Documentation

Overview

    package jsonpath is a template engine using jsonpath syntax, which can be seen at http://goessner.net/articles/JsonPath/. In addition, it has {range} {end} function to iterate list and slice.

    Index

    Constants

    This section is empty.

    Variables

    View Source
    var NodeTypeName = map[NodeType]string{
    	NodeText:       "NodeText",
    	NodeArray:      "NodeArray",
    	NodeList:       "NodeList",
    	NodeField:      "NodeField",
    	NodeIdentifier: "NodeIdentifier",
    	NodeFilter:     "NodeFilter",
    	NodeInt:        "NodeInt",
    	NodeFloat:      "NodeFloat",
    	NodeWildcard:   "NodeWildcard",
    	NodeRecursive:  "NodeRecursive",
    	NodeUnion:      "NodeUnion",
    	NodeBool:       "NodeBool",
    }

    Functions

    This section is empty.

    Types

    type ArrayNode

    type ArrayNode struct {
    	NodeType
    	Params [3]ParamsEntry //start, end, step
    }

      ArrayNode holds start, end, step information for array index selection

      func (*ArrayNode) String

      func (a *ArrayNode) String() string

      type BoolNode

      type BoolNode struct {
      	NodeType
      	Value bool
      }

        BoolNode holds bool value

        func (*BoolNode) String

        func (b *BoolNode) String() string

        type FieldNode

        type FieldNode struct {
        	NodeType
        	Value string
        }

          FieldNode holds field of struct

          func (*FieldNode) String

          func (f *FieldNode) String() string

          type FilterNode

          type FilterNode struct {
          	NodeType
          	Left     *ListNode
          	Right    *ListNode
          	Operator string
          }

            FilterNode holds operand and operator information for filter

            func (*FilterNode) String

            func (f *FilterNode) String() string

            type FloatNode

            type FloatNode struct {
            	NodeType
            	Value float64
            }

              FloatNode holds float value

              func (*FloatNode) String

              func (i *FloatNode) String() string

              type IdentifierNode

              type IdentifierNode struct {
              	NodeType
              	Name string
              }

                IdentifierNode holds an identifier

                func (*IdentifierNode) String

                func (f *IdentifierNode) String() string

                type IntNode

                type IntNode struct {
                	NodeType
                	Value int
                }

                  IntNode holds integer value

                  func (*IntNode) String

                  func (i *IntNode) String() string

                  type JSONPath

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

                  func New

                  func New(name string) *JSONPath

                  func (*JSONPath) AllowMissingKeys

                  func (j *JSONPath) AllowMissingKeys(allow bool) *JSONPath

                    AllowMissingKeys allows a caller to specify whether they want an error if a field or map key cannot be located, or simply an empty result. The receiver is returned for chaining.

                    func (*JSONPath) Execute

                    func (j *JSONPath) Execute(wr io.Writer, data interface{}) error

                      Execute bounds data into template and write the result

                      func (*JSONPath) FindResults

                      func (j *JSONPath) FindResults(data interface{}) ([][]reflect.Value, error)

                      func (*JSONPath) Parse

                      func (j *JSONPath) Parse(text string) (err error)

                        Parse parse the given template, return error

                        func (*JSONPath) PrintResults

                        func (j *JSONPath) PrintResults(wr io.Writer, results []reflect.Value) error

                          PrintResults write the results into writer

                          type ListNode

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

                            ListNode holds a sequence of nodes.

                            func (*ListNode) String

                            func (l *ListNode) String() string

                            type Node

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

                            type NodeType

                            type NodeType int

                              NodeType identifies the type of a parse tree node.

                              const (
                              	NodeText NodeType = iota
                              	NodeArray
                              	NodeList
                              	NodeField
                              	NodeIdentifier
                              	NodeFilter
                              	NodeInt
                              	NodeFloat
                              	NodeWildcard
                              	NodeRecursive
                              	NodeUnion
                              	NodeBool
                              )

                              func (NodeType) String

                              func (t NodeType) String() string

                              func (NodeType) Type

                              func (t NodeType) Type() NodeType

                                Type returns itself and provides an easy default implementation

                                type ParamsEntry

                                type ParamsEntry struct {
                                	Value int
                                	Known bool //whether the value is known when parse it
                                }

                                  ParamsEntry holds param information for ArrayNode

                                  type Parser

                                  type Parser struct {
                                  	Name string
                                  	Root *ListNode
                                  	// contains filtered or unexported fields
                                  }

                                  func NewParser

                                  func NewParser(name string) *Parser

                                  func Parse

                                  func Parse(name, text string) (*Parser, error)

                                    Parse parsed the given text and return a node Parser. If an error is encountered, parsing stops and an empty Parser is returned with the error

                                    func (*Parser) Parse

                                    func (p *Parser) Parse(text string) error

                                    type RecursiveNode

                                    type RecursiveNode struct {
                                    	NodeType
                                    }

                                      RecursiveNode means a recursive descent operator

                                      func (*RecursiveNode) String

                                      func (r *RecursiveNode) String() string

                                      type TextNode

                                      type TextNode struct {
                                      	NodeType
                                      	Text string // The text; may span newlines.
                                      }

                                        TextNode holds plain text.

                                        func (*TextNode) String

                                        func (t *TextNode) String() string

                                        type UnionNode

                                        type UnionNode struct {
                                        	NodeType
                                        	Nodes []*ListNode
                                        }

                                          UnionNode is union of ListNode

                                          func (*UnionNode) String

                                          func (u *UnionNode) String() string

                                          type WildcardNode

                                          type WildcardNode struct {
                                          	NodeType
                                          }

                                            WildcardNode means a wildcard

                                            func (*WildcardNode) String

                                            func (i *WildcardNode) String() string