provider

type CleanupFunc func()

type ErrInvalidProviderType struct {
	Name           string
	Type           providerType
	KnownProviders []string
}

type ErrInvalidRegisteredProvider struct {
	Name string
}

type ErrProviderAlreadyExists struct {
	Name string
}

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

type ErrUnknownProvider struct {
	Name           string
	KnownProviders []string
}

type Feature struct {
	ID       uint64
	Geometry geom.Geometry
	SRID     uint64
	Tags     map[string]interface{}
}

type InitFunc func(dicter dict.Dicter, maps []Map) (Tiler, error)

type Layer struct {
	// Name is the name of the Layer as recognized by the provider
	Name string
	// MVTName is the name of the layer to encode into the MVT.
	// this is often used when different provider layers are used
	// at different zoom levels but the MVT layer name is consistent
	MVTName string
}

type LayerInfo interface {
	// Name is the name of the layer
	Name() string
	// GeomType is the geometry type of the layer
	GeomType() geom.Geometry
	// SRID is the srid of all the points in the layer
	SRID() uint64
}

type Layerer interface {
	// Layers returns information about the various layers the provider supports
	Layers() ([]LayerInfo, error)
}

type MVTInitFunc func(dicter dict.Dicter, maps []Map) (MVTTiler, error)

type MVTTiler interface {
	Layerer

	// MVTForLayers will return a MVT byte array or an error for the given layer names.
	MVTForLayers(ctx context.Context, tile Tile, params Params, layers []Layer) ([]byte, error)
}

type Map struct {
	Name        env.String       `toml:"name"`
	Attribution env.String       `toml:"attribution"`
	Bounds      []env.Float      `toml:"bounds"`
	Center      [3]env.Float     `toml:"center"`
	Layers      []MapLayer       `toml:"layers"`
	Parameters  []QueryParameter `toml:"params"`
	TileBuffer  *env.Int         `toml:"tile_buffer"`
}

type MapLayer struct {
	// Name is optional. If it's not defined the name of the ProviderLayer will be used.
	// Name can also be used to group multiple ProviderLayers under the same namespace.
	Name          env.String `toml:"name"`
	ProviderLayer env.String `toml:"provider_layer"`
	MinZoom       *env.Uint  `toml:"min_zoom"`
	MaxZoom       *env.Uint  `toml:"max_zoom"`
	DefaultTags   env.Dict   `toml:"default_tags"`
	// DontSimplify indicates whether feature simplification should be applied.
	// We use a negative in the name so the default is to simplify
	DontSimplify env.Bool `toml:"dont_simplify"`
	// DontClip indicates whether feature clipping should be applied.
	// We use a negative in the name so the default is to clipping
	DontClip env.Bool `toml:"dont_clip"`
	// DontClip indicates whether feature cleaning (e.g. make valid) should be applied.
	// We use a negative in the name so the default is to clean
	DontClean env.Bool `toml:"dont_clean"`
}

type Params map[string]QueryParameterValue

type QueryParameter struct {
	Name  string `toml:"name"`
	Token string `toml:"token"`
	Type  string `toml:"type"`
	SQL   string `toml:"sql"`
	// DefaultSQL replaces SQL if param wasn't passed. Either default_sql or
	// default_value can be specified
	DefaultSQL   string `toml:"default_sql"`
	DefaultValue string `toml:"default_value"`
}

type QueryParameterValue struct {
	// Token to replace e.g., !TOKEN!
	Token string
	// SQL expression to be inserted. Contains "?" that will be replaced with an
	//  ordinal argument e.g., "$1"
	SQL string
	// Value that will be passed to the final query in arguments list
	Value interface{}
	// Raw parameter and value for debugging and monitoring
	RawParam string
	// RawValue will be "" if the param wasn't passed and defaults were used
	RawValue string
}

type Tile interface {
	// ZXY returns the z, x and y values of the tile
	ZXY() (uint, uint, uint)
	// Extent returns the extent of the tile excluding any buffer
	Extent() (extent *geom.Extent, srid uint64)
	// BufferedExtent returns the extent of the tile including any buffer
	BufferedExtent() (extent *geom.Extent, srid uint64)
}

type Tiler interface {
	Layerer

	// TileFeature will stream decoded features to the callback function fn
	// if fn returns ErrCanceled, the TileFeatures method should stop processing
	TileFeatures(ctx context.Context, layer string, t Tile, params Params, fn func(f *Feature) error) error
}

type TilerUnion struct {
	Std Tiler
	Mvt MVTTiler
}