parse

type ComponentNode ¶

type ComponentNode struct {
	NodeType
	List *ListNode
}

ComponentNode holds a list of nodes that are components of one another. Like a person's first and last name can be components.

func (c *ComponentNode) String() string

type DataNode ¶

type DataNode struct {
	NodeType
	Node Node
}

DataNode holds a single node. It's basically an encapsulation to follow the spec.

func (c *DataNode) String() string

type HeaderNode ¶

type HeaderNode struct {
	NodeType
	SegmentName Node
	Text        Node
}

A header node holds the UNA header and the configuration text.

func (h *HeaderNode) String() string

type ListNode ¶

type ListNode struct {
	NodeType
	Nodes []Node // The element nodes in lexical order.
}

ListNode holds a sequence of nodes.

func Parse(text string) (listnode *ListNode, err error)

func (l *ListNode) String() string

func (l *ListNode) StringDelim(delim string) string

type Node ¶

type Node interface {
	Type() NodeType
	String() string
}

A Node is an element in the parse tree. The interface is trivial. The interface contains an unexported method so that only types local to this package can satisfy it.

type NodeStack ¶

type NodeStack []Node

type NodeType ¶

type NodeType int

NodeType identifies the type of a parse tree node.

const (
	NodeList       NodeType = iota // A list of Nodes.
	NodeHeader                     // The UNA header node.
	NodeSegment                    // A segment node.
	NodeData                       // A data node.
	NodeText                       // Plain text.
	NodeComponent                  // A component node.
	NodeRepetition                 // A repetition node.
)

func (t NodeType) Type() NodeType

type RepetitionNode ¶

type RepetitionNode struct {
	NodeType
	List *ListNode
}

RepetitionNode holds a list of nodes that are repetitions. For example, a start and end date could be repetitions.

func (r *RepetitionNode) String() string

type SegmentNode ¶

type SegmentNode struct {
	NodeType
	List *ListNode
}

SegmentNode holds a list of nodes (only DataNodes) that signify an entire segment. The segment name is specified in the first DataNode of the list.

func (s *SegmentNode) String() string

type TextNode ¶

type TextNode struct {
	NodeType
	Text []byte // The text; may span newlines.
}

TextNode holds plain text.

func (t *TextNode) String() string

type Tree ¶

type Tree struct {
	Root *ListNode // top-level root of the tree.
	// contains filtered or unexported fields
}

Tree is the representation of a single parsed template.