README

jsonpath

This repository has been forked from https://github.com/kubernetes/client-go/tree/v0.21.0/util/jsonpath

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 (
    	ErrSyntax = errors.New("invalid syntax")
    )
    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

    func UnquoteExtend

    func UnquoteExtend(s string) (string, error)

      UnquoteExtend is almost same as strconv.Unquote(), but it support parse single quotes as a string

      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

                      New creates a new JSONPath with the given name.

                      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) EnableJSONOutput

                        func (j *JSONPath) EnableJSONOutput(v bool)

                          EnableJSONOutput changes the PrintResults behavior to return a JSON array of results

                          func (*JSONPath) Execute

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

                            Execute bounds data into template and writes the result.

                            func (*JSONPath) FindResults

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

                            func (*JSONPath) Parse

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

                              Parse parses the given template and returns an error.

                              func (*JSONPath) PrintResults

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

                                PrintResults writes 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
                                      	Derived bool
                                      }

                                        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

                                                  Directories

                                                  Path Synopsis
                                                  third_party
                                                  forked/golang/template
                                                  This package is copied from Go library text/template.
                                                  This package is copied from Go library text/template.