summaryrefslogtreecommitdiff
path: root/vendor/github.com/buger/jsonparser/parser.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/buger/jsonparser/parser.go')
-rw-r--r--vendor/github.com/buger/jsonparser/parser.go1283
1 files changed, 0 insertions, 1283 deletions
diff --git a/vendor/github.com/buger/jsonparser/parser.go b/vendor/github.com/buger/jsonparser/parser.go
deleted file mode 100644
index 14b80bc48..000000000
--- a/vendor/github.com/buger/jsonparser/parser.go
+++ /dev/null
@@ -1,1283 +0,0 @@
-package jsonparser
-
-import (
- "bytes"
- "errors"
- "fmt"
- "strconv"
-)
-
-// Errors
-var (
- KeyPathNotFoundError = errors.New("Key path not found")
- UnknownValueTypeError = errors.New("Unknown value type")
- MalformedJsonError = errors.New("Malformed JSON error")
- MalformedStringError = errors.New("Value is string, but can't find closing '\"' symbol")
- MalformedArrayError = errors.New("Value is array, but can't find closing ']' symbol")
- MalformedObjectError = errors.New("Value looks like object, but can't find closing '}' symbol")
- MalformedValueError = errors.New("Value looks like Number/Boolean/None, but can't find its end: ',' or '}' symbol")
- OverflowIntegerError = errors.New("Value is number, but overflowed while parsing")
- MalformedStringEscapeError = errors.New("Encountered an invalid escape sequence in a string")
-)
-
-// How much stack space to allocate for unescaping JSON strings; if a string longer
-// than this needs to be escaped, it will result in a heap allocation
-const unescapeStackBufSize = 64
-
-func tokenEnd(data []byte) int {
- for i, c := range data {
- switch c {
- case ' ', '\n', '\r', '\t', ',', '}', ']':
- return i
- }
- }
-
- return len(data)
-}
-
-func findTokenStart(data []byte, token byte) int {
- for i := len(data) - 1; i >= 0; i-- {
- switch data[i] {
- case token:
- return i
- case '[', '{':
- return 0
- }
- }
-
- return 0
-}
-
-func findKeyStart(data []byte, key string) (int, error) {
- i := 0
- ln := len(data)
- if ln > 0 && (data[0] == '{' || data[0] == '[') {
- i = 1
- }
- var stackbuf [unescapeStackBufSize]byte // stack-allocated array for allocation-free unescaping of small strings
-
- if ku, err := Unescape(StringToBytes(key), stackbuf[:]); err == nil {
- key = bytesToString(&ku)
- }
-
- for i < ln {
- switch data[i] {
- case '"':
- i++
- keyBegin := i
-
- strEnd, keyEscaped := stringEnd(data[i:])
- if strEnd == -1 {
- break
- }
- i += strEnd
- keyEnd := i - 1
-
- valueOffset := nextToken(data[i:])
- if valueOffset == -1 {
- break
- }
-
- i += valueOffset
-
- // if string is a key, and key level match
- k := data[keyBegin:keyEnd]
- // for unescape: if there are no escape sequences, this is cheap; if there are, it is a
- // bit more expensive, but causes no allocations unless len(key) > unescapeStackBufSize
- if keyEscaped {
- if ku, err := Unescape(k, stackbuf[:]); err != nil {
- break
- } else {
- k = ku
- }
- }
-
- if data[i] == ':' && len(key) == len(k) && bytesToString(&k) == key {
- return keyBegin - 1, nil
- }
-
- case '[':
- end := blockEnd(data[i:], data[i], ']')
- if end != -1 {
- i = i + end
- }
- case '{':
- end := blockEnd(data[i:], data[i], '}')
- if end != -1 {
- i = i + end
- }
- }
- i++
- }
-
- return -1, KeyPathNotFoundError
-}
-
-func tokenStart(data []byte) int {
- for i := len(data) - 1; i >= 0; i-- {
- switch data[i] {
- case '\n', '\r', '\t', ',', '{', '[':
- return i
- }
- }
-
- return 0
-}
-
-// Find position of next character which is not whitespace
-func nextToken(data []byte) int {
- for i, c := range data {
- switch c {
- case ' ', '\n', '\r', '\t':
- continue
- default:
- return i
- }
- }
-
- return -1
-}
-
-// Find position of last character which is not whitespace
-func lastToken(data []byte) int {
- for i := len(data) - 1; i >= 0; i-- {
- switch data[i] {
- case ' ', '\n', '\r', '\t':
- continue
- default:
- return i
- }
- }
-
- return -1
-}
-
-// Tries to find the end of string
-// Support if string contains escaped quote symbols.
-func stringEnd(data []byte) (int, bool) {
- escaped := false
- for i, c := range data {
- if c == '"' {
- if !escaped {
- return i + 1, false
- } else {
- j := i - 1
- for {
- if j < 0 || data[j] != '\\' {
- return i + 1, true // even number of backslashes
- }
- j--
- if j < 0 || data[j] != '\\' {
- break // odd number of backslashes
- }
- j--
-
- }
- }
- } else if c == '\\' {
- escaped = true
- }
- }
-
- return -1, escaped
-}
-
-// Find end of the data structure, array or object.
-// For array openSym and closeSym will be '[' and ']', for object '{' and '}'
-func blockEnd(data []byte, openSym byte, closeSym byte) int {
- level := 0
- i := 0
- ln := len(data)
-
- for i < ln {
- switch data[i] {
- case '"': // If inside string, skip it
- se, _ := stringEnd(data[i+1:])
- if se == -1 {
- return -1
- }
- i += se
- case openSym: // If open symbol, increase level
- level++
- case closeSym: // If close symbol, increase level
- level--
-
- // If we have returned to the original level, we're done
- if level == 0 {
- return i + 1
- }
- }
- i++
- }
-
- return -1
-}
-
-func searchKeys(data []byte, keys ...string) int {
- keyLevel := 0
- level := 0
- i := 0
- ln := len(data)
- lk := len(keys)
- lastMatched := true
-
- if lk == 0 {
- return 0
- }
-
- var stackbuf [unescapeStackBufSize]byte // stack-allocated array for allocation-free unescaping of small strings
-
- for i < ln {
- switch data[i] {
- case '"':
- i++
- keyBegin := i
-
- strEnd, keyEscaped := stringEnd(data[i:])
- if strEnd == -1 {
- return -1
- }
- i += strEnd
- keyEnd := i - 1
-
- valueOffset := nextToken(data[i:])
- if valueOffset == -1 {
- return -1
- }
-
- i += valueOffset
-
- // if string is a key
- if data[i] == ':' {
- if level < 1 {
- return -1
- }
-
- key := data[keyBegin:keyEnd]
-
- // for unescape: if there are no escape sequences, this is cheap; if there are, it is a
- // bit more expensive, but causes no allocations unless len(key) > unescapeStackBufSize
- var keyUnesc []byte
- if !keyEscaped {
- keyUnesc = key
- } else if ku, err := Unescape(key, stackbuf[:]); err != nil {
- return -1
- } else {
- keyUnesc = ku
- }
-
- if level <= len(keys) {
- if equalStr(&keyUnesc, keys[level-1]) {
- lastMatched = true
-
- // if key level match
- if keyLevel == level-1 {
- keyLevel++
- // If we found all keys in path
- if keyLevel == lk {
- return i + 1
- }
- }
- } else {
- lastMatched = false
- }
- } else {
- return -1
- }
- } else {
- i--
- }
- case '{':
-
- // in case parent key is matched then only we will increase the level otherwise can directly
- // can move to the end of this block
- if !lastMatched {
- end := blockEnd(data[i:], '{', '}')
- if end == -1 {
- return -1
- }
- i += end - 1
- } else {
- level++
- }
- case '}':
- level--
- if level == keyLevel {
- keyLevel--
- }
- case '[':
- // If we want to get array element by index
- if keyLevel == level && keys[level][0] == '[' {
- var keyLen = len(keys[level])
- if keyLen < 3 || keys[level][0] != '[' || keys[level][keyLen-1] != ']' {
- return -1
- }
- aIdx, err := strconv.Atoi(keys[level][1 : keyLen-1])
- if err != nil {
- return -1
- }
- var curIdx int
- var valueFound []byte
- var valueOffset int
- var curI = i
- ArrayEach(data[i:], func(value []byte, dataType ValueType, offset int, err error) {
- if curIdx == aIdx {
- valueFound = value
- valueOffset = offset
- if dataType == String {
- valueOffset = valueOffset - 2
- valueFound = data[curI+valueOffset : curI+valueOffset+len(value)+2]
- }
- }
- curIdx += 1
- })
-
- if valueFound == nil {
- return -1
- } else {
- subIndex := searchKeys(valueFound, keys[level+1:]...)
- if subIndex < 0 {
- return -1
- }
- return i + valueOffset + subIndex
- }
- } else {
- // Do not search for keys inside arrays
- if arraySkip := blockEnd(data[i:], '[', ']'); arraySkip == -1 {
- return -1
- } else {
- i += arraySkip - 1
- }
- }
- case ':': // If encountered, JSON data is malformed
- return -1
- }
-
- i++
- }
-
- return -1
-}
-
-func sameTree(p1, p2 []string) bool {
- minLen := len(p1)
- if len(p2) < minLen {
- minLen = len(p2)
- }
-
- for pi_1, p_1 := range p1[:minLen] {
- if p2[pi_1] != p_1 {
- return false
- }
- }
-
- return true
-}
-
-func EachKey(data []byte, cb func(int, []byte, ValueType, error), paths ...[]string) int {
- var x struct{}
- pathFlags := make([]bool, len(paths))
- var level, pathsMatched, i int
- ln := len(data)
-
- var maxPath int
- for _, p := range paths {
- if len(p) > maxPath {
- maxPath = len(p)
- }
- }
-
- pathsBuf := make([]string, maxPath)
-
- for i < ln {
- switch data[i] {
- case '"':
- i++
- keyBegin := i
-
- strEnd, keyEscaped := stringEnd(data[i:])
- if strEnd == -1 {
- return -1
- }
- i += strEnd
-
- keyEnd := i - 1
-
- valueOffset := nextToken(data[i:])
- if valueOffset == -1 {
- return -1
- }
-
- i += valueOffset
-
- // if string is a key, and key level match
- if data[i] == ':' {
- match := -1
- key := data[keyBegin:keyEnd]
-
- // for unescape: if there are no escape sequences, this is cheap; if there are, it is a
- // bit more expensive, but causes no allocations unless len(key) > unescapeStackBufSize
- var keyUnesc []byte
- if !keyEscaped {
- keyUnesc = key
- } else {
- var stackbuf [unescapeStackBufSize]byte
- if ku, err := Unescape(key, stackbuf[:]); err != nil {
- return -1
- } else {
- keyUnesc = ku
- }
- }
-
- if maxPath >= level {
- if level < 1 {
- cb(-1, nil, Unknown, MalformedJsonError)
- return -1
- }
-
- pathsBuf[level-1] = bytesToString(&keyUnesc)
- for pi, p := range paths {
- if len(p) != level || pathFlags[pi] || !equalStr(&keyUnesc, p[level-1]) || !sameTree(p, pathsBuf[:level]) {
- continue
- }
-
- match = pi
-
- pathsMatched++
- pathFlags[pi] = true
-
- v, dt, _, e := Get(data[i+1:])
- cb(pi, v, dt, e)
-
- if pathsMatched == len(paths) {
- break
- }
- }
- if pathsMatched == len(paths) {
- return i
- }
- }
-
- if match == -1 {
- tokenOffset := nextToken(data[i+1:])
- i += tokenOffset
-
- if data[i] == '{' {
- blockSkip := blockEnd(data[i:], '{', '}')
- i += blockSkip + 1
- }
- }
-
- if i < ln {
- switch data[i] {
- case '{', '}', '[', '"':
- i--
- }
- }
- } else {
- i--
- }
- case '{':
- level++
- case '}':
- level--
- case '[':
- var ok bool
- arrIdxFlags := make(map[int]struct{})
- pIdxFlags := make([]bool, len(paths))
-
- if level < 0 {
- cb(-1, nil, Unknown, MalformedJsonError)
- return -1
- }
-
- for pi, p := range paths {
- if len(p) < level+1 || pathFlags[pi] || p[level][0] != '[' || !sameTree(p, pathsBuf[:level]) {
- continue
- }
- if len(p[level]) >= 2 {
- aIdx, _ := strconv.Atoi(p[level][1 : len(p[level])-1])
- arrIdxFlags[aIdx] = x
- pIdxFlags[pi] = true
- }
- }
-
- if len(arrIdxFlags) > 0 {
- level++
-
- var curIdx int
- arrOff, _ := ArrayEach(data[i:], func(value []byte, dataType ValueType, offset int, err error) {
- if _, ok = arrIdxFlags[curIdx]; ok {
- for pi, p := range paths {
- if pIdxFlags[pi] {
- aIdx, _ := strconv.Atoi(p[level-1][1 : len(p[level-1])-1])
-
- if curIdx == aIdx {
- of := searchKeys(value, p[level:]...)
-
- pathsMatched++
- pathFlags[pi] = true
-
- if of != -1 {
- v, dt, _, e := Get(value[of:])
- cb(pi, v, dt, e)
- }
- }
- }
- }
- }
-
- curIdx += 1
- })
-
- if pathsMatched == len(paths) {
- return i
- }
-
- i += arrOff - 1
- } else {
- // Do not search for keys inside arrays
- if arraySkip := blockEnd(data[i:], '[', ']'); arraySkip == -1 {
- return -1
- } else {
- i += arraySkip - 1
- }
- }
- case ']':
- level--
- }
-
- i++
- }
-
- return -1
-}
-
-// Data types available in valid JSON data.
-type ValueType int
-
-const (
- NotExist = ValueType(iota)
- String
- Number
- Object
- Array
- Boolean
- Null
- Unknown
-)
-
-func (vt ValueType) String() string {
- switch vt {
- case NotExist:
- return "non-existent"
- case String:
- return "string"
- case Number:
- return "number"
- case Object:
- return "object"
- case Array:
- return "array"
- case Boolean:
- return "boolean"
- case Null:
- return "null"
- default:
- return "unknown"
- }
-}
-
-var (
- trueLiteral = []byte("true")
- falseLiteral = []byte("false")
- nullLiteral = []byte("null")
-)
-
-func createInsertComponent(keys []string, setValue []byte, comma, object bool) []byte {
- isIndex := string(keys[0][0]) == "["
- offset := 0
- lk := calcAllocateSpace(keys, setValue, comma, object)
- buffer := make([]byte, lk, lk)
- if comma {
- offset += WriteToBuffer(buffer[offset:], ",")
- }
- if isIndex && !comma {
- offset += WriteToBuffer(buffer[offset:], "[")
- } else {
- if object {
- offset += WriteToBuffer(buffer[offset:], "{")
- }
- if !isIndex {
- offset += WriteToBuffer(buffer[offset:], "\"")
- offset += WriteToBuffer(buffer[offset:], keys[0])
- offset += WriteToBuffer(buffer[offset:], "\":")
- }
- }
-
- for i := 1; i < len(keys); i++ {
- if string(keys[i][0]) == "[" {
- offset += WriteToBuffer(buffer[offset:], "[")
- } else {
- offset += WriteToBuffer(buffer[offset:], "{\"")
- offset += WriteToBuffer(buffer[offset:], keys[i])
- offset += WriteToBuffer(buffer[offset:], "\":")
- }
- }
- offset += WriteToBuffer(buffer[offset:], string(setValue))
- for i := len(keys) - 1; i > 0; i-- {
- if string(keys[i][0]) == "[" {
- offset += WriteToBuffer(buffer[offset:], "]")
- } else {
- offset += WriteToBuffer(buffer[offset:], "}")
- }
- }
- if isIndex && !comma {
- offset += WriteToBuffer(buffer[offset:], "]")
- }
- if object && !isIndex {
- offset += WriteToBuffer(buffer[offset:], "}")
- }
- return buffer
-}
-
-func calcAllocateSpace(keys []string, setValue []byte, comma, object bool) int {
- isIndex := string(keys[0][0]) == "["
- lk := 0
- if comma {
- // ,
- lk += 1
- }
- if isIndex && !comma {
- // []
- lk += 2
- } else {
- if object {
- // {
- lk += 1
- }
- if !isIndex {
- // "keys[0]"
- lk += len(keys[0]) + 3
- }
- }
-
-
- lk += len(setValue)
- for i := 1; i < len(keys); i++ {
- if string(keys[i][0]) == "[" {
- // []
- lk += 2
- } else {
- // {"keys[i]":setValue}
- lk += len(keys[i]) + 5
- }
- }
-
- if object && !isIndex {
- // }
- lk += 1
- }
-
- return lk
-}
-
-func WriteToBuffer(buffer []byte, str string) int {
- copy(buffer, str)
- return len(str)
-}
-
-/*
-
-Del - Receives existing data structure, path to delete.
-
-Returns:
-`data` - return modified data
-
-*/
-func Delete(data []byte, keys ...string) []byte {
- lk := len(keys)
- if lk == 0 {
- return data[:0]
- }
-
- array := false
- if len(keys[lk-1]) > 0 && string(keys[lk-1][0]) == "[" {
- array = true
- }
-
- var startOffset, keyOffset int
- endOffset := len(data)
- var err error
- if !array {
- if len(keys) > 1 {
- _, _, startOffset, endOffset, err = internalGet(data, keys[:lk-1]...)
- if err == KeyPathNotFoundError {
- // problem parsing the data
- return data
- }
- }
-
- keyOffset, err = findKeyStart(data[startOffset:endOffset], keys[lk-1])
- if err == KeyPathNotFoundError {
- // problem parsing the data
- return data
- }
- keyOffset += startOffset
- _, _, _, subEndOffset, _ := internalGet(data[startOffset:endOffset], keys[lk-1])
- endOffset = startOffset + subEndOffset
- tokEnd := tokenEnd(data[endOffset:])
- tokStart := findTokenStart(data[:keyOffset], ","[0])
-
- if data[endOffset+tokEnd] == ","[0] {
- endOffset += tokEnd + 1
- } else if data[endOffset+tokEnd] == " "[0] && len(data) > endOffset+tokEnd+1 && data[endOffset+tokEnd+1] == ","[0] {
- endOffset += tokEnd + 2
- } else if data[endOffset+tokEnd] == "}"[0] && data[tokStart] == ","[0] {
- keyOffset = tokStart
- }
- } else {
- _, _, keyOffset, endOffset, err = internalGet(data, keys...)
- if err == KeyPathNotFoundError {
- // problem parsing the data
- return data
- }
-
- tokEnd := tokenEnd(data[endOffset:])
- tokStart := findTokenStart(data[:keyOffset], ","[0])
-
- if data[endOffset+tokEnd] == ","[0] {
- endOffset += tokEnd + 1
- } else if data[endOffset+tokEnd] == "]"[0] && data[tokStart] == ","[0] {
- keyOffset = tokStart
- }
- }
-
- // We need to remove remaining trailing comma if we delete las element in the object
- prevTok := lastToken(data[:keyOffset])
- remainedValue := data[endOffset:]
-
- var newOffset int
- if nextToken(remainedValue) > -1 && remainedValue[nextToken(remainedValue)] == '}' && data[prevTok] == ',' {
- newOffset = prevTok
- } else {
- newOffset = prevTok + 1
- }
-
- // We have to make a copy here if we don't want to mangle the original data, because byte slices are
- // accessed by reference and not by value
- dataCopy := make([]byte, len(data))
- copy(dataCopy, data)
- data = append(dataCopy[:newOffset], dataCopy[endOffset:]...)
-
- return data
-}
-
-/*
-
-Set - Receives existing data structure, path to set, and data to set at that key.
-
-Returns:
-`value` - modified byte array
-`err` - On any parsing error
-
-*/
-func Set(data []byte, setValue []byte, keys ...string) (value []byte, err error) {
- // ensure keys are set
- if len(keys) == 0 {
- return nil, KeyPathNotFoundError
- }
-
- _, _, startOffset, endOffset, err := internalGet(data, keys...)
- if err != nil {
- if err != KeyPathNotFoundError {
- // problem parsing the data
- return nil, err
- }
- // full path doesnt exist
- // does any subpath exist?
- var depth int
- for i := range keys {
- _, _, start, end, sErr := internalGet(data, keys[:i+1]...)
- if sErr != nil {
- break
- } else {
- endOffset = end
- startOffset = start
- depth++
- }
- }
- comma := true
- object := false
- if endOffset == -1 {
- firstToken := nextToken(data)
- // We can't set a top-level key if data isn't an object
- if firstToken < 0 || data[firstToken] != '{' {
- return nil, KeyPathNotFoundError
- }
- // Don't need a comma if the input is an empty object
- secondToken := firstToken + 1 + nextToken(data[firstToken+1:])
- if data[secondToken] == '}' {
- comma = false
- }
- // Set the top level key at the end (accounting for any trailing whitespace)
- // This assumes last token is valid like '}', could check and return error
- endOffset = lastToken(data)
- }
- depthOffset := endOffset
- if depth != 0 {
- // if subpath is a non-empty object, add to it
- // or if subpath is a non-empty array, add to it
- if (data[startOffset] == '{' && data[startOffset+1+nextToken(data[startOffset+1:])] != '}') ||
- (data[startOffset] == '[' && data[startOffset+1+nextToken(data[startOffset+1:])] == '{') && keys[depth:][0][0] == 91 {
- depthOffset--
- startOffset = depthOffset
- // otherwise, over-write it with a new object
- } else {
- comma = false
- object = true
- }
- } else {
- startOffset = depthOffset
- }
- value = append(data[:startOffset], append(createInsertComponent(keys[depth:], setValue, comma, object), data[depthOffset:]...)...)
- } else {
- // path currently exists
- startComponent := data[:startOffset]
- endComponent := data[endOffset:]
-
- value = make([]byte, len(startComponent)+len(endComponent)+len(setValue))
- newEndOffset := startOffset + len(setValue)
- copy(value[0:startOffset], startComponent)
- copy(value[startOffset:newEndOffset], setValue)
- copy(value[newEndOffset:], endComponent)
- }
- return value, nil
-}
-
-func getType(data []byte, offset int) ([]byte, ValueType, int, error) {
- var dataType ValueType
- endOffset := offset
-
- // if string value
- if data[offset] == '"' {
- dataType = String
- if idx, _ := stringEnd(data[offset+1:]); idx != -1 {
- endOffset += idx + 1
- } else {
- return nil, dataType, offset, MalformedStringError
- }
- } else if data[offset] == '[' { // if array value
- dataType = Array
- // break label, for stopping nested loops
- endOffset = blockEnd(data[offset:], '[', ']')
-
- if endOffset == -1 {
- return nil, dataType, offset, MalformedArrayError
- }
-
- endOffset += offset
- } else if data[offset] == '{' { // if object value
- dataType = Object
- // break label, for stopping nested loops
- endOffset = blockEnd(data[offset:], '{', '}')
-
- if endOffset == -1 {
- return nil, dataType, offset, MalformedObjectError
- }
-
- endOffset += offset
- } else {
- // Number, Boolean or None
- end := tokenEnd(data[endOffset:])
-
- if end == -1 {
- return nil, dataType, offset, MalformedValueError
- }
-
- value := data[offset : endOffset+end]
-
- switch data[offset] {
- case 't', 'f': // true or false
- if bytes.Equal(value, trueLiteral) || bytes.Equal(value, falseLiteral) {
- dataType = Boolean
- } else {
- return nil, Unknown, offset, UnknownValueTypeError
- }
- case 'u', 'n': // undefined or null
- if bytes.Equal(value, nullLiteral) {
- dataType = Null
- } else {
- return nil, Unknown, offset, UnknownValueTypeError
- }
- case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-':
- dataType = Number
- default:
- return nil, Unknown, offset, UnknownValueTypeError
- }
-
- endOffset += end
- }
- return data[offset:endOffset], dataType, endOffset, nil
-}
-
-/*
-Get - Receives data structure, and key path to extract value from.
-
-Returns:
-`value` - Pointer to original data structure containing key value, or just empty slice if nothing found or error
-`dataType` - Can be: `NotExist`, `String`, `Number`, `Object`, `Array`, `Boolean` or `Null`
-`offset` - Offset from provided data structure where key value ends. Used mostly internally, for example for `ArrayEach` helper.
-`err` - If key not found or any other parsing issue it should return error. If key not found it also sets `dataType` to `NotExist`
-
-Accept multiple keys to specify path to JSON value (in case of quering nested structures).
-If no keys provided it will try to extract closest JSON value (simple ones or object/array), useful for reading streams or arrays, see `ArrayEach` implementation.
-*/
-func Get(data []byte, keys ...string) (value []byte, dataType ValueType, offset int, err error) {
- a, b, _, d, e := internalGet(data, keys...)
- return a, b, d, e
-}
-
-func internalGet(data []byte, keys ...string) (value []byte, dataType ValueType, offset, endOffset int, err error) {
- if len(keys) > 0 {
- if offset = searchKeys(data, keys...); offset == -1 {
- return nil, NotExist, -1, -1, KeyPathNotFoundError
- }
- }
-
- // Go to closest value
- nO := nextToken(data[offset:])
- if nO == -1 {
- return nil, NotExist, offset, -1, MalformedJsonError
- }
-
- offset += nO
- value, dataType, endOffset, err = getType(data, offset)
- if err != nil {
- return value, dataType, offset, endOffset, err
- }
-
- // Strip quotes from string values
- if dataType == String {
- value = value[1 : len(value)-1]
- }
-
- return value[:len(value):len(value)], dataType, offset, endOffset, nil
-}
-
-// ArrayEach is used when iterating arrays, accepts a callback function with the same return arguments as `Get`.
-func ArrayEach(data []byte, cb func(value []byte, dataType ValueType, offset int, err error), keys ...string) (offset int, err error) {
- if len(data) == 0 {
- return -1, MalformedObjectError
- }
-
- nT := nextToken(data)
- if nT == -1 {
- return -1, MalformedJsonError
- }
-
- offset = nT + 1
-
- if len(keys) > 0 {
- if offset = searchKeys(data, keys...); offset == -1 {
- return offset, KeyPathNotFoundError
- }
-
- // Go to closest value
- nO := nextToken(data[offset:])
- if nO == -1 {
- return offset, MalformedJsonError
- }
-
- offset += nO
-
- if data[offset] != '[' {
- return offset, MalformedArrayError
- }
-
- offset++
- }
-
- nO := nextToken(data[offset:])
- if nO == -1 {
- return offset, MalformedJsonError
- }
-
- offset += nO
-
- if data[offset] == ']' {
- return offset, nil
- }
-
- for true {
- v, t, o, e := Get(data[offset:])
-
- if e != nil {
- return offset, e
- }
-
- if o == 0 {
- break
- }
-
- if t != NotExist {
- cb(v, t, offset+o-len(v), e)
- }
-
- if e != nil {
- break
- }
-
- offset += o
-
- skipToToken := nextToken(data[offset:])
- if skipToToken == -1 {
- return offset, MalformedArrayError
- }
- offset += skipToToken
-
- if data[offset] == ']' {
- break
- }
-
- if data[offset] != ',' {
- return offset, MalformedArrayError
- }
-
- offset++
- }
-
- return offset, nil
-}
-
-// ObjectEach iterates over the key-value pairs of a JSON object, invoking a given callback for each such entry
-func ObjectEach(data []byte, callback func(key []byte, value []byte, dataType ValueType, offset int) error, keys ...string) (err error) {
- offset := 0
-
- // Descend to the desired key, if requested
- if len(keys) > 0 {
- if off := searchKeys(data, keys...); off == -1 {
- return KeyPathNotFoundError
- } else {
- offset = off
- }
- }
-
- // Validate and skip past opening brace
- if off := nextToken(data[offset:]); off == -1 {
- return MalformedObjectError
- } else if offset += off; data[offset] != '{' {
- return MalformedObjectError
- } else {
- offset++
- }
-
- // Skip to the first token inside the object, or stop if we find the ending brace
- if off := nextToken(data[offset:]); off == -1 {
- return MalformedJsonError
- } else if offset += off; data[offset] == '}' {
- return nil
- }
-
- // Loop pre-condition: data[offset] points to what should be either the next entry's key, or the closing brace (if it's anything else, the JSON is malformed)
- for offset < len(data) {
- // Step 1: find the next key
- var key []byte
-
- // Check what the the next token is: start of string, end of object, or something else (error)
- switch data[offset] {
- case '"':
- offset++ // accept as string and skip opening quote
- case '}':
- return nil // we found the end of the object; stop and return success
- default:
- return MalformedObjectError
- }
-
- // Find the end of the key string
- var keyEscaped bool
- if off, esc := stringEnd(data[offset:]); off == -1 {
- return MalformedJsonError
- } else {
- key, keyEscaped = data[offset:offset+off-1], esc
- offset += off
- }
-
- // Unescape the string if needed
- if keyEscaped {
- var stackbuf [unescapeStackBufSize]byte // stack-allocated array for allocation-free unescaping of small strings
- if keyUnescaped, err := Unescape(key, stackbuf[:]); err != nil {
- return MalformedStringEscapeError
- } else {
- key = keyUnescaped
- }
- }
-
- // Step 2: skip the colon
- if off := nextToken(data[offset:]); off == -1 {
- return MalformedJsonError
- } else if offset += off; data[offset] != ':' {
- return MalformedJsonError
- } else {
- offset++
- }
-
- // Step 3: find the associated value, then invoke the callback
- if value, valueType, off, err := Get(data[offset:]); err != nil {
- return err
- } else if err := callback(key, value, valueType, offset+off); err != nil { // Invoke the callback here!
- return err
- } else {
- offset += off
- }
-
- // Step 4: skip over the next comma to the following token, or stop if we hit the ending brace
- if off := nextToken(data[offset:]); off == -1 {
- return MalformedArrayError
- } else {
- offset += off
- switch data[offset] {
- case '}':
- return nil // Stop if we hit the close brace
- case ',':
- offset++ // Ignore the comma
- default:
- return MalformedObjectError
- }
- }
-
- // Skip to the next token after the comma
- if off := nextToken(data[offset:]); off == -1 {
- return MalformedArrayError
- } else {
- offset += off
- }
- }
-
- return MalformedObjectError // we shouldn't get here; it's expected that we will return via finding the ending brace
-}
-
-// GetUnsafeString returns the value retrieved by `Get`, use creates string without memory allocation by mapping string to slice memory. It does not handle escape symbols.
-func GetUnsafeString(data []byte, keys ...string) (val string, err error) {
- v, _, _, e := Get(data, keys...)
-
- if e != nil {
- return "", e
- }
-
- return bytesToString(&v), nil
-}
-
-// GetString returns the value retrieved by `Get`, cast to a string if possible, trying to properly handle escape and utf8 symbols
-// If key data type do not match, it will return an error.
-func GetString(data []byte, keys ...string) (val string, err error) {
- v, t, _, e := Get(data, keys...)
-
- if e != nil {
- return "", e
- }
-
- if t != String {
- return "", fmt.Errorf("Value is not a string: %s", string(v))
- }
-
- // If no escapes return raw content
- if bytes.IndexByte(v, '\\') == -1 {
- return string(v), nil
- }
-
- return ParseString(v)
-}
-
-// GetFloat returns the value retrieved by `Get`, cast to a float64 if possible.
-// The offset is the same as in `Get`.
-// If key data type do not match, it will return an error.
-func GetFloat(data []byte, keys ...string) (val float64, err error) {
- v, t, _, e := Get(data, keys...)
-
- if e != nil {
- return 0, e
- }
-
- if t != Number {
- return 0, fmt.Errorf("Value is not a number: %s", string(v))
- }
-
- return ParseFloat(v)
-}
-
-// GetInt returns the value retrieved by `Get`, cast to a int64 if possible.
-// If key data type do not match, it will return an error.
-func GetInt(data []byte, keys ...string) (val int64, err error) {
- v, t, _, e := Get(data, keys...)
-
- if e != nil {
- return 0, e
- }
-
- if t != Number {
- return 0, fmt.Errorf("Value is not a number: %s", string(v))
- }
-
- return ParseInt(v)
-}
-
-// GetBoolean returns the value retrieved by `Get`, cast to a bool if possible.
-// The offset is the same as in `Get`.
-// If key data type do not match, it will return error.
-func GetBoolean(data []byte, keys ...string) (val bool, err error) {
- v, t, _, e := Get(data, keys...)
-
- if e != nil {
- return false, e
- }
-
- if t != Boolean {
- return false, fmt.Errorf("Value is not a boolean: %s", string(v))
- }
-
- return ParseBoolean(v)
-}
-
-// ParseBoolean parses a Boolean ValueType into a Go bool (not particularly useful, but here for completeness)
-func ParseBoolean(b []byte) (bool, error) {
- switch {
- case bytes.Equal(b, trueLiteral):
- return true, nil
- case bytes.Equal(b, falseLiteral):
- return false, nil
- default:
- return false, MalformedValueError
- }
-}
-
-// ParseString parses a String ValueType into a Go string (the main parsing work is unescaping the JSON string)
-func ParseString(b []byte) (string, error) {
- var stackbuf [unescapeStackBufSize]byte // stack-allocated array for allocation-free unescaping of small strings
- if bU, err := Unescape(b, stackbuf[:]); err != nil {
- return "", MalformedValueError
- } else {
- return string(bU), nil
- }
-}
-
-// ParseNumber parses a Number ValueType into a Go float64
-func ParseFloat(b []byte) (float64, error) {
- if v, err := parseFloat(&b); err != nil {
- return 0, MalformedValueError
- } else {
- return v, nil
- }
-}
-
-// ParseInt parses a Number ValueType into a Go int64
-func ParseInt(b []byte) (int64, error) {
- if v, ok, overflow := parseInt(b); !ok {
- if overflow {
- return 0, OverflowIntegerError
- }
- return 0, MalformedValueError
- } else {
- return v, nil
- }
-}
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-13 15:45:15 +0000