tilenol

type Cache interface {
	// Exists determines whether or not there is a cache value for the given key
	Exists(key string) bool
	// Get retrieves the cached data given a key
	Get(key string) ([]byte, error)
	// Put stores a new value in the cache at a given key
	Put(key string, val []byte) error
}

type CacheConfig struct {
	// Redis is an optional YAML key for configuring a RedisCache
	Redis *RedisConfig `yaml:"redis"`
}

type Config struct {
	// Cache configures the tile server cache
	Cache *CacheConfig `yaml:"cache"`
	// Layers configures the tile server layers
	Layers []LayerConfig `yaml:"layers"`
}

type ConfigOption func(s *Server) error

type Dict map[string]interface{}

type DumbScanner struct {
	Value interface{}
}

type ElasticsearchConfig struct {
	// Host is the hostname part of the backend Elasticsearch cluster
	Host string `yaml:"host"`
	// Host is the port number of the backend Elasticsearch cluster
	Port int `yaml:"port"`
	// Index is the name of the Elasticsearch index used for retrieving feature data
	Index string `yaml:"index"`
	// GeometryField is the name of the document field that holds the feature geometry
	GeometryField string `yaml:"geometryField"`
	// SourceFields is a mapping from the feature property name to the source document
	// field name
	SourceFields map[string]string `yaml:"sourceFields"`
}

type ElasticsearchSource struct {
	// ES is the internal Elasticsearch cluster client
	ES *elastic.Client
	// Index is the name of the Elasticsearch index used for retrieving feature data
	Index string
	// GeometryField is the name of the document field that holds the feature geometry
	GeometryField string
	// SourceFields is a mapping from the feature property name to the source document
	// field name
	SourceFields map[string]string
}

type Handler func(context.Context, io.Writer, *http.Request) error

type InMemoryCache struct {
	// contains filtered or unexported fields
}

type InvalidRequestError struct {
	// contains filtered or unexported fields
}

type Layer struct {
	Name        string
	Description string
	Minzoom     int
	Maxzoom     int
	Cacheable   bool
	// contains filtered or unexported fields
}

type LayerConfig struct {
	// Name is the effective name of the layer
	Name string `yaml:"name"`
	// Description is an optional short descriptor of the layer
	Description string `yaml:"description"`
	// Minzoom specifies the minimum z value for the layer
	Minzoom int `yaml:"minzoom"`
	// Maxzoom specifies the maximum z value for the layer
	Maxzoom int `yaml:"maxzoom"`
	// NoCache indicates that this layer should not cache its source data
	NoCache bool `yaml:"nocache"`
	// Source configures the underlying Source for the layer
	Source SourceConfig `yaml:"source"`
}

type NilCache struct{}

type NilSource struct{}

type PostGISConfig struct {
	// DSN is the "data source name" that specifies how to connect to the database server
	DSN string `yaml:"dsn"`
	// Schema is the table space to use for queries
	Schema string `yaml:"schema"`
	// Table is the name of the table to use for queries
	Table string `yaml:"table"`
	// TableExpression is a valid SQL query that is used as an alternative to Schema and Table
	TableExpression string `yaml:"tableExpression"`
	// GeometryField is the name of the column that holds the feature geometry
	GeometryField string `yaml:"geometryField"`
	// SourceFields is a mapping from the feature property name to the source row
	// column names
	SourceFields map[string]string `yaml:"sourceFields"`
}

type PostGISSource struct {
	DB            *goqu.Database
	Dataset       *goqu.SelectDataset
	GeometryField string
	SourceFields  map[string]string
}

type RedisCache struct {
	// Client is the backend Redis cluster client
	Client *redis.Client
	// TTL is how long each cache entry should remain before refresh
	TTL time.Duration
}

type RedisConfig struct {
	// Host is the Redis cluster host name
	Host string `yaml:"host"`
	// Port is the Redis cluster port number
	Port int `yaml:"port"`
	// TTL is how long each cache entry should remain before refresh
	TTL time.Duration `yaml:"ttl"`
}

type Server struct {
	// Port is the port number to bind the tile server
	Port uint16
	// InternalPort is the port number to bind the internal metrics endpoints
	InternalPort uint16
	// EnableCORS configures whether or not the tile server responds with CORS headers
	EnableCORS bool
	// Simplify configures whether or not the tile server simplifies outgoing feature
	// geometries based on zoom level
	Simplify bool
	// Layers is the list of configured layers supported by the tile server
	Layers []Layer
	// Cache is an optional cache object that the server uses to cache responses
	Cache Cache
}

type Source interface {
	// GetFeatures retrieves the GeoJSON FeatureCollection for the given request
	GetFeatures(context.Context, *TileRequest) (*geojson.FeatureCollection, error)
}

type SourceConfig struct {
	// Elasticsearch is an optional YAML key for configuring an ElasticsearchConfig
	Elasticsearch *ElasticsearchConfig `yaml:"elasticsearch"`
	// PostGIS is an optional YAML key for configuring a PostGISConfig
	PostGIS *PostGISConfig `yaml:"postgis"`
}

type TileRequest struct {
	X    int
	Y    int
	Z    int
	Args map[string][]string
}