mapping

type Areas struct {
	AreaTags   []Key `yaml:"area_tags"`
	LinearTags []Key `yaml:"linear_tags"`
}

type DestTable struct {
	Name       string
	SubMapping string
}

type ElementFilter func(tags element.Tags, key Key, closed bool) bool

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

type Field struct {
	Name       string                 `yaml:"name"`
	Key        Key                    `yaml:"key"`
	Keys       []Key                  `yaml:"keys"`
	Type       string                 `yaml:"type"`
	Args       map[string]interface{} `yaml:"args"`
	FromMember bool                   `yaml:"from_member"`
}

type FieldSpec struct {
	Key  Key
	Type FieldType
}

type FieldType struct {
	Name       string
	GoType     string
	Func       MakeValue
	MakeFunc   MakeMakeValue
	MemberFunc MakeMemberValue
	FromMember bool
}

type Filters struct {
	ExcludeTags *[][]string `yaml:"exclude_tags"`
}

type GeneralizedTable struct {
	Name            string
	SourceTableName string  `yaml:"source"`
	Tolerance       float64 `yaml:"tolerance"`
	SqlFilter       string  `yaml:"sql_filter"`
}

type GeneralizedTables map[string]*GeneralizedTable

type Key string

type KeyValues map[Key][]orderedValue

type MakeMakeValue func(string, FieldType, Field) (MakeValue, error)

type MakeMemberValue func(*element.Relation, *element.Member, Match) interface{}

type MakeValue func(string, *element.OSMElem, *geom.Geometry, Match) interface{}

type Mapping struct {
	Tables            Tables            `yaml:"tables"`
	GeneralizedTables GeneralizedTables `yaml:"generalized_tables"`
	Tags              Tags              `yaml:"tags"`
	Areas             Areas             `yaml:"areas"`
	// SingleIdSpace mangles the overlapping node/way/relation IDs
	// to be unique (nodes positive, ways negative, relations negative -1e17)
	SingleIdSpace bool `yaml:"use_single_id_space"`
}

type Match struct {
	Key   string
	Value string
	Table DestTable
	// contains filtered or unexported fields
}

type NodeMatcher interface {
	MatchNode(node *element.Node) []Match
}

type OrderedDestTable struct {
	DestTable
	// contains filtered or unexported fields
}

type RelWayMatcher interface {
	WayMatcher
	RelationMatcher
}

type RelationMatcher interface {
	MatchRelation(rel *element.Relation) []Match
}

type RelationTagFilter struct {
	TagFilter
}

type SubMapping struct {
	Mapping KeyValues
}

type Table struct {
	Name         string
	Type         TableType             `yaml:"type"`
	Mapping      KeyValues             `yaml:"mapping"`
	Mappings     map[string]SubMapping `yaml:"mappings"`
	TypeMappings TypeMappings          `yaml:"type_mappings"`
	Fields       []*Field              `yaml:"columns"` // TODO rename Fields internaly to Columns
	OldFields    []*Field              `yaml:"fields"`
	Filters      *Filters              `yaml:"filters"`
}

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

type TableType string

type Tables map[string]*Table

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

type TagFilterer interface {
	Filter(tags *element.Tags) bool
}

type TagTables map[Key]map[Value][]OrderedDestTable

type Tags struct {
	LoadAll bool  `yaml:"load_all"`
	Exclude []Key `yaml:"exclude"`
	Include []Key `yaml:"include"`
}

type TypeMappings struct {
	Points      KeyValues `yaml:"points"`
	LineStrings KeyValues `yaml:"linestrings"`
	Polygons    KeyValues `yaml:"polygons"`
}

type Value string

type WayMatcher interface {
	MatchWay(way *element.Way) []Match
}