134 lines
3.2 KiB
Go
134 lines
3.2 KiB
Go
package command
|
|
|
|
func (g *Graph) AppendLiteral(child *Literal) *Graph {
|
|
g.nodes[0].Children = append(g.nodes[0].Children, child.index)
|
|
return g
|
|
}
|
|
|
|
// Literal create a new LiteralNode in the Graph.
|
|
func (g *Graph) Literal(str string) LiteralBuilder {
|
|
index := int32(len(g.nodes))
|
|
g.nodes = append(g.nodes, &Node{
|
|
g: g,
|
|
index: index,
|
|
kind: LiteralNode,
|
|
Name: str,
|
|
})
|
|
return LiteralBuilder{current: g.nodes[index]}
|
|
}
|
|
|
|
// Argument create a new ArgumentNode in the Graph.
|
|
func (g *Graph) Argument(name string, parser Parser) ArgumentBuilder {
|
|
index := int32(len(g.nodes))
|
|
g.nodes = append(g.nodes, &Node{
|
|
g: g,
|
|
index: index,
|
|
kind: ArgumentNode,
|
|
Name: name,
|
|
Parser: parser,
|
|
})
|
|
return ArgumentBuilder{current: g.nodes[index]}
|
|
}
|
|
|
|
type LiteralBuilder struct {
|
|
current *Node
|
|
}
|
|
|
|
func (n LiteralBuilder) AppendLiteral(node *Literal) LiteralBuilderWithLiteral {
|
|
n.current.Children = append(n.current.Children, node.index)
|
|
return LiteralBuilderWithLiteral{n: n}
|
|
}
|
|
|
|
func (n LiteralBuilder) AppendArgument(node *Argument) LiteralBuilderWithArgument {
|
|
n.current.Children = append(n.current.Children, node.index)
|
|
return LiteralBuilderWithArgument{n: n}
|
|
}
|
|
|
|
func (n LiteralBuilder) HandleFunc(f HandlerFunc) *Literal {
|
|
n.current.Run = f
|
|
return (*Literal)(n.current)
|
|
}
|
|
|
|
func (n LiteralBuilder) Unhandle() *Literal {
|
|
return n.HandleFunc(unhandledCmd)
|
|
}
|
|
|
|
type ArgumentBuilder struct {
|
|
current *Node
|
|
}
|
|
|
|
func (n ArgumentBuilder) AppendLiteral(node *Literal) ArgumentBuilderWithLiteral {
|
|
n.current.Children = append(n.current.Children, node.index)
|
|
return ArgumentBuilderWithLiteral{n: n}
|
|
}
|
|
|
|
func (n ArgumentBuilder) AppendArgument(node *Argument) ArgumentBuilderWithArgument {
|
|
n.current.Children = append(n.current.Children, node.index)
|
|
return ArgumentBuilderWithArgument{n: n}
|
|
}
|
|
|
|
func (n ArgumentBuilder) HandleFunc(f HandlerFunc) *Argument {
|
|
n.current.Run = f
|
|
return (*Argument)(n.current)
|
|
}
|
|
|
|
func (n ArgumentBuilder) Unhandle() *Argument {
|
|
return n.HandleFunc(unhandledCmd)
|
|
}
|
|
|
|
type LiteralBuilderWithLiteral struct {
|
|
n LiteralBuilder
|
|
}
|
|
|
|
func (n LiteralBuilderWithLiteral) AppendLiteral(node *Literal) LiteralBuilderWithLiteral {
|
|
return n.n.AppendLiteral(node)
|
|
}
|
|
|
|
func (n LiteralBuilderWithLiteral) HandleFunc(f HandlerFunc) *Literal {
|
|
return n.n.HandleFunc(f)
|
|
}
|
|
|
|
func (n LiteralBuilderWithLiteral) Unhandle() *Literal {
|
|
return n.n.Unhandle()
|
|
}
|
|
|
|
type LiteralBuilderWithArgument struct {
|
|
n LiteralBuilder
|
|
}
|
|
|
|
func (n LiteralBuilderWithArgument) HandleFunc(f HandlerFunc) *Literal {
|
|
return n.n.HandleFunc(f)
|
|
}
|
|
|
|
func (n LiteralBuilderWithArgument) Unhandle() *Literal {
|
|
return n.n.Unhandle()
|
|
}
|
|
|
|
type ArgumentBuilderWithLiteral struct {
|
|
n ArgumentBuilder
|
|
}
|
|
|
|
func (n ArgumentBuilderWithLiteral) AppendLiteral(node *Literal) ArgumentBuilderWithLiteral {
|
|
return n.n.AppendLiteral(node)
|
|
}
|
|
|
|
func (n ArgumentBuilderWithLiteral) HandleFunc(f HandlerFunc) *Argument {
|
|
return n.n.HandleFunc(f)
|
|
}
|
|
|
|
func (n ArgumentBuilderWithLiteral) Unhandle() *Argument {
|
|
return n.n.Unhandle()
|
|
}
|
|
|
|
type ArgumentBuilderWithArgument struct {
|
|
n ArgumentBuilder
|
|
}
|
|
|
|
func (n ArgumentBuilderWithArgument) HandleFunc(f HandlerFunc) *Argument {
|
|
return n.n.HandleFunc(f)
|
|
}
|
|
|
|
func (n ArgumentBuilderWithArgument) Unhandle() *Argument {
|
|
return n.n.Unhandle()
|
|
}
|