fx/node.go

package main

import (
	"strconv"
)

type node struct {
	prev, next, end *node
	directParent    *node
	indirectParent  *node
	collapsed       *node
	depth           uint8
	key             []byte
	value           []byte
	chunk           []byte
	chunkEnd        *node
	comma           bool
	index           int
}

func (n *node) append(child *node) {
	if n.end == nil {
		n.end = n
	}
	n.end.next = child
	child.prev = n.end
	if child.end == nil {
		n.end = child
	} else {
		n.end = child.end
	}
}

func (n *node) insertChunk(chunk *node) {
	if n.chunkEnd == nil {
		n.insertAfter(chunk)
	} else {
		n.chunkEnd.insertAfter(chunk)
	}
	n.chunkEnd = chunk
}

func (n *node) insertAfter(child *node) {
	if n.next == nil {
		n.next = child
		child.prev = n
	} else {
		old := n.next
		n.next = child
		child.prev = n
		child.next = old
		old.prev = child
	}
}

func (n *node) dropChunks() {
	if n.chunkEnd == nil {
		return
	}

	n.chunk = nil

	n.next = n.chunkEnd.next
	if n.next != nil {
		n.next.prev = n
	}

	n.chunkEnd = nil
}

func (n *node) hasChildren() bool {
	return n.end != nil
}

func (n *node) parent() *node {
	if n.directParent == nil {
		return nil
	}
	parent := n.directParent
	if parent.indirectParent != nil {
		parent = parent.indirectParent
	}
	return parent
}

func (n *node) isCollapsed() bool {
	return n.collapsed != nil
}

func (n *node) collapse() *node {
	if n.end != nil && !n.isCollapsed() {
		n.collapsed = n.next
		n.next = n.end.next
		if n.next != nil {
			n.next.prev = n
		}
	}
	return n
}

func (n *node) collapseRecursively() {
	var at *node
	if n.isCollapsed() {
		at = n.collapsed
	} else {
		at = n.next
	}
	for at != nil && at != n.end {
		if at.hasChildren() {
			at.collapseRecursively()
			at.collapse()
		}
		at = at.next
	}
}

func (n *node) expand() {
	if n.isCollapsed() {
		if n.next != nil {
			n.next.prev = n.end
		}
		n.next = n.collapsed
		n.collapsed = nil
	}
}

func (n *node) expandRecursively() {
	at := n
	for at != nil && at != n.end {
		at.expand()
		at = at.next
	}
}

func (n *node) findChildByKey(key string) *node {
	it := n.next
	for it != nil && it != n.end {
		if it.key != nil {
			k, err := strconv.Unquote(string(it.key))
			if err != nil {
				return nil
			}
			if k == key {
				return it
			}
		}
		if it.chunkEnd != nil {
			it = it.chunkEnd.next
		} else if it.end != nil {
			it = it.end.next
		} else {
			it = it.next
		}
	}
	return nil
}

func (n *node) findChildByIndex(index int) *node {
	for at := n.next; at != nil && at != n.end; {
		if at.index == index {
			return at
		}
		if at.end != nil {
			at = at.end.next
		} else {
			at = at.next
		}
	}
	return nil
}

func (n *node) paths(prefix string, paths *[]string, nodes *[]*node) {
	it := n.next
	for it != nil && it != n.end {
		var path string

		if it.key != nil {
			quoted := string(it.key)
			unquoted, err := strconv.Unquote(quoted)
			if err != nil {
				panic(err)
			}
			if identifier.MatchString(unquoted) {
				path = prefix + "." + unquoted
			} else {
				path = prefix + "[" + quoted + "]"
			}
		} else if it.index >= 0 {
			path = prefix + "[" + strconv.Itoa(it.index) + "]"
		}

		*paths = append(*paths, path)
		*nodes = append(*nodes, it)

		if it.hasChildren() {
			it.paths(path, paths, nodes)
			it = it.end.next
		} else {
			it = it.next
		}
	}
}

func (n *node) children() ([]string, []*node) {
	if !n.hasChildren() {
		return nil, nil
	}

	var paths []string
	var nodes []*node

	var it *node
	if n.isCollapsed() {
		it = n.collapsed
	} else {
		it = n.next
	}

	for it != nil && it != n.end {
		if it.key != nil {
			unquoted, err := strconv.Unquote(string(it.key))
			if err != nil {
				panic(err)
			}
			paths = append(paths, unquoted)
			nodes = append(nodes, it)
		}

		if it.hasChildren() {
			it = it.end.next
		} else {
			it = it.next
		}
	}

	return paths, nodes
}