dom

type Container interface {
	Node
	// Children returns mapping between child name and its corresponding Node
	Children() map[string]Node
	// Child returns single child Node by its name
	Child(name string) Node
	// Lookup attempts to find child Node at given path
	Lookup(path string) Node
	// Flatten flattens this Container into list of leaves
	Flatten() map[string]Leaf
	// Search finds all paths where Node's value is equal to given value according to provided SearchValueFunc.
	// If no match is found, nil is returned.
	Search(fn SearchValueFunc) []string
}

type ContainerBuilder interface {
	Container
	Serializable
	// AddValue adds Node value into this Container
	AddValue(name string, value Node)
	// AddValueAt adds Leaf value into this Container at given path.
	// Child nodes are creates as needed.
	AddValueAt(path string, value Node)
	// AddContainer adds child Container into this Container
	AddContainer(name string) ContainerBuilder
	// AddList adds child List into this Container
	AddList(name string) ListBuilder
	// Remove removes direct child Node.
	Remove(name string)
	// RemoveAt removes child Node at given path.
	RemoveAt(path string)
	// Walk walks whole document tree, visiting every node
	Walk(fn WalkFn)
}

type ContainerFactory interface {
	// Container creates empty ContainerBuilder
	Container() ContainerBuilder
	// FromReader creates ContainerBuilder pre-populated with data from provided io.Reader and DecoderFunc
	FromReader(r io.Reader, fn DecoderFunc) (ContainerBuilder, error)
	// FromMap creates ContainerBuilder pre-populated with data from provided map
	FromMap(in map[string]interface{}) ContainerBuilder
	// FromAny creates ContainerBuilder from any object. Any error encountered in process will result in panic.
	// This method uses YAML codec internally to perform translation between raw interface and map
	FromAny(v interface{}) ContainerBuilder
}

type Coordinate interface {
	// Layer returns name of layer within OverlayDocument
	Layer() string
	// Path returns path to Node within layer
	Path() string
}

type Coordinates []Coordinate

type DecoderFunc func(r io.Reader, v interface{}) error

type EncoderFunc func(w io.Writer, v interface{}) error

type Leaf interface {
	Node
	Value() interface{}
}

type List interface {
	Node
	// Size returns current count of items in this list
	Size() int
	// Items returns copy of slice of all nodes in this list
	Items() []Node
}

type ListBuilder interface {
	List
	// Clear sets items to empty slice
	Clear()
	// Set sets item at given index. Items are allocated and set to nil Leaf as necessary.
	Set(uint, Node)
	// MustSet sets item at given index. Panics if index is out of bounds.
	MustSet(uint, Node)
	// Append adds new item at the end of slice
	Append(Node)
}

type MergeOption func(*merger)

type Node interface {
	// IsContainer returns true if this node is Container
	IsContainer() bool
	// IsList returns true if this node is List
	IsList() bool
	// IsLeaf returns true if this node is Leaf
	IsLeaf() bool
	// SameAs returns true if this node is of same type like other node.
	// The other Node can be nil, in which case return value is false.
	SameAs(Node) bool
	// Equals return true is value of this node is equal to value of provided Node.
	Equals(Node) bool
	// Clone returns deep copy of this Node.
	Clone() Node
}

type NodeList []Node

type NodeMappingFunc func(Container) interface{}

type OverlayDocument interface {
	Serializable
	// Lookup lookups data in given overlay and path
	// if no node is present at any level, nil is returned
	Lookup(overlay, path string) Node
	// LookupAny lookups data in all overlays (in creation order) and path.
	// if no node is present at any level, nil is returned
	LookupAny(path string) Node
	// Search finds all occurrences of given value in all layers using custom SearchValueFunc
	Search(fn SearchValueFunc) Coordinates
	// Populate puts dictionary into overlay at given path
	Populate(overlay, path string, data *map[string]interface{})
	// Put puts Node value into overlay at given path
	Put(overlay, path string, value Node)
	// Merged returns read-only, merged view of all overlays
	Merged(option ...MergeOption) Container
	// Layers return copy of list with all layer names
	Layers() []string
}

type SearchValueFunc func(val interface{}) bool

type Serializable interface {
	// Serialize writes content into given writer, while encoding using provided EncoderFunc
	Serialize(writer io.Writer, mappingFunc NodeMappingFunc, encFn EncoderFunc) error
}

type WalkFn func(path string, parent ContainerBuilder, node Node) bool