type KeyString … type Decoder … // NewDecoder creates a new instance of the extended JSON Decoder. func NewDecoder(r io.Reader) *Decoder { … } // SeekTo causes the Decoder to move forward to a given path in the JSON structure. // // The path argument must consist of strings or integers. Each string specifies an JSON object key, and // each integer specifies an index into a JSON array. // // Consider the JSON structure // // { "a": [0,"s",12e4,{"b":0,"v":35} ] } // // SeekTo("a",3,"v") will move to the value referenced by the "a" key in the current object, // followed by a move to the 4th value (index 3) in the array, followed by a move to the value at key "v". // In this example, a subsequent call to the decoder's Decode() would unmarshal the value 35. // // SeekTo returns a boolean value indicating whether a match was found. // // Decoder is intended to be used with a stream of tokens. As a result it navigates forward only. func (d *Decoder) SeekTo(path ...interface{ … } // Decode reads the next JSON-encoded value from its input and stores it in the value pointed to by v. This is // equivalent to encoding/json.Decode(). func (d *Decoder) Decode(v interface{ … } // Path returns a slice of string and/or int values representing the path from the root of the JSON object to the // position of the most-recently parsed token. func (d *Decoder) Path() JsonPath { … } // Token is equivalent to the Token() method on json.Decoder. The primary difference is that it distinguishes // between strings that are keys and and strings that are values. String tokens that are object keys are returned as a // KeyString rather than as a native string. func (d *Decoder) Token() (json.Token, error) { … } // Scan moves forward over the JSON stream consuming all the tokens at the current level (current object, current array) // invoking each matching PathAction along the way. // // Scan returns true if there are more contiguous values to scan (for example in an array). func (d *Decoder) Scan(ext *PathActions) (bool, error) { … }