aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/github.com/json-iterator/go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/json-iterator/go')
-rw-r--r--vendor/github.com/json-iterator/go/.codecov.yml3
-rw-r--r--vendor/github.com/json-iterator/go/.gitignore4
-rw-r--r--vendor/github.com/json-iterator/go/.travis.yml14
-rw-r--r--vendor/github.com/json-iterator/go/Gopkg.lock21
-rw-r--r--vendor/github.com/json-iterator/go/Gopkg.toml26
-rw-r--r--vendor/github.com/json-iterator/go/LICENSE21
-rw-r--r--vendor/github.com/json-iterator/go/README.md85
-rw-r--r--vendor/github.com/json-iterator/go/adapter.go150
-rw-r--r--vendor/github.com/json-iterator/go/any.go325
-rw-r--r--vendor/github.com/json-iterator/go/any_array.go278
-rw-r--r--vendor/github.com/json-iterator/go/any_bool.go137
-rw-r--r--vendor/github.com/json-iterator/go/any_float.go83
-rw-r--r--vendor/github.com/json-iterator/go/any_int32.go74
-rw-r--r--vendor/github.com/json-iterator/go/any_int64.go74
-rw-r--r--vendor/github.com/json-iterator/go/any_invalid.go82
-rw-r--r--vendor/github.com/json-iterator/go/any_nil.go69
-rw-r--r--vendor/github.com/json-iterator/go/any_number.go123
-rw-r--r--vendor/github.com/json-iterator/go/any_object.go374
-rw-r--r--vendor/github.com/json-iterator/go/any_str.go166
-rw-r--r--vendor/github.com/json-iterator/go/any_uint32.go74
-rw-r--r--vendor/github.com/json-iterator/go/any_uint64.go74
-rw-r--r--vendor/github.com/json-iterator/go/build.sh12
-rw-r--r--vendor/github.com/json-iterator/go/config.go375
-rw-r--r--vendor/github.com/json-iterator/go/fuzzy_mode_convert_table.md7
-rw-r--r--vendor/github.com/json-iterator/go/iter.go349
-rw-r--r--vendor/github.com/json-iterator/go/iter_array.go64
-rw-r--r--vendor/github.com/json-iterator/go/iter_float.go342
-rw-r--r--vendor/github.com/json-iterator/go/iter_int.go346
-rw-r--r--vendor/github.com/json-iterator/go/iter_object.go267
-rw-r--r--vendor/github.com/json-iterator/go/iter_skip.go130
-rw-r--r--vendor/github.com/json-iterator/go/iter_skip_sloppy.go163
-rw-r--r--vendor/github.com/json-iterator/go/iter_skip_strict.go99
-rw-r--r--vendor/github.com/json-iterator/go/iter_str.go215
-rw-r--r--vendor/github.com/json-iterator/go/jsoniter.go18
-rw-r--r--vendor/github.com/json-iterator/go/pool.go42
-rw-r--r--vendor/github.com/json-iterator/go/reflect.go337
-rw-r--r--vendor/github.com/json-iterator/go/reflect_array.go104
-rw-r--r--vendor/github.com/json-iterator/go/reflect_dynamic.go70
-rw-r--r--vendor/github.com/json-iterator/go/reflect_extension.go483
-rw-r--r--vendor/github.com/json-iterator/go/reflect_json_number.go112
-rw-r--r--vendor/github.com/json-iterator/go/reflect_json_raw_message.go76
-rw-r--r--vendor/github.com/json-iterator/go/reflect_map.go346
-rw-r--r--vendor/github.com/json-iterator/go/reflect_marshaler.go225
-rw-r--r--vendor/github.com/json-iterator/go/reflect_native.go453
-rw-r--r--vendor/github.com/json-iterator/go/reflect_optional.go129
-rw-r--r--vendor/github.com/json-iterator/go/reflect_slice.go99
-rw-r--r--vendor/github.com/json-iterator/go/reflect_struct_decoder.go1097
-rw-r--r--vendor/github.com/json-iterator/go/reflect_struct_encoder.go211
-rw-r--r--vendor/github.com/json-iterator/go/stream.go210
-rw-r--r--vendor/github.com/json-iterator/go/stream_float.go111
-rw-r--r--vendor/github.com/json-iterator/go/stream_int.go190
-rw-r--r--vendor/github.com/json-iterator/go/stream_str.go372
-rw-r--r--vendor/github.com/json-iterator/go/test.sh12
53 files changed, 0 insertions, 9323 deletions
diff --git a/vendor/github.com/json-iterator/go/.codecov.yml b/vendor/github.com/json-iterator/go/.codecov.yml
deleted file mode 100644
index 955dc0b..0000000
--- a/vendor/github.com/json-iterator/go/.codecov.yml
+++ /dev/null
@@ -1,3 +0,0 @@
1ignore:
2 - "output_tests/.*"
3
diff --git a/vendor/github.com/json-iterator/go/.gitignore b/vendor/github.com/json-iterator/go/.gitignore
deleted file mode 100644
index 1555653..0000000
--- a/vendor/github.com/json-iterator/go/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
1/vendor
2/bug_test.go
3/coverage.txt
4/.idea
diff --git a/vendor/github.com/json-iterator/go/.travis.yml b/vendor/github.com/json-iterator/go/.travis.yml
deleted file mode 100644
index 449e67c..0000000
--- a/vendor/github.com/json-iterator/go/.travis.yml
+++ /dev/null
@@ -1,14 +0,0 @@
1language: go
2
3go:
4 - 1.8.x
5 - 1.x
6
7before_install:
8 - go get -t -v ./...
9
10script:
11 - ./test.sh
12
13after_success:
14 - bash <(curl -s https://codecov.io/bash)
diff --git a/vendor/github.com/json-iterator/go/Gopkg.lock b/vendor/github.com/json-iterator/go/Gopkg.lock
deleted file mode 100644
index c8a9fbb..0000000
--- a/vendor/github.com/json-iterator/go/Gopkg.lock
+++ /dev/null
@@ -1,21 +0,0 @@
1# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
2
3
4[[projects]]
5 name = "github.com/modern-go/concurrent"
6 packages = ["."]
7 revision = "e0a39a4cb4216ea8db28e22a69f4ec25610d513a"
8 version = "1.0.0"
9
10[[projects]]
11 name = "github.com/modern-go/reflect2"
12 packages = ["."]
13 revision = "4b7aa43c6742a2c18fdef89dd197aaae7dac7ccd"
14 version = "1.0.1"
15
16[solve-meta]
17 analyzer-name = "dep"
18 analyzer-version = 1
19 inputs-digest = "ea54a775e5a354cb015502d2e7aa4b74230fc77e894f34a838b268c25ec8eeb8"
20 solver-name = "gps-cdcl"
21 solver-version = 1
diff --git a/vendor/github.com/json-iterator/go/Gopkg.toml b/vendor/github.com/json-iterator/go/Gopkg.toml
deleted file mode 100644
index 313a0f8..0000000
--- a/vendor/github.com/json-iterator/go/Gopkg.toml
+++ /dev/null
@@ -1,26 +0,0 @@
1# Gopkg.toml example
2#
3# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
4# for detailed Gopkg.toml documentation.
5#
6# required = ["github.com/user/thing/cmd/thing"]
7# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
8#
9# [[constraint]]
10# name = "github.com/user/project"
11# version = "1.0.0"
12#
13# [[constraint]]
14# name = "github.com/user/project2"
15# branch = "dev"
16# source = "github.com/myfork/project2"
17#
18# [[override]]
19# name = "github.com/x/y"
20# version = "2.4.0"
21
22ignored = ["github.com/davecgh/go-spew*","github.com/google/gofuzz*","github.com/stretchr/testify*"]
23
24[[constraint]]
25 name = "github.com/modern-go/reflect2"
26 version = "1.0.1"
diff --git a/vendor/github.com/json-iterator/go/LICENSE b/vendor/github.com/json-iterator/go/LICENSE
deleted file mode 100644
index 2cf4f5a..0000000
--- a/vendor/github.com/json-iterator/go/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
1MIT License
2
3Copyright (c) 2016 json-iterator
4
5Permission is hereby granted, free of charge, to any person obtaining a copy
6of this software and associated documentation files (the "Software"), to deal
7in the Software without restriction, including without limitation the rights
8to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9copies of the Software, and to permit persons to whom the Software is
10furnished to do so, subject to the following conditions:
11
12The above copyright notice and this permission notice shall be included in all
13copies or substantial portions of the Software.
14
15THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21SOFTWARE.
diff --git a/vendor/github.com/json-iterator/go/README.md b/vendor/github.com/json-iterator/go/README.md
deleted file mode 100644
index c589add..0000000
--- a/vendor/github.com/json-iterator/go/README.md
+++ /dev/null
@@ -1,85 +0,0 @@
1[![Sourcegraph](https://sourcegraph.com/github.com/json-iterator/go/-/badge.svg)](https://sourcegraph.com/github.com/json-iterator/go?badge)
2[![GoDoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](https://pkg.go.dev/github.com/json-iterator/go)
3[![Build Status](https://travis-ci.org/json-iterator/go.svg?branch=master)](https://travis-ci.org/json-iterator/go)
4[![codecov](https://codecov.io/gh/json-iterator/go/branch/master/graph/badge.svg)](https://codecov.io/gh/json-iterator/go)
5[![rcard](https://goreportcard.com/badge/github.com/json-iterator/go)](https://goreportcard.com/report/github.com/json-iterator/go)
6[![License](http://img.shields.io/badge/license-mit-blue.svg?style=flat-square)](https://raw.githubusercontent.com/json-iterator/go/master/LICENSE)
7[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/json-iterator/Lobby)
8
9A high-performance 100% compatible drop-in replacement of "encoding/json"
10
11# Benchmark
12
13![benchmark](http://jsoniter.com/benchmarks/go-benchmark.png)
14
15Source code: https://github.com/json-iterator/go-benchmark/blob/master/src/github.com/json-iterator/go-benchmark/benchmark_medium_payload_test.go
16
17Raw Result (easyjson requires static code generation)
18
19| | ns/op | allocation bytes | allocation times |
20| --------------- | ----------- | ---------------- | ---------------- |
21| std decode | 35510 ns/op | 1960 B/op | 99 allocs/op |
22| easyjson decode | 8499 ns/op | 160 B/op | 4 allocs/op |
23| jsoniter decode | 5623 ns/op | 160 B/op | 3 allocs/op |
24| std encode | 2213 ns/op | 712 B/op | 5 allocs/op |
25| easyjson encode | 883 ns/op | 576 B/op | 3 allocs/op |
26| jsoniter encode | 837 ns/op | 384 B/op | 4 allocs/op |
27
28Always benchmark with your own workload.
29The result depends heavily on the data input.
30
31# Usage
32
33100% compatibility with standard lib
34
35Replace
36
37```go
38import "encoding/json"
39json.Marshal(&data)
40```
41
42with
43
44```go
45import jsoniter "github.com/json-iterator/go"
46
47var json = jsoniter.ConfigCompatibleWithStandardLibrary
48json.Marshal(&data)
49```
50
51Replace
52
53```go
54import "encoding/json"
55json.Unmarshal(input, &data)
56```
57
58with
59
60```go
61import jsoniter "github.com/json-iterator/go"
62
63var json = jsoniter.ConfigCompatibleWithStandardLibrary
64json.Unmarshal(input, &data)
65```
66
67[More documentation](http://jsoniter.com/migrate-from-go-std.html)
68
69# How to get
70
71```
72go get github.com/json-iterator/go
73```
74
75# Contribution Welcomed !
76
77Contributors
78
79- [thockin](https://github.com/thockin)
80- [mattn](https://github.com/mattn)
81- [cch123](https://github.com/cch123)
82- [Oleg Shaldybin](https://github.com/olegshaldybin)
83- [Jason Toffaletti](https://github.com/toffaletti)
84
85Report issue or pull request, or email [email protected], or [![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/json-iterator/Lobby)
diff --git a/vendor/github.com/json-iterator/go/adapter.go b/vendor/github.com/json-iterator/go/adapter.go
deleted file mode 100644
index 92d2cc4..0000000
--- a/vendor/github.com/json-iterator/go/adapter.go
+++ /dev/null
@@ -1,150 +0,0 @@
1package jsoniter
2
3import (
4 "bytes"
5 "io"
6)
7
8// RawMessage to make replace json with jsoniter
9type RawMessage []byte
10
11// Unmarshal adapts to json/encoding Unmarshal API
12//
13// Unmarshal parses the JSON-encoded data and stores the result in the value pointed to by v.
14// Refer to https://godoc.org/encoding/json#Unmarshal for more information
15func Unmarshal(data []byte, v interface{}) error {
16 return ConfigDefault.Unmarshal(data, v)
17}
18
19// UnmarshalFromString is a convenient method to read from string instead of []byte
20func UnmarshalFromString(str string, v interface{}) error {
21 return ConfigDefault.UnmarshalFromString(str, v)
22}
23
24// Get quick method to get value from deeply nested JSON structure
25func Get(data []byte, path ...interface{}) Any {
26 return ConfigDefault.Get(data, path...)
27}
28
29// Marshal adapts to json/encoding Marshal API
30//
31// Marshal returns the JSON encoding of v, adapts to json/encoding Marshal API
32// Refer to https://godoc.org/encoding/json#Marshal for more information
33func Marshal(v interface{}) ([]byte, error) {
34 return ConfigDefault.Marshal(v)
35}
36
37// MarshalIndent same as json.MarshalIndent. Prefix is not supported.
38func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
39 return ConfigDefault.MarshalIndent(v, prefix, indent)
40}
41
42// MarshalToString convenient method to write as string instead of []byte
43func MarshalToString(v interface{}) (string, error) {
44 return ConfigDefault.MarshalToString(v)
45}
46
47// NewDecoder adapts to json/stream NewDecoder API.
48//
49// NewDecoder returns a new decoder that reads from r.
50//
51// Instead of a json/encoding Decoder, an Decoder is returned
52// Refer to https://godoc.org/encoding/json#NewDecoder for more information
53func NewDecoder(reader io.Reader) *Decoder {
54 return ConfigDefault.NewDecoder(reader)
55}
56
57// Decoder reads and decodes JSON values from an input stream.
58// Decoder provides identical APIs with json/stream Decoder (Token() and UseNumber() are in progress)
59type Decoder struct {
60 iter *Iterator
61}
62
63// Decode decode JSON into interface{}
64func (adapter *Decoder) Decode(obj interface{}) error {
65 if adapter.iter.head == adapter.iter.tail && adapter.iter.reader != nil {
66 if !adapter.iter.loadMore() {
67 return io.EOF
68 }
69 }
70 adapter.iter.ReadVal(obj)
71 err := adapter.iter.Error
72 if err == io.EOF {
73 return nil
74 }
75 return adapter.iter.Error
76}
77
78// More is there more?
79func (adapter *Decoder) More() bool {
80 iter := adapter.iter
81 if iter.Error != nil {
82 return false
83 }
84 c := iter.nextToken()
85 if c == 0 {
86 return false
87 }
88 iter.unreadByte()
89 return c != ']' && c != '}'
90}
91
92// Buffered remaining buffer
93func (adapter *Decoder) Buffered() io.Reader {
94 remaining := adapter.iter.buf[adapter.iter.head:adapter.iter.tail]
95 return bytes.NewReader(remaining)
96}
97
98// UseNumber causes the Decoder to unmarshal a number into an interface{} as a
99// Number instead of as a float64.
100func (adapter *Decoder) UseNumber() {
101 cfg := adapter.iter.cfg.configBeforeFrozen
102 cfg.UseNumber = true
103 adapter.iter.cfg = cfg.frozeWithCacheReuse(adapter.iter.cfg.extraExtensions)
104}
105
106// DisallowUnknownFields causes the Decoder to return an error when the destination
107// is a struct and the input contains object keys which do not match any
108// non-ignored, exported fields in the destination.
109func (adapter *Decoder) DisallowUnknownFields() {
110 cfg := adapter.iter.cfg.configBeforeFrozen
111 cfg.DisallowUnknownFields = true
112 adapter.iter.cfg = cfg.frozeWithCacheReuse(adapter.iter.cfg.extraExtensions)
113}
114
115// NewEncoder same as json.NewEncoder
116func NewEncoder(writer io.Writer) *Encoder {
117 return ConfigDefault.NewEncoder(writer)
118}
119
120// Encoder same as json.Encoder
121type Encoder struct {
122 stream *Stream
123}
124
125// Encode encode interface{} as JSON to io.Writer
126func (adapter *Encoder) Encode(val interface{}) error {
127 adapter.stream.WriteVal(val)
128 adapter.stream.WriteRaw("\n")
129 adapter.stream.Flush()
130 return adapter.stream.Error
131}
132
133// SetIndent set the indention. Prefix is not supported
134func (adapter *Encoder) SetIndent(prefix, indent string) {
135 config := adapter.stream.cfg.configBeforeFrozen
136 config.IndentionStep = len(indent)
137 adapter.stream.cfg = config.frozeWithCacheReuse(adapter.stream.cfg.extraExtensions)
138}
139
140// SetEscapeHTML escape html by default, set to false to disable
141func (adapter *Encoder) SetEscapeHTML(escapeHTML bool) {
142 config := adapter.stream.cfg.configBeforeFrozen
143 config.EscapeHTML = escapeHTML
144 adapter.stream.cfg = config.frozeWithCacheReuse(adapter.stream.cfg.extraExtensions)
145}
146
147// Valid reports whether data is a valid JSON encoding.
148func Valid(data []byte) bool {
149 return ConfigDefault.Valid(data)
150}
diff --git a/vendor/github.com/json-iterator/go/any.go b/vendor/github.com/json-iterator/go/any.go
deleted file mode 100644
index f6b8aea..0000000
--- a/vendor/github.com/json-iterator/go/any.go
+++ /dev/null
@@ -1,325 +0,0 @@
1package jsoniter
2
3import (
4 "errors"
5 "fmt"
6 "github.com/modern-go/reflect2"
7 "io"
8 "reflect"
9 "strconv"
10 "unsafe"
11)
12
13// Any generic object representation.
14// The lazy json implementation holds []byte and parse lazily.
15type Any interface {
16 LastError() error
17 ValueType() ValueType
18 MustBeValid() Any
19 ToBool() bool
20 ToInt() int
21 ToInt32() int32
22 ToInt64() int64
23 ToUint() uint
24 ToUint32() uint32
25 ToUint64() uint64
26 ToFloat32() float32
27 ToFloat64() float64
28 ToString() string
29 ToVal(val interface{})
30 Get(path ...interface{}) Any
31 Size() int
32 Keys() []string
33 GetInterface() interface{}
34 WriteTo(stream *Stream)
35}
36
37type baseAny struct{}
38
39func (any *baseAny) Get(path ...interface{}) Any {
40 return &invalidAny{baseAny{}, fmt.Errorf("GetIndex %v from simple value", path)}
41}
42
43func (any *baseAny) Size() int {
44 return 0
45}
46
47func (any *baseAny) Keys() []string {
48 return []string{}
49}
50
51func (any *baseAny) ToVal(obj interface{}) {
52 panic("not implemented")
53}
54
55// WrapInt32 turn int32 into Any interface
56func WrapInt32(val int32) Any {
57 return &int32Any{baseAny{}, val}
58}
59
60// WrapInt64 turn int64 into Any interface
61func WrapInt64(val int64) Any {
62 return &int64Any{baseAny{}, val}
63}
64
65// WrapUint32 turn uint32 into Any interface
66func WrapUint32(val uint32) Any {
67 return &uint32Any{baseAny{}, val}
68}
69
70// WrapUint64 turn uint64 into Any interface
71func WrapUint64(val uint64) Any {
72 return &uint64Any{baseAny{}, val}
73}
74
75// WrapFloat64 turn float64 into Any interface
76func WrapFloat64(val float64) Any {
77 return &floatAny{baseAny{}, val}
78}
79
80// WrapString turn string into Any interface
81func WrapString(val string) Any {
82 return &stringAny{baseAny{}, val}
83}
84
85// Wrap turn a go object into Any interface
86func Wrap(val interface{}) Any {
87 if val == nil {
88 return &nilAny{}
89 }
90 asAny, isAny := val.(Any)
91 if isAny {
92 return asAny
93 }
94 typ := reflect2.TypeOf(val)
95 switch typ.Kind() {
96 case reflect.Slice:
97 return wrapArray(val)
98 case reflect.Struct:
99 return wrapStruct(val)
100 case reflect.Map:
101 return wrapMap(val)
102 case reflect.String:
103 return WrapString(val.(string))
104 case reflect.Int:
105 if strconv.IntSize == 32 {
106 return WrapInt32(int32(val.(int)))
107 }
108 return WrapInt64(int64(val.(int)))
109 case reflect.Int8:
110 return WrapInt32(int32(val.(int8)))
111 case reflect.Int16:
112 return WrapInt32(int32(val.(int16)))
113 case reflect.Int32:
114 return WrapInt32(val.(int32))
115 case reflect.Int64:
116 return WrapInt64(val.(int64))
117 case reflect.Uint:
118 if strconv.IntSize == 32 {
119 return WrapUint32(uint32(val.(uint)))
120 }
121 return WrapUint64(uint64(val.(uint)))
122 case reflect.Uintptr:
123 if ptrSize == 32 {
124 return WrapUint32(uint32(val.(uintptr)))
125 }
126 return WrapUint64(uint64(val.(uintptr)))
127 case reflect.Uint8:
128 return WrapUint32(uint32(val.(uint8)))
129 case reflect.Uint16:
130 return WrapUint32(uint32(val.(uint16)))
131 case reflect.Uint32:
132 return WrapUint32(uint32(val.(uint32)))
133 case reflect.Uint64:
134 return WrapUint64(val.(uint64))
135 case reflect.Float32:
136 return WrapFloat64(float64(val.(float32)))
137 case reflect.Float64:
138 return WrapFloat64(val.(float64))
139 case reflect.Bool:
140 if val.(bool) == true {
141 return &trueAny{}
142 }
143 return &falseAny{}
144 }
145 return &invalidAny{baseAny{}, fmt.Errorf("unsupported type: %v", typ)}
146}
147
148// ReadAny read next JSON element as an Any object. It is a better json.RawMessage.
149func (iter *Iterator) ReadAny() Any {
150 return iter.readAny()
151}
152
153func (iter *Iterator) readAny() Any {
154 c := iter.nextToken()
155 switch c {
156 case '"':
157 iter.unreadByte()
158 return &stringAny{baseAny{}, iter.ReadString()}
159 case 'n':
160 iter.skipThreeBytes('u', 'l', 'l') // null
161 return &nilAny{}
162 case 't':
163 iter.skipThreeBytes('r', 'u', 'e') // true
164 return &trueAny{}
165 case 'f':
166 iter.skipFourBytes('a', 'l', 's', 'e') // false
167 return &falseAny{}
168 case '{':
169 return iter.readObjectAny()
170 case '[':
171 return iter.readArrayAny()
172 case '-':
173 return iter.readNumberAny(false)
174 case 0:
175 return &invalidAny{baseAny{}, errors.New("input is empty")}
176 default:
177 return iter.readNumberAny(true)
178 }
179}
180
181func (iter *Iterator) readNumberAny(positive bool) Any {
182 iter.startCapture(iter.head - 1)
183 iter.skipNumber()
184 lazyBuf := iter.stopCapture()
185 return &numberLazyAny{baseAny{}, iter.cfg, lazyBuf, nil}
186}
187
188func (iter *Iterator) readObjectAny() Any {
189 iter.startCapture(iter.head - 1)
190 iter.skipObject()
191 lazyBuf := iter.stopCapture()
192 return &objectLazyAny{baseAny{}, iter.cfg, lazyBuf, nil}
193}
194
195func (iter *Iterator) readArrayAny() Any {
196 iter.startCapture(iter.head - 1)
197 iter.skipArray()
198 lazyBuf := iter.stopCapture()
199 return &arrayLazyAny{baseAny{}, iter.cfg, lazyBuf, nil}
200}
201
202func locateObjectField(iter *Iterator, target string) []byte {
203 var found []byte
204 iter.ReadObjectCB(func(iter *Iterator, field string) bool {
205 if field == target {
206 found = iter.SkipAndReturnBytes()
207 return false
208 }
209 iter.Skip()
210 return true
211 })
212 return found
213}
214
215func locateArrayElement(iter *Iterator, target int) []byte {
216 var found []byte
217 n := 0
218 iter.ReadArrayCB(func(iter *Iterator) bool {
219 if n == target {
220 found = iter.SkipAndReturnBytes()
221 return false
222 }
223 iter.Skip()
224 n++
225 return true
226 })
227 return found
228}
229
230func locatePath(iter *Iterator, path []interface{}) Any {
231 for i, pathKeyObj := range path {
232 switch pathKey := pathKeyObj.(type) {
233 case string:
234 valueBytes := locateObjectField(iter, pathKey)
235 if valueBytes == nil {
236 return newInvalidAny(path[i:])
237 }
238 iter.ResetBytes(valueBytes)
239 case int:
240 valueBytes := locateArrayElement(iter, pathKey)
241 if valueBytes == nil {
242 return newInvalidAny(path[i:])
243 }
244 iter.ResetBytes(valueBytes)
245 case int32:
246 if '*' == pathKey {
247 return iter.readAny().Get(path[i:]...)
248 }
249 return newInvalidAny(path[i:])
250 default:
251 return newInvalidAny(path[i:])
252 }
253 }
254 if iter.Error != nil && iter.Error != io.EOF {
255 return &invalidAny{baseAny{}, iter.Error}
256 }
257 return iter.readAny()
258}
259
260var anyType = reflect2.TypeOfPtr((*Any)(nil)).Elem()
261
262func createDecoderOfAny(ctx *ctx, typ reflect2.Type) ValDecoder {
263 if typ == anyType {
264 return &directAnyCodec{}
265 }
266 if typ.Implements(anyType) {
267 return &anyCodec{
268 valType: typ,
269 }
270 }
271 return nil
272}
273
274func createEncoderOfAny(ctx *ctx, typ reflect2.Type) ValEncoder {
275 if typ == anyType {
276 return &directAnyCodec{}
277 }
278 if typ.Implements(anyType) {
279 return &anyCodec{
280 valType: typ,
281 }
282 }
283 return nil
284}
285
286type anyCodec struct {
287 valType reflect2.Type
288}
289
290func (codec *anyCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
291 panic("not implemented")
292}
293
294func (codec *anyCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
295 obj := codec.valType.UnsafeIndirect(ptr)
296 any := obj.(Any)
297 any.WriteTo(stream)
298}
299
300func (codec *anyCodec) IsEmpty(ptr unsafe.Pointer) bool {
301 obj := codec.valType.UnsafeIndirect(ptr)
302 any := obj.(Any)
303 return any.Size() == 0
304}
305
306type directAnyCodec struct {
307}
308
309func (codec *directAnyCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
310 *(*Any)(ptr) = iter.readAny()
311}
312
313func (codec *directAnyCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
314 any := *(*Any)(ptr)
315 if any == nil {
316 stream.WriteNil()
317 return
318 }
319 any.WriteTo(stream)
320}
321
322func (codec *directAnyCodec) IsEmpty(ptr unsafe.Pointer) bool {
323 any := *(*Any)(ptr)
324 return any.Size() == 0
325}
diff --git a/vendor/github.com/json-iterator/go/any_array.go b/vendor/github.com/json-iterator/go/any_array.go
deleted file mode 100644
index 0449e9a..0000000
--- a/vendor/github.com/json-iterator/go/any_array.go
+++ /dev/null
@@ -1,278 +0,0 @@
1package jsoniter
2
3import (
4 "reflect"
5 "unsafe"
6)
7
8type arrayLazyAny struct {
9 baseAny
10 cfg *frozenConfig
11 buf []byte
12 err error
13}
14
15func (any *arrayLazyAny) ValueType() ValueType {
16 return ArrayValue
17}
18
19func (any *arrayLazyAny) MustBeValid() Any {
20 return any
21}
22
23func (any *arrayLazyAny) LastError() error {
24 return any.err
25}
26
27func (any *arrayLazyAny) ToBool() bool {
28 iter := any.cfg.BorrowIterator(any.buf)
29 defer any.cfg.ReturnIterator(iter)
30 return iter.ReadArray()
31}
32
33func (any *arrayLazyAny) ToInt() int {
34 if any.ToBool() {
35 return 1
36 }
37 return 0
38}
39
40func (any *arrayLazyAny) ToInt32() int32 {
41 if any.ToBool() {
42 return 1
43 }
44 return 0
45}
46
47func (any *arrayLazyAny) ToInt64() int64 {
48 if any.ToBool() {
49 return 1
50 }
51 return 0
52}
53
54func (any *arrayLazyAny) ToUint() uint {
55 if any.ToBool() {
56 return 1
57 }
58 return 0
59}
60
61func (any *arrayLazyAny) ToUint32() uint32 {
62 if any.ToBool() {
63 return 1
64 }
65 return 0
66}
67
68func (any *arrayLazyAny) ToUint64() uint64 {
69 if any.ToBool() {
70 return 1
71 }
72 return 0
73}
74
75func (any *arrayLazyAny) ToFloat32() float32 {
76 if any.ToBool() {
77 return 1
78 }
79 return 0
80}
81
82func (any *arrayLazyAny) ToFloat64() float64 {
83 if any.ToBool() {
84 return 1
85 }
86 return 0
87}
88
89func (any *arrayLazyAny) ToString() string {
90 return *(*string)(unsafe.Pointer(&any.buf))
91}
92
93func (any *arrayLazyAny) ToVal(val interface{}) {
94 iter := any.cfg.BorrowIterator(any.buf)
95 defer any.cfg.ReturnIterator(iter)
96 iter.ReadVal(val)
97}
98
99func (any *arrayLazyAny) Get(path ...interface{}) Any {
100 if len(path) == 0 {
101 return any
102 }
103 switch firstPath := path[0].(type) {
104 case int:
105 iter := any.cfg.BorrowIterator(any.buf)
106 defer any.cfg.ReturnIterator(iter)
107 valueBytes := locateArrayElement(iter, firstPath)
108 if valueBytes == nil {
109 return newInvalidAny(path)
110 }
111 iter.ResetBytes(valueBytes)
112 return locatePath(iter, path[1:])
113 case int32:
114 if '*' == firstPath {
115 iter := any.cfg.BorrowIterator(any.buf)
116 defer any.cfg.ReturnIterator(iter)
117 arr := make([]Any, 0)
118 iter.ReadArrayCB(func(iter *Iterator) bool {
119 found := iter.readAny().Get(path[1:]...)
120 if found.ValueType() != InvalidValue {
121 arr = append(arr, found)
122 }
123 return true
124 })
125 return wrapArray(arr)
126 }
127 return newInvalidAny(path)
128 default:
129 return newInvalidAny(path)
130 }
131}
132
133func (any *arrayLazyAny) Size() int {
134 size := 0
135 iter := any.cfg.BorrowIterator(any.buf)
136 defer any.cfg.ReturnIterator(iter)
137 iter.ReadArrayCB(func(iter *Iterator) bool {
138 size++
139 iter.Skip()
140 return true
141 })
142 return size
143}
144
145func (any *arrayLazyAny) WriteTo(stream *Stream) {
146 stream.Write(any.buf)
147}
148
149func (any *arrayLazyAny) GetInterface() interface{} {
150 iter := any.cfg.BorrowIterator(any.buf)
151 defer any.cfg.ReturnIterator(iter)
152 return iter.Read()
153}
154
155type arrayAny struct {
156 baseAny
157 val reflect.Value
158}
159
160func wrapArray(val interface{}) *arrayAny {
161 return &arrayAny{baseAny{}, reflect.ValueOf(val)}
162}
163
164func (any *arrayAny) ValueType() ValueType {
165 return ArrayValue
166}
167
168func (any *arrayAny) MustBeValid() Any {
169 return any
170}
171
172func (any *arrayAny) LastError() error {
173 return nil
174}
175
176func (any *arrayAny) ToBool() bool {
177 return any.val.Len() != 0
178}
179
180func (any *arrayAny) ToInt() int {
181 if any.val.Len() == 0 {
182 return 0
183 }
184 return 1
185}
186
187func (any *arrayAny) ToInt32() int32 {
188 if any.val.Len() == 0 {
189 return 0
190 }
191 return 1
192}
193
194func (any *arrayAny) ToInt64() int64 {
195 if any.val.Len() == 0 {
196 return 0
197 }
198 return 1
199}
200
201func (any *arrayAny) ToUint() uint {
202 if any.val.Len() == 0 {
203 return 0
204 }
205 return 1
206}
207
208func (any *arrayAny) ToUint32() uint32 {
209 if any.val.Len() == 0 {
210 return 0
211 }
212 return 1
213}
214
215func (any *arrayAny) ToUint64() uint64 {
216 if any.val.Len() == 0 {
217 return 0
218 }
219 return 1
220}
221
222func (any *arrayAny) ToFloat32() float32 {
223 if any.val.Len() == 0 {
224 return 0
225 }
226 return 1
227}
228
229func (any *arrayAny) ToFloat64() float64 {
230 if any.val.Len() == 0 {
231 return 0
232 }
233 return 1
234}
235
236func (any *arrayAny) ToString() string {
237 str, _ := MarshalToString(any.val.Interface())
238 return str
239}
240
241func (any *arrayAny) Get(path ...interface{}) Any {
242 if len(path) == 0 {
243 return any
244 }
245 switch firstPath := path[0].(type) {
246 case int:
247 if firstPath < 0 || firstPath >= any.val.Len() {
248 return newInvalidAny(path)
249 }
250 return Wrap(any.val.Index(firstPath).Interface())
251 case int32:
252 if '*' == firstPath {
253 mappedAll := make([]Any, 0)
254 for i := 0; i < any.val.Len(); i++ {
255 mapped := Wrap(any.val.Index(i).Interface()).Get(path[1:]...)
256 if mapped.ValueType() != InvalidValue {
257 mappedAll = append(mappedAll, mapped)
258 }
259 }
260 return wrapArray(mappedAll)
261 }
262 return newInvalidAny(path)
263 default:
264 return newInvalidAny(path)
265 }
266}
267
268func (any *arrayAny) Size() int {
269 return any.val.Len()
270}
271
272func (any *arrayAny) WriteTo(stream *Stream) {
273 stream.WriteVal(any.val)
274}
275
276func (any *arrayAny) GetInterface() interface{} {
277 return any.val.Interface()
278}
diff --git a/vendor/github.com/json-iterator/go/any_bool.go b/vendor/github.com/json-iterator/go/any_bool.go
deleted file mode 100644
index 9452324..0000000
--- a/vendor/github.com/json-iterator/go/any_bool.go
+++ /dev/null
@@ -1,137 +0,0 @@
1package jsoniter
2
3type trueAny struct {
4 baseAny
5}
6
7func (any *trueAny) LastError() error {
8 return nil
9}
10
11func (any *trueAny) ToBool() bool {
12 return true
13}
14
15func (any *trueAny) ToInt() int {
16 return 1
17}
18
19func (any *trueAny) ToInt32() int32 {
20 return 1
21}
22
23func (any *trueAny) ToInt64() int64 {
24 return 1
25}
26
27func (any *trueAny) ToUint() uint {
28 return 1
29}
30
31func (any *trueAny) ToUint32() uint32 {
32 return 1
33}
34
35func (any *trueAny) ToUint64() uint64 {
36 return 1
37}
38
39func (any *trueAny) ToFloat32() float32 {
40 return 1
41}
42
43func (any *trueAny) ToFloat64() float64 {
44 return 1
45}
46
47func (any *trueAny) ToString() string {
48 return "true"
49}
50
51func (any *trueAny) WriteTo(stream *Stream) {
52 stream.WriteTrue()
53}
54
55func (any *trueAny) Parse() *Iterator {
56 return nil
57}
58
59func (any *trueAny) GetInterface() interface{} {
60 return true
61}
62
63func (any *trueAny) ValueType() ValueType {
64 return BoolValue
65}
66
67func (any *trueAny) MustBeValid() Any {
68 return any
69}
70
71type falseAny struct {
72 baseAny
73}
74
75func (any *falseAny) LastError() error {
76 return nil
77}
78
79func (any *falseAny) ToBool() bool {
80 return false
81}
82
83func (any *falseAny) ToInt() int {
84 return 0
85}
86
87func (any *falseAny) ToInt32() int32 {
88 return 0
89}
90
91func (any *falseAny) ToInt64() int64 {
92 return 0
93}
94
95func (any *falseAny) ToUint() uint {
96 return 0
97}
98
99func (any *falseAny) ToUint32() uint32 {
100 return 0
101}
102
103func (any *falseAny) ToUint64() uint64 {
104 return 0
105}
106
107func (any *falseAny) ToFloat32() float32 {
108 return 0
109}
110
111func (any *falseAny) ToFloat64() float64 {
112 return 0
113}
114
115func (any *falseAny) ToString() string {
116 return "false"
117}
118
119func (any *falseAny) WriteTo(stream *Stream) {
120 stream.WriteFalse()
121}
122
123func (any *falseAny) Parse() *Iterator {
124 return nil
125}
126
127func (any *falseAny) GetInterface() interface{} {
128 return false
129}
130
131func (any *falseAny) ValueType() ValueType {
132 return BoolValue
133}
134
135func (any *falseAny) MustBeValid() Any {
136 return any
137}
diff --git a/vendor/github.com/json-iterator/go/any_float.go b/vendor/github.com/json-iterator/go/any_float.go
deleted file mode 100644
index 35fdb09..0000000
--- a/vendor/github.com/json-iterator/go/any_float.go
+++ /dev/null
@@ -1,83 +0,0 @@
1package jsoniter
2
3import (
4 "strconv"
5)
6
7type floatAny struct {
8 baseAny
9 val float64
10}
11
12func (any *floatAny) Parse() *Iterator {
13 return nil
14}
15
16func (any *floatAny) ValueType() ValueType {
17 return NumberValue
18}
19
20func (any *floatAny) MustBeValid() Any {
21 return any
22}
23
24func (any *floatAny) LastError() error {
25 return nil
26}
27
28func (any *floatAny) ToBool() bool {
29 return any.ToFloat64() != 0
30}
31
32func (any *floatAny) ToInt() int {
33 return int(any.val)
34}
35
36func (any *floatAny) ToInt32() int32 {
37 return int32(any.val)
38}
39
40func (any *floatAny) ToInt64() int64 {
41 return int64(any.val)
42}
43
44func (any *floatAny) ToUint() uint {
45 if any.val > 0 {
46 return uint(any.val)
47 }
48 return 0
49}
50
51func (any *floatAny) ToUint32() uint32 {
52 if any.val > 0 {
53 return uint32(any.val)
54 }
55 return 0
56}
57
58func (any *floatAny) ToUint64() uint64 {
59 if any.val > 0 {
60 return uint64(any.val)
61 }
62 return 0
63}
64
65func (any *floatAny) ToFloat32() float32 {
66 return float32(any.val)
67}
68
69func (any *floatAny) ToFloat64() float64 {
70 return any.val
71}
72
73func (any *floatAny) ToString() string {
74 return strconv.FormatFloat(any.val, 'E', -1, 64)
75}
76
77func (any *floatAny) WriteTo(stream *Stream) {
78 stream.WriteFloat64(any.val)
79}
80
81func (any *floatAny) GetInterface() interface{} {
82 return any.val
83}
diff --git a/vendor/github.com/json-iterator/go/any_int32.go b/vendor/github.com/json-iterator/go/any_int32.go
deleted file mode 100644
index 1b56f39..0000000
--- a/vendor/github.com/json-iterator/go/any_int32.go
+++ /dev/null
@@ -1,74 +0,0 @@
1package jsoniter
2
3import (
4 "strconv"
5)
6
7type int32Any struct {
8 baseAny
9 val int32
10}
11
12func (any *int32Any) LastError() error {
13 return nil
14}
15
16func (any *int32Any) ValueType() ValueType {
17 return NumberValue
18}
19
20func (any *int32Any) MustBeValid() Any {
21 return any
22}
23
24func (any *int32Any) ToBool() bool {
25 return any.val != 0
26}
27
28func (any *int32Any) ToInt() int {
29 return int(any.val)
30}
31
32func (any *int32Any) ToInt32() int32 {
33 return any.val
34}
35
36func (any *int32Any) ToInt64() int64 {
37 return int64(any.val)
38}
39
40func (any *int32Any) ToUint() uint {
41 return uint(any.val)
42}
43
44func (any *int32Any) ToUint32() uint32 {
45 return uint32(any.val)
46}
47
48func (any *int32Any) ToUint64() uint64 {
49 return uint64(any.val)
50}
51
52func (any *int32Any) ToFloat32() float32 {
53 return float32(any.val)
54}
55
56func (any *int32Any) ToFloat64() float64 {
57 return float64(any.val)
58}
59
60func (any *int32Any) ToString() string {
61 return strconv.FormatInt(int64(any.val), 10)
62}
63
64func (any *int32Any) WriteTo(stream *Stream) {
65 stream.WriteInt32(any.val)
66}
67
68func (any *int32Any) Parse() *Iterator {
69 return nil
70}
71
72func (any *int32Any) GetInterface() interface{} {
73 return any.val
74}
diff --git a/vendor/github.com/json-iterator/go/any_int64.go b/vendor/github.com/json-iterator/go/any_int64.go
deleted file mode 100644
index c440d72..0000000
--- a/vendor/github.com/json-iterator/go/any_int64.go
+++ /dev/null
@@ -1,74 +0,0 @@
1package jsoniter
2
3import (
4 "strconv"
5)
6
7type int64Any struct {
8 baseAny
9 val int64
10}
11
12func (any *int64Any) LastError() error {
13 return nil
14}
15
16func (any *int64Any) ValueType() ValueType {
17 return NumberValue
18}
19
20func (any *int64Any) MustBeValid() Any {
21 return any
22}
23
24func (any *int64Any) ToBool() bool {
25 return any.val != 0
26}
27
28func (any *int64Any) ToInt() int {
29 return int(any.val)
30}
31
32func (any *int64Any) ToInt32() int32 {
33 return int32(any.val)
34}
35
36func (any *int64Any) ToInt64() int64 {
37 return any.val
38}
39
40func (any *int64Any) ToUint() uint {
41 return uint(any.val)
42}
43
44func (any *int64Any) ToUint32() uint32 {
45 return uint32(any.val)
46}
47
48func (any *int64Any) ToUint64() uint64 {
49 return uint64(any.val)
50}
51
52func (any *int64Any) ToFloat32() float32 {
53 return float32(any.val)
54}
55
56func (any *int64Any) ToFloat64() float64 {
57 return float64(any.val)
58}
59
60func (any *int64Any) ToString() string {
61 return strconv.FormatInt(any.val, 10)
62}
63
64func (any *int64Any) WriteTo(stream *Stream) {
65 stream.WriteInt64(any.val)
66}
67
68func (any *int64Any) Parse() *Iterator {
69 return nil
70}
71
72func (any *int64Any) GetInterface() interface{} {
73 return any.val
74}
diff --git a/vendor/github.com/json-iterator/go/any_invalid.go b/vendor/github.com/json-iterator/go/any_invalid.go
deleted file mode 100644
index 1d859ea..0000000
--- a/vendor/github.com/json-iterator/go/any_invalid.go
+++ /dev/null
@@ -1,82 +0,0 @@
1package jsoniter
2
3import "fmt"
4
5type invalidAny struct {
6 baseAny
7 err error
8}
9
10func newInvalidAny(path []interface{}) *invalidAny {
11 return &invalidAny{baseAny{}, fmt.Errorf("%v not found", path)}
12}
13
14func (any *invalidAny) LastError() error {
15 return any.err
16}
17
18func (any *invalidAny) ValueType() ValueType {
19 return InvalidValue
20}
21
22func (any *invalidAny) MustBeValid() Any {
23 panic(any.err)
24}
25
26func (any *invalidAny) ToBool() bool {
27 return false
28}
29
30func (any *invalidAny) ToInt() int {
31 return 0
32}
33
34func (any *invalidAny) ToInt32() int32 {
35 return 0
36}
37
38func (any *invalidAny) ToInt64() int64 {
39 return 0
40}
41
42func (any *invalidAny) ToUint() uint {
43 return 0
44}
45
46func (any *invalidAny) ToUint32() uint32 {
47 return 0
48}
49
50func (any *invalidAny) ToUint64() uint64 {
51 return 0
52}
53
54func (any *invalidAny) ToFloat32() float32 {
55 return 0
56}
57
58func (any *invalidAny) ToFloat64() float64 {
59 return 0
60}
61
62func (any *invalidAny) ToString() string {
63 return ""
64}
65
66func (any *invalidAny) WriteTo(stream *Stream) {
67}
68
69func (any *invalidAny) Get(path ...interface{}) Any {
70 if any.err == nil {
71 return &invalidAny{baseAny{}, fmt.Errorf("get %v from invalid", path)}
72 }
73 return &invalidAny{baseAny{}, fmt.Errorf("%v, get %v from invalid", any.err, path)}
74}
75
76func (any *invalidAny) Parse() *Iterator {
77 return nil
78}
79
80func (any *invalidAny) GetInterface() interface{} {
81 return nil
82}
diff --git a/vendor/github.com/json-iterator/go/any_nil.go b/vendor/github.com/json-iterator/go/any_nil.go
deleted file mode 100644
index d04cb54..0000000
--- a/vendor/github.com/json-iterator/go/any_nil.go
+++ /dev/null
@@ -1,69 +0,0 @@
1package jsoniter
2
3type nilAny struct {
4 baseAny
5}
6
7func (any *nilAny) LastError() error {
8 return nil
9}
10
11func (any *nilAny) ValueType() ValueType {
12 return NilValue
13}
14
15func (any *nilAny) MustBeValid() Any {
16 return any
17}
18
19func (any *nilAny) ToBool() bool {
20 return false
21}
22
23func (any *nilAny) ToInt() int {
24 return 0
25}
26
27func (any *nilAny) ToInt32() int32 {
28 return 0
29}
30
31func (any *nilAny) ToInt64() int64 {
32 return 0
33}
34
35func (any *nilAny) ToUint() uint {
36 return 0
37}
38
39func (any *nilAny) ToUint32() uint32 {
40 return 0
41}
42
43func (any *nilAny) ToUint64() uint64 {
44 return 0
45}
46
47func (any *nilAny) ToFloat32() float32 {
48 return 0
49}
50
51func (any *nilAny) ToFloat64() float64 {
52 return 0
53}
54
55func (any *nilAny) ToString() string {
56 return ""
57}
58
59func (any *nilAny) WriteTo(stream *Stream) {
60 stream.WriteNil()
61}
62
63func (any *nilAny) Parse() *Iterator {
64 return nil
65}
66
67func (any *nilAny) GetInterface() interface{} {
68 return nil
69}
diff --git a/vendor/github.com/json-iterator/go/any_number.go b/vendor/github.com/json-iterator/go/any_number.go
deleted file mode 100644
index 9d1e901..0000000
--- a/vendor/github.com/json-iterator/go/any_number.go
+++ /dev/null
@@ -1,123 +0,0 @@
1package jsoniter
2
3import (
4 "io"
5 "unsafe"
6)
7
8type numberLazyAny struct {
9 baseAny
10 cfg *frozenConfig
11 buf []byte
12 err error
13}
14
15func (any *numberLazyAny) ValueType() ValueType {
16 return NumberValue
17}
18
19func (any *numberLazyAny) MustBeValid() Any {
20 return any
21}
22
23func (any *numberLazyAny) LastError() error {
24 return any.err
25}
26
27func (any *numberLazyAny) ToBool() bool {
28 return any.ToFloat64() != 0
29}
30
31func (any *numberLazyAny) ToInt() int {
32 iter := any.cfg.BorrowIterator(any.buf)
33 defer any.cfg.ReturnIterator(iter)
34 val := iter.ReadInt()
35 if iter.Error != nil && iter.Error != io.EOF {
36 any.err = iter.Error
37 }
38 return val
39}
40
41func (any *numberLazyAny) ToInt32() int32 {
42 iter := any.cfg.BorrowIterator(any.buf)
43 defer any.cfg.ReturnIterator(iter)
44 val := iter.ReadInt32()
45 if iter.Error != nil && iter.Error != io.EOF {
46 any.err = iter.Error
47 }
48 return val
49}
50
51func (any *numberLazyAny) ToInt64() int64 {
52 iter := any.cfg.BorrowIterator(any.buf)
53 defer any.cfg.ReturnIterator(iter)
54 val := iter.ReadInt64()
55 if iter.Error != nil && iter.Error != io.EOF {
56 any.err = iter.Error
57 }
58 return val
59}
60
61func (any *numberLazyAny) ToUint() uint {
62 iter := any.cfg.BorrowIterator(any.buf)
63 defer any.cfg.ReturnIterator(iter)
64 val := iter.ReadUint()
65 if iter.Error != nil && iter.Error != io.EOF {
66 any.err = iter.Error
67 }
68 return val
69}
70
71func (any *numberLazyAny) ToUint32() uint32 {
72 iter := any.cfg.BorrowIterator(any.buf)
73 defer any.cfg.ReturnIterator(iter)
74 val := iter.ReadUint32()
75 if iter.Error != nil && iter.Error != io.EOF {
76 any.err = iter.Error
77 }
78 return val
79}
80
81func (any *numberLazyAny) ToUint64() uint64 {
82 iter := any.cfg.BorrowIterator(any.buf)
83 defer any.cfg.ReturnIterator(iter)
84 val := iter.ReadUint64()
85 if iter.Error != nil && iter.Error != io.EOF {
86 any.err = iter.Error
87 }
88 return val
89}
90
91func (any *numberLazyAny) ToFloat32() float32 {
92 iter := any.cfg.BorrowIterator(any.buf)
93 defer any.cfg.ReturnIterator(iter)
94 val := iter.ReadFloat32()
95 if iter.Error != nil && iter.Error != io.EOF {
96 any.err = iter.Error
97 }
98 return val
99}
100
101func (any *numberLazyAny) ToFloat64() float64 {
102 iter := any.cfg.BorrowIterator(any.buf)
103 defer any.cfg.ReturnIterator(iter)
104 val := iter.ReadFloat64()
105 if iter.Error != nil && iter.Error != io.EOF {
106 any.err = iter.Error
107 }
108 return val
109}
110
111func (any *numberLazyAny) ToString() string {
112 return *(*string)(unsafe.Pointer(&any.buf))
113}
114
115func (any *numberLazyAny) WriteTo(stream *Stream) {
116 stream.Write(any.buf)
117}
118
119func (any *numberLazyAny) GetInterface() interface{} {
120 iter := any.cfg.BorrowIterator(any.buf)
121 defer any.cfg.ReturnIterator(iter)
122 return iter.Read()
123}
diff --git a/vendor/github.com/json-iterator/go/any_object.go b/vendor/github.com/json-iterator/go/any_object.go
deleted file mode 100644
index c44ef5c..0000000
--- a/vendor/github.com/json-iterator/go/any_object.go
+++ /dev/null
@@ -1,374 +0,0 @@
1package jsoniter
2
3import (
4 "reflect"
5 "unsafe"
6)
7
8type objectLazyAny struct {
9 baseAny
10 cfg *frozenConfig
11 buf []byte
12 err error
13}
14
15func (any *objectLazyAny) ValueType() ValueType {
16 return ObjectValue
17}
18
19func (any *objectLazyAny) MustBeValid() Any {
20 return any
21}
22
23func (any *objectLazyAny) LastError() error {
24 return any.err
25}
26
27func (any *objectLazyAny) ToBool() bool {
28 return true
29}
30
31func (any *objectLazyAny) ToInt() int {
32 return 0
33}
34
35func (any *objectLazyAny) ToInt32() int32 {
36 return 0
37}
38
39func (any *objectLazyAny) ToInt64() int64 {
40 return 0
41}
42
43func (any *objectLazyAny) ToUint() uint {
44 return 0
45}
46
47func (any *objectLazyAny) ToUint32() uint32 {
48 return 0
49}
50
51func (any *objectLazyAny) ToUint64() uint64 {
52 return 0
53}
54
55func (any *objectLazyAny) ToFloat32() float32 {
56 return 0
57}
58
59func (any *objectLazyAny) ToFloat64() float64 {
60 return 0
61}
62
63func (any *objectLazyAny) ToString() string {
64 return *(*string)(unsafe.Pointer(&any.buf))
65}
66
67func (any *objectLazyAny) ToVal(obj interface{}) {
68 iter := any.cfg.BorrowIterator(any.buf)
69 defer any.cfg.ReturnIterator(iter)
70 iter.ReadVal(obj)
71}
72
73func (any *objectLazyAny) Get(path ...interface{}) Any {
74 if len(path) == 0 {
75 return any
76 }
77 switch firstPath := path[0].(type) {
78 case string:
79 iter := any.cfg.BorrowIterator(any.buf)
80 defer any.cfg.ReturnIterator(iter)
81 valueBytes := locateObjectField(iter, firstPath)
82 if valueBytes == nil {
83 return newInvalidAny(path)
84 }
85 iter.ResetBytes(valueBytes)
86 return locatePath(iter, path[1:])
87 case int32:
88 if '*' == firstPath {
89 mappedAll := map[string]Any{}
90 iter := any.cfg.BorrowIterator(any.buf)
91 defer any.cfg.ReturnIterator(iter)
92 iter.ReadMapCB(func(iter *Iterator, field string) bool {
93 mapped := locatePath(iter, path[1:])
94 if mapped.ValueType() != InvalidValue {
95 mappedAll[field] = mapped
96 }
97 return true
98 })
99 return wrapMap(mappedAll)
100 }
101 return newInvalidAny(path)
102 default:
103 return newInvalidAny(path)
104 }
105}
106
107func (any *objectLazyAny) Keys() []string {
108 keys := []string{}
109 iter := any.cfg.BorrowIterator(any.buf)
110 defer any.cfg.ReturnIterator(iter)
111 iter.ReadMapCB(func(iter *Iterator, field string) bool {
112 iter.Skip()
113 keys = append(keys, field)
114 return true
115 })
116 return keys
117}
118
119func (any *objectLazyAny) Size() int {
120 size := 0
121 iter := any.cfg.BorrowIterator(any.buf)
122 defer any.cfg.ReturnIterator(iter)
123 iter.ReadObjectCB(func(iter *Iterator, field string) bool {
124 iter.Skip()
125 size++
126 return true
127 })
128 return size
129}
130
131func (any *objectLazyAny) WriteTo(stream *Stream) {
132 stream.Write(any.buf)
133}
134
135func (any *objectLazyAny) GetInterface() interface{} {
136 iter := any.cfg.BorrowIterator(any.buf)
137 defer any.cfg.ReturnIterator(iter)
138 return iter.Read()
139}
140
141type objectAny struct {
142 baseAny
143 err error
144 val reflect.Value
145}
146
147func wrapStruct(val interface{}) *objectAny {
148 return &objectAny{baseAny{}, nil, reflect.ValueOf(val)}
149}
150
151func (any *objectAny) ValueType() ValueType {
152 return ObjectValue
153}
154
155func (any *objectAny) MustBeValid() Any {
156 return any
157}
158
159func (any *objectAny) Parse() *Iterator {
160 return nil
161}
162
163func (any *objectAny) LastError() error {
164 return any.err
165}
166
167func (any *objectAny) ToBool() bool {
168 return any.val.NumField() != 0
169}
170
171func (any *objectAny) ToInt() int {
172 return 0
173}
174
175func (any *objectAny) ToInt32() int32 {
176 return 0
177}
178
179func (any *objectAny) ToInt64() int64 {
180 return 0
181}
182
183func (any *objectAny) ToUint() uint {
184 return 0
185}
186
187func (any *objectAny) ToUint32() uint32 {
188 return 0
189}
190
191func (any *objectAny) ToUint64() uint64 {
192 return 0
193}
194
195func (any *objectAny) ToFloat32() float32 {
196 return 0
197}
198
199func (any *objectAny) ToFloat64() float64 {
200 return 0
201}
202
203func (any *objectAny) ToString() string {
204 str, err := MarshalToString(any.val.Interface())
205 any.err = err
206 return str
207}
208
209func (any *objectAny) Get(path ...interface{}) Any {
210 if len(path) == 0 {
211 return any
212 }
213 switch firstPath := path[0].(type) {
214 case string:
215 field := any.val.FieldByName(firstPath)
216 if !field.IsValid() {
217 return newInvalidAny(path)
218 }
219 return Wrap(field.Interface())
220 case int32:
221 if '*' == firstPath {
222 mappedAll := map[string]Any{}
223 for i := 0; i < any.val.NumField(); i++ {
224 field := any.val.Field(i)
225 if field.CanInterface() {
226 mapped := Wrap(field.Interface()).Get(path[1:]...)
227 if mapped.ValueType() != InvalidValue {
228 mappedAll[any.val.Type().Field(i).Name] = mapped
229 }
230 }
231 }
232 return wrapMap(mappedAll)
233 }
234 return newInvalidAny(path)
235 default:
236 return newInvalidAny(path)
237 }
238}
239
240func (any *objectAny) Keys() []string {
241 keys := make([]string, 0, any.val.NumField())
242 for i := 0; i < any.val.NumField(); i++ {
243 keys = append(keys, any.val.Type().Field(i).Name)
244 }
245 return keys
246}
247
248func (any *objectAny) Size() int {
249 return any.val.NumField()
250}
251
252func (any *objectAny) WriteTo(stream *Stream) {
253 stream.WriteVal(any.val)
254}
255
256func (any *objectAny) GetInterface() interface{} {
257 return any.val.Interface()
258}
259
260type mapAny struct {
261 baseAny
262 err error
263 val reflect.Value
264}
265
266func wrapMap(val interface{}) *mapAny {
267 return &mapAny{baseAny{}, nil, reflect.ValueOf(val)}
268}
269
270func (any *mapAny) ValueType() ValueType {
271 return ObjectValue
272}
273
274func (any *mapAny) MustBeValid() Any {
275 return any
276}
277
278func (any *mapAny) Parse() *Iterator {
279 return nil
280}
281
282func (any *mapAny) LastError() error {
283 return any.err
284}
285
286func (any *mapAny) ToBool() bool {
287 return true
288}
289
290func (any *mapAny) ToInt() int {
291 return 0
292}
293
294func (any *mapAny) ToInt32() int32 {
295 return 0
296}
297
298func (any *mapAny) ToInt64() int64 {
299 return 0
300}
301
302func (any *mapAny) ToUint() uint {
303 return 0
304}
305
306func (any *mapAny) ToUint32() uint32 {
307 return 0
308}
309
310func (any *mapAny) ToUint64() uint64 {
311 return 0
312}
313
314func (any *mapAny) ToFloat32() float32 {
315 return 0
316}
317
318func (any *mapAny) ToFloat64() float64 {
319 return 0
320}
321
322func (any *mapAny) ToString() string {
323 str, err := MarshalToString(any.val.Interface())
324 any.err = err
325 return str
326}
327
328func (any *mapAny) Get(path ...interface{}) Any {
329 if len(path) == 0 {
330 return any
331 }
332 switch firstPath := path[0].(type) {
333 case int32:
334 if '*' == firstPath {
335 mappedAll := map[string]Any{}
336 for _, key := range any.val.MapKeys() {
337 keyAsStr := key.String()
338 element := Wrap(any.val.MapIndex(key).Interface())
339 mapped := element.Get(path[1:]...)
340 if mapped.ValueType() != InvalidValue {
341 mappedAll[keyAsStr] = mapped
342 }
343 }
344 return wrapMap(mappedAll)
345 }
346 return newInvalidAny(path)
347 default:
348 value := any.val.MapIndex(reflect.ValueOf(firstPath))
349 if !value.IsValid() {
350 return newInvalidAny(path)
351 }
352 return Wrap(value.Interface())
353 }
354}
355
356func (any *mapAny) Keys() []string {
357 keys := make([]string, 0, any.val.Len())
358 for _, key := range any.val.MapKeys() {
359 keys = append(keys, key.String())
360 }
361 return keys
362}
363
364func (any *mapAny) Size() int {
365 return any.val.Len()
366}
367
368func (any *mapAny) WriteTo(stream *Stream) {
369 stream.WriteVal(any.val)
370}
371
372func (any *mapAny) GetInterface() interface{} {
373 return any.val.Interface()
374}
diff --git a/vendor/github.com/json-iterator/go/any_str.go b/vendor/github.com/json-iterator/go/any_str.go
deleted file mode 100644
index 1f12f66..0000000
--- a/vendor/github.com/json-iterator/go/any_str.go
+++ /dev/null
@@ -1,166 +0,0 @@
1package jsoniter
2
3import (
4 "fmt"
5 "strconv"
6)
7
8type stringAny struct {
9 baseAny
10 val string
11}
12
13func (any *stringAny) Get(path ...interface{}) Any {
14 if len(path) == 0 {
15 return any
16 }
17 return &invalidAny{baseAny{}, fmt.Errorf("GetIndex %v from simple value", path)}
18}
19
20func (any *stringAny) Parse() *Iterator {
21 return nil
22}
23
24func (any *stringAny) ValueType() ValueType {
25 return StringValue
26}
27
28func (any *stringAny) MustBeValid() Any {
29 return any
30}
31
32func (any *stringAny) LastError() error {
33 return nil
34}
35
36func (any *stringAny) ToBool() bool {
37 str := any.ToString()
38 if str == "0" {
39 return false
40 }
41 for _, c := range str {
42 switch c {
43 case ' ', '\n', '\r', '\t':
44 default:
45 return true
46 }
47 }
48 return false
49}
50
51func (any *stringAny) ToInt() int {
52 return int(any.ToInt64())
53
54}
55
56func (any *stringAny) ToInt32() int32 {
57 return int32(any.ToInt64())
58}
59
60func (any *stringAny) ToInt64() int64 {
61 if any.val == "" {
62 return 0
63 }
64
65 flag := 1
66 startPos := 0
67 if any.val[0] == '+' || any.val[0] == '-' {
68 startPos = 1
69 }
70
71 if any.val[0] == '-' {
72 flag = -1
73 }
74
75 endPos := startPos
76 for i := startPos; i < len(any.val); i++ {
77 if any.val[i] >= '0' && any.val[i] <= '9' {
78 endPos = i + 1
79 } else {
80 break
81 }
82 }
83 parsed, _ := strconv.ParseInt(any.val[startPos:endPos], 10, 64)
84 return int64(flag) * parsed
85}
86
87func (any *stringAny) ToUint() uint {
88 return uint(any.ToUint64())
89}
90
91func (any *stringAny) ToUint32() uint32 {
92 return uint32(any.ToUint64())
93}
94
95func (any *stringAny) ToUint64() uint64 {
96 if any.val == "" {
97 return 0
98 }
99
100 startPos := 0
101
102 if any.val[0] == '-' {
103 return 0
104 }
105 if any.val[0] == '+' {
106 startPos = 1
107 }
108
109 endPos := startPos
110 for i := startPos; i < len(any.val); i++ {
111 if any.val[i] >= '0' && any.val[i] <= '9' {
112 endPos = i + 1
113 } else {
114 break
115 }
116 }
117 parsed, _ := strconv.ParseUint(any.val[startPos:endPos], 10, 64)
118 return parsed
119}
120
121func (any *stringAny) ToFloat32() float32 {
122 return float32(any.ToFloat64())
123}
124
125func (any *stringAny) ToFloat64() float64 {
126 if len(any.val) == 0 {
127 return 0
128 }
129
130 // first char invalid
131 if any.val[0] != '+' && any.val[0] != '-' && (any.val[0] > '9' || any.val[0] < '0') {
132 return 0
133 }
134
135 // extract valid num expression from string
136 // eg 123true => 123, -12.12xxa => -12.12
137 endPos := 1
138 for i := 1; i < len(any.val); i++ {
139 if any.val[i] == '.' || any.val[i] == 'e' || any.val[i] == 'E' || any.val[i] == '+' || any.val[i] == '-' {
140 endPos = i + 1
141 continue
142 }
143
144 // end position is the first char which is not digit
145 if any.val[i] >= '0' && any.val[i] <= '9' {
146 endPos = i + 1
147 } else {
148 endPos = i
149 break
150 }
151 }
152 parsed, _ := strconv.ParseFloat(any.val[:endPos], 64)
153 return parsed
154}
155
156func (any *stringAny) ToString() string {
157 return any.val
158}
159
160func (any *stringAny) WriteTo(stream *Stream) {
161 stream.WriteString(any.val)
162}
163
164func (any *stringAny) GetInterface() interface{} {
165 return any.val
166}
diff --git a/vendor/github.com/json-iterator/go/any_uint32.go b/vendor/github.com/json-iterator/go/any_uint32.go
deleted file mode 100644
index 656bbd3..0000000
--- a/vendor/github.com/json-iterator/go/any_uint32.go
+++ /dev/null
@@ -1,74 +0,0 @@
1package jsoniter
2
3import (
4 "strconv"
5)
6
7type uint32Any struct {
8 baseAny
9 val uint32
10}
11
12func (any *uint32Any) LastError() error {
13 return nil
14}
15
16func (any *uint32Any) ValueType() ValueType {
17 return NumberValue
18}
19
20func (any *uint32Any) MustBeValid() Any {
21 return any
22}
23
24func (any *uint32Any) ToBool() bool {
25 return any.val != 0
26}
27
28func (any *uint32Any) ToInt() int {
29 return int(any.val)
30}
31
32func (any *uint32Any) ToInt32() int32 {
33 return int32(any.val)
34}
35
36func (any *uint32Any) ToInt64() int64 {
37 return int64(any.val)
38}
39
40func (any *uint32Any) ToUint() uint {
41 return uint(any.val)
42}
43
44func (any *uint32Any) ToUint32() uint32 {
45 return any.val
46}
47
48func (any *uint32Any) ToUint64() uint64 {
49 return uint64(any.val)
50}
51
52func (any *uint32Any) ToFloat32() float32 {
53 return float32(any.val)
54}
55
56func (any *uint32Any) ToFloat64() float64 {
57 return float64(any.val)
58}
59
60func (any *uint32Any) ToString() string {
61 return strconv.FormatInt(int64(any.val), 10)
62}
63
64func (any *uint32Any) WriteTo(stream *Stream) {
65 stream.WriteUint32(any.val)
66}
67
68func (any *uint32Any) Parse() *Iterator {
69 return nil
70}
71
72func (any *uint32Any) GetInterface() interface{} {
73 return any.val
74}
diff --git a/vendor/github.com/json-iterator/go/any_uint64.go b/vendor/github.com/json-iterator/go/any_uint64.go
deleted file mode 100644
index 7df2fce..0000000
--- a/vendor/github.com/json-iterator/go/any_uint64.go
+++ /dev/null
@@ -1,74 +0,0 @@
1package jsoniter
2
3import (
4 "strconv"
5)
6
7type uint64Any struct {
8 baseAny
9 val uint64
10}
11
12func (any *uint64Any) LastError() error {
13 return nil
14}
15
16func (any *uint64Any) ValueType() ValueType {
17 return NumberValue
18}
19
20func (any *uint64Any) MustBeValid() Any {
21 return any
22}
23
24func (any *uint64Any) ToBool() bool {
25 return any.val != 0
26}
27
28func (any *uint64Any) ToInt() int {
29 return int(any.val)
30}
31
32func (any *uint64Any) ToInt32() int32 {
33 return int32(any.val)
34}
35
36func (any *uint64Any) ToInt64() int64 {
37 return int64(any.val)
38}
39
40func (any *uint64Any) ToUint() uint {
41 return uint(any.val)
42}
43
44func (any *uint64Any) ToUint32() uint32 {
45 return uint32(any.val)
46}
47
48func (any *uint64Any) ToUint64() uint64 {
49 return any.val
50}
51
52func (any *uint64Any) ToFloat32() float32 {
53 return float32(any.val)
54}
55
56func (any *uint64Any) ToFloat64() float64 {
57 return float64(any.val)
58}
59
60func (any *uint64Any) ToString() string {
61 return strconv.FormatUint(any.val, 10)
62}
63
64func (any *uint64Any) WriteTo(stream *Stream) {
65 stream.WriteUint64(any.val)
66}
67
68func (any *uint64Any) Parse() *Iterator {
69 return nil
70}
71
72func (any *uint64Any) GetInterface() interface{} {
73 return any.val
74}
diff --git a/vendor/github.com/json-iterator/go/build.sh b/vendor/github.com/json-iterator/go/build.sh
deleted file mode 100644
index b45ef68..0000000
--- a/vendor/github.com/json-iterator/go/build.sh
+++ /dev/null
@@ -1,12 +0,0 @@
1#!/bin/bash
2set -e
3set -x
4
5if [ ! -d /tmp/build-golang/src/github.com/json-iterator ]; then
6 mkdir -p /tmp/build-golang/src/github.com/json-iterator
7 ln -s $PWD /tmp/build-golang/src/github.com/json-iterator/go
8fi
9export GOPATH=/tmp/build-golang
10go get -u github.com/golang/dep/cmd/dep
11cd /tmp/build-golang/src/github.com/json-iterator/go
12exec $GOPATH/bin/dep ensure -update
diff --git a/vendor/github.com/json-iterator/go/config.go b/vendor/github.com/json-iterator/go/config.go
deleted file mode 100644
index 2adcdc3..0000000
--- a/vendor/github.com/json-iterator/go/config.go
+++ /dev/null
@@ -1,375 +0,0 @@
1package jsoniter
2
3import (
4 "encoding/json"
5 "io"
6 "reflect"
7 "sync"
8 "unsafe"
9
10 "github.com/modern-go/concurrent"
11 "github.com/modern-go/reflect2"
12)
13
14// Config customize how the API should behave.
15// The API is created from Config by Froze.
16type Config struct {
17 IndentionStep int
18 MarshalFloatWith6Digits bool
19 EscapeHTML bool
20 SortMapKeys bool
21 UseNumber bool
22 DisallowUnknownFields bool
23 TagKey string
24 OnlyTaggedField bool
25 ValidateJsonRawMessage bool
26 ObjectFieldMustBeSimpleString bool
27 CaseSensitive bool
28}
29
30// API the public interface of this package.
31// Primary Marshal and Unmarshal.
32type API interface {
33 IteratorPool
34 StreamPool
35 MarshalToString(v interface{}) (string, error)
36 Marshal(v interface{}) ([]byte, error)
37 MarshalIndent(v interface{}, prefix, indent string) ([]byte, error)
38 UnmarshalFromString(str string, v interface{}) error
39 Unmarshal(data []byte, v interface{}) error
40 Get(data []byte, path ...interface{}) Any
41 NewEncoder(writer io.Writer) *Encoder
42 NewDecoder(reader io.Reader) *Decoder
43 Valid(data []byte) bool
44 RegisterExtension(extension Extension)
45 DecoderOf(typ reflect2.Type) ValDecoder
46 EncoderOf(typ reflect2.Type) ValEncoder
47}
48
49// ConfigDefault the default API
50var ConfigDefault = Config{
51 EscapeHTML: true,
52}.Froze()
53
54// ConfigCompatibleWithStandardLibrary tries to be 100% compatible with standard library behavior
55var ConfigCompatibleWithStandardLibrary = Config{
56 EscapeHTML: true,
57 SortMapKeys: true,
58 ValidateJsonRawMessage: true,
59}.Froze()
60
61// ConfigFastest marshals float with only 6 digits precision
62var ConfigFastest = Config{
63 EscapeHTML: false,
64 MarshalFloatWith6Digits: true, // will lose precession
65 ObjectFieldMustBeSimpleString: true, // do not unescape object field
66}.Froze()
67
68type frozenConfig struct {
69 configBeforeFrozen Config
70 sortMapKeys bool
71 indentionStep int
72 objectFieldMustBeSimpleString bool
73 onlyTaggedField bool
74 disallowUnknownFields bool
75 decoderCache *concurrent.Map
76 encoderCache *concurrent.Map
77 encoderExtension Extension
78 decoderExtension Extension
79 extraExtensions []Extension
80 streamPool *sync.Pool
81 iteratorPool *sync.Pool
82 caseSensitive bool
83}
84
85func (cfg *frozenConfig) initCache() {
86 cfg.decoderCache = concurrent.NewMap()
87 cfg.encoderCache = concurrent.NewMap()
88}
89
90func (cfg *frozenConfig) addDecoderToCache(cacheKey uintptr, decoder ValDecoder) {
91 cfg.decoderCache.Store(cacheKey, decoder)
92}
93
94func (cfg *frozenConfig) addEncoderToCache(cacheKey uintptr, encoder ValEncoder) {
95 cfg.encoderCache.Store(cacheKey, encoder)
96}
97
98func (cfg *frozenConfig) getDecoderFromCache(cacheKey uintptr) ValDecoder {
99 decoder, found := cfg.decoderCache.Load(cacheKey)
100 if found {
101 return decoder.(ValDecoder)
102 }
103 return nil
104}
105
106func (cfg *frozenConfig) getEncoderFromCache(cacheKey uintptr) ValEncoder {
107 encoder, found := cfg.encoderCache.Load(cacheKey)
108 if found {
109 return encoder.(ValEncoder)
110 }
111 return nil
112}
113
114var cfgCache = concurrent.NewMap()
115
116func getFrozenConfigFromCache(cfg Config) *frozenConfig {
117 obj, found := cfgCache.Load(cfg)
118 if found {
119 return obj.(*frozenConfig)
120 }
121 return nil
122}
123
124func addFrozenConfigToCache(cfg Config, frozenConfig *frozenConfig) {
125 cfgCache.Store(cfg, frozenConfig)
126}
127
128// Froze forge API from config
129func (cfg Config) Froze() API {
130 api := &frozenConfig{
131 sortMapKeys: cfg.SortMapKeys,
132 indentionStep: cfg.IndentionStep,
133 objectFieldMustBeSimpleString: cfg.ObjectFieldMustBeSimpleString,
134 onlyTaggedField: cfg.OnlyTaggedField,
135 disallowUnknownFields: cfg.DisallowUnknownFields,
136 caseSensitive: cfg.CaseSensitive,
137 }
138 api.streamPool = &sync.Pool{
139 New: func() interface{} {
140 return NewStream(api, nil, 512)
141 },
142 }
143 api.iteratorPool = &sync.Pool{
144 New: func() interface{} {
145 return NewIterator(api)
146 },
147 }
148 api.initCache()
149 encoderExtension := EncoderExtension{}
150 decoderExtension := DecoderExtension{}
151 if cfg.MarshalFloatWith6Digits {
152 api.marshalFloatWith6Digits(encoderExtension)
153 }
154 if cfg.EscapeHTML {
155 api.escapeHTML(encoderExtension)
156 }
157 if cfg.UseNumber {
158 api.useNumber(decoderExtension)
159 }
160 if cfg.ValidateJsonRawMessage {
161 api.validateJsonRawMessage(encoderExtension)
162 }
163 api.encoderExtension = encoderExtension
164 api.decoderExtension = decoderExtension
165 api.configBeforeFrozen = cfg
166 return api
167}
168
169func (cfg Config) frozeWithCacheReuse(extraExtensions []Extension) *frozenConfig {
170 api := getFrozenConfigFromCache(cfg)
171 if api != nil {
172 return api
173 }
174 api = cfg.Froze().(*frozenConfig)
175 for _, extension := range extraExtensions {
176 api.RegisterExtension(extension)
177 }
178 addFrozenConfigToCache(cfg, api)
179 return api
180}
181
182func (cfg *frozenConfig) validateJsonRawMessage(extension EncoderExtension) {
183 encoder := &funcEncoder{func(ptr unsafe.Pointer, stream *Stream) {
184 rawMessage := *(*json.RawMessage)(ptr)
185 iter := cfg.BorrowIterator([]byte(rawMessage))
186 defer cfg.ReturnIterator(iter)
187 iter.Read()
188 if iter.Error != nil && iter.Error != io.EOF {
189 stream.WriteRaw("null")
190 } else {
191 stream.WriteRaw(string(rawMessage))
192 }
193 }, func(ptr unsafe.Pointer) bool {
194 return len(*((*json.RawMessage)(ptr))) == 0
195 }}
196 extension[reflect2.TypeOfPtr((*json.RawMessage)(nil)).Elem()] = encoder
197 extension[reflect2.TypeOfPtr((*RawMessage)(nil)).Elem()] = encoder
198}
199
200func (cfg *frozenConfig) useNumber(extension DecoderExtension) {
201 extension[reflect2.TypeOfPtr((*interface{})(nil)).Elem()] = &funcDecoder{func(ptr unsafe.Pointer, iter *Iterator) {
202 exitingValue := *((*interface{})(ptr))
203 if exitingValue != nil && reflect.TypeOf(exitingValue).Kind() == reflect.Ptr {
204 iter.ReadVal(exitingValue)
205 return
206 }
207 if iter.WhatIsNext() == NumberValue {
208 *((*interface{})(ptr)) = json.Number(iter.readNumberAsString())
209 } else {
210 *((*interface{})(ptr)) = iter.Read()
211 }
212 }}
213}
214func (cfg *frozenConfig) getTagKey() string {
215 tagKey := cfg.configBeforeFrozen.TagKey
216 if tagKey == "" {
217 return "json"
218 }
219 return tagKey
220}
221
222func (cfg *frozenConfig) RegisterExtension(extension Extension) {
223 cfg.extraExtensions = append(cfg.extraExtensions, extension)
224 copied := cfg.configBeforeFrozen
225 cfg.configBeforeFrozen = copied
226}
227
228type lossyFloat32Encoder struct {
229}
230
231func (encoder *lossyFloat32Encoder) Encode(ptr unsafe.Pointer, stream *Stream) {
232 stream.WriteFloat32Lossy(*((*float32)(ptr)))
233}
234
235func (encoder *lossyFloat32Encoder) IsEmpty(ptr unsafe.Pointer) bool {
236 return *((*float32)(ptr)) == 0
237}
238
239type lossyFloat64Encoder struct {
240}
241
242func (encoder *lossyFloat64Encoder) Encode(ptr unsafe.Pointer, stream *Stream) {
243 stream.WriteFloat64Lossy(*((*float64)(ptr)))
244}
245
246func (encoder *lossyFloat64Encoder) IsEmpty(ptr unsafe.Pointer) bool {
247 return *((*float64)(ptr)) == 0
248}
249
250// EnableLossyFloatMarshalling keeps 10**(-6) precision
251// for float variables for better performance.
252func (cfg *frozenConfig) marshalFloatWith6Digits(extension EncoderExtension) {
253 // for better performance
254 extension[reflect2.TypeOfPtr((*float32)(nil)).Elem()] = &lossyFloat32Encoder{}
255 extension[reflect2.TypeOfPtr((*float64)(nil)).Elem()] = &lossyFloat64Encoder{}
256}
257
258type htmlEscapedStringEncoder struct {
259}
260
261func (encoder *htmlEscapedStringEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
262 str := *((*string)(ptr))
263 stream.WriteStringWithHTMLEscaped(str)
264}
265
266func (encoder *htmlEscapedStringEncoder) IsEmpty(ptr unsafe.Pointer) bool {
267 return *((*string)(ptr)) == ""
268}
269
270func (cfg *frozenConfig) escapeHTML(encoderExtension EncoderExtension) {
271 encoderExtension[reflect2.TypeOfPtr((*string)(nil)).Elem()] = &htmlEscapedStringEncoder{}
272}
273
274func (cfg *frozenConfig) cleanDecoders() {
275 typeDecoders = map[string]ValDecoder{}
276 fieldDecoders = map[string]ValDecoder{}
277 *cfg = *(cfg.configBeforeFrozen.Froze().(*frozenConfig))
278}
279
280func (cfg *frozenConfig) cleanEncoders() {
281 typeEncoders = map[string]ValEncoder{}
282 fieldEncoders = map[string]ValEncoder{}
283 *cfg = *(cfg.configBeforeFrozen.Froze().(*frozenConfig))
284}
285
286func (cfg *frozenConfig) MarshalToString(v interface{}) (string, error) {
287 stream := cfg.BorrowStream(nil)
288 defer cfg.ReturnStream(stream)
289 stream.WriteVal(v)
290 if stream.Error != nil {
291 return "", stream.Error
292 }
293 return string(stream.Buffer()), nil
294}
295
296func (cfg *frozenConfig) Marshal(v interface{}) ([]byte, error) {
297 stream := cfg.BorrowStream(nil)
298 defer cfg.ReturnStream(stream)
299 stream.WriteVal(v)
300 if stream.Error != nil {
301 return nil, stream.Error
302 }
303 result := stream.Buffer()
304 copied := make([]byte, len(result))
305 copy(copied, result)
306 return copied, nil
307}
308
309func (cfg *frozenConfig) MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
310 if prefix != "" {
311 panic("prefix is not supported")
312 }
313 for _, r := range indent {
314 if r != ' ' {
315 panic("indent can only be space")
316 }
317 }
318 newCfg := cfg.configBeforeFrozen
319 newCfg.IndentionStep = len(indent)
320 return newCfg.frozeWithCacheReuse(cfg.extraExtensions).Marshal(v)
321}
322
323func (cfg *frozenConfig) UnmarshalFromString(str string, v interface{}) error {
324 data := []byte(str)
325 iter := cfg.BorrowIterator(data)
326 defer cfg.ReturnIterator(iter)
327 iter.ReadVal(v)
328 c := iter.nextToken()
329 if c == 0 {
330 if iter.Error == io.EOF {
331 return nil
332 }
333 return iter.Error
334 }
335 iter.ReportError("Unmarshal", "there are bytes left after unmarshal")
336 return iter.Error
337}
338
339func (cfg *frozenConfig) Get(data []byte, path ...interface{}) Any {
340 iter := cfg.BorrowIterator(data)
341 defer cfg.ReturnIterator(iter)
342 return locatePath(iter, path)
343}
344
345func (cfg *frozenConfig) Unmarshal(data []byte, v interface{}) error {
346 iter := cfg.BorrowIterator(data)
347 defer cfg.ReturnIterator(iter)
348 iter.ReadVal(v)
349 c := iter.nextToken()
350 if c == 0 {
351 if iter.Error == io.EOF {
352 return nil
353 }
354 return iter.Error
355 }
356 iter.ReportError("Unmarshal", "there are bytes left after unmarshal")
357 return iter.Error
358}
359
360func (cfg *frozenConfig) NewEncoder(writer io.Writer) *Encoder {
361 stream := NewStream(cfg, writer, 512)
362 return &Encoder{stream}
363}
364
365func (cfg *frozenConfig) NewDecoder(reader io.Reader) *Decoder {
366 iter := Parse(cfg, reader, 512)
367 return &Decoder{iter}
368}
369
370func (cfg *frozenConfig) Valid(data []byte) bool {
371 iter := cfg.BorrowIterator(data)
372 defer cfg.ReturnIterator(iter)
373 iter.Skip()
374 return iter.Error == nil
375}
diff --git a/vendor/github.com/json-iterator/go/fuzzy_mode_convert_table.md b/vendor/github.com/json-iterator/go/fuzzy_mode_convert_table.md
deleted file mode 100644
index 3095662..0000000
--- a/vendor/github.com/json-iterator/go/fuzzy_mode_convert_table.md
+++ /dev/null
@@ -1,7 +0,0 @@
1| json type \ dest type | bool | int | uint | float |string|
2| --- | --- | --- | --- |--|--|
3| number | positive => true <br/> negative => true <br/> zero => false| 23.2 => 23 <br/> -32.1 => -32| 12.1 => 12 <br/> -12.1 => 0|as normal|same as origin|
4| string | empty string => false <br/> string "0" => false <br/> other strings => true | "123.32" => 123 <br/> "-123.4" => -123 <br/> "123.23xxxw" => 123 <br/> "abcde12" => 0 <br/> "-32.1" => -32| 13.2 => 13 <br/> -1.1 => 0 |12.1 => 12.1 <br/> -12.3 => -12.3<br/> 12.4xxa => 12.4 <br/> +1.1e2 =>110 |same as origin|
5| bool | true => true <br/> false => false| true => 1 <br/> false => 0 | true => 1 <br/> false => 0 |true => 1 <br/>false => 0|true => "true" <br/> false => "false"|
6| object | true | 0 | 0 |0|originnal json|
7| array | empty array => false <br/> nonempty array => true| [] => 0 <br/> [1,2] => 1 | [] => 0 <br/> [1,2] => 1 |[] => 0<br/>[1,2] => 1|original json| \ No newline at end of file
diff --git a/vendor/github.com/json-iterator/go/iter.go b/vendor/github.com/json-iterator/go/iter.go
deleted file mode 100644
index 29b31cf..0000000
--- a/vendor/github.com/json-iterator/go/iter.go
+++ /dev/null
@@ -1,349 +0,0 @@
1package jsoniter
2
3import (
4 "encoding/json"
5 "fmt"
6 "io"
7)
8
9// ValueType the type for JSON element
10type ValueType int
11
12const (
13 // InvalidValue invalid JSON element
14 InvalidValue ValueType = iota
15 // StringValue JSON element "string"
16 StringValue
17 // NumberValue JSON element 100 or 0.10
18 NumberValue
19 // NilValue JSON element null
20 NilValue
21 // BoolValue JSON element true or false
22 BoolValue
23 // ArrayValue JSON element []
24 ArrayValue
25 // ObjectValue JSON element {}
26 ObjectValue
27)
28
29var hexDigits []byte
30var valueTypes []ValueType
31
32func init() {
33 hexDigits = make([]byte, 256)
34 for i := 0; i < len(hexDigits); i++ {
35 hexDigits[i] = 255
36 }
37 for i := '0'; i <= '9'; i++ {
38 hexDigits[i] = byte(i - '0')
39 }
40 for i := 'a'; i <= 'f'; i++ {
41 hexDigits[i] = byte((i - 'a') + 10)
42 }
43 for i := 'A'; i <= 'F'; i++ {
44 hexDigits[i] = byte((i - 'A') + 10)
45 }
46 valueTypes = make([]ValueType, 256)
47 for i := 0; i < len(valueTypes); i++ {
48 valueTypes[i] = InvalidValue
49 }
50 valueTypes['"'] = StringValue
51 valueTypes['-'] = NumberValue
52 valueTypes['0'] = NumberValue
53 valueTypes['1'] = NumberValue
54 valueTypes['2'] = NumberValue
55 valueTypes['3'] = NumberValue
56 valueTypes['4'] = NumberValue
57 valueTypes['5'] = NumberValue
58 valueTypes['6'] = NumberValue
59 valueTypes['7'] = NumberValue
60 valueTypes['8'] = NumberValue
61 valueTypes['9'] = NumberValue
62 valueTypes['t'] = BoolValue
63 valueTypes['f'] = BoolValue
64 valueTypes['n'] = NilValue
65 valueTypes['['] = ArrayValue
66 valueTypes['{'] = ObjectValue
67}
68
69// Iterator is a io.Reader like object, with JSON specific read functions.
70// Error is not returned as return value, but stored as Error member on this iterator instance.
71type Iterator struct {
72 cfg *frozenConfig
73 reader io.Reader
74 buf []byte
75 head int
76 tail int
77 depth int
78 captureStartedAt int
79 captured []byte
80 Error error
81 Attachment interface{} // open for customized decoder
82}
83
84// NewIterator creates an empty Iterator instance
85func NewIterator(cfg API) *Iterator {
86 return &Iterator{
87 cfg: cfg.(*frozenConfig),
88 reader: nil,
89 buf: nil,
90 head: 0,
91 tail: 0,
92 depth: 0,
93 }
94}
95
96// Parse creates an Iterator instance from io.Reader
97func Parse(cfg API, reader io.Reader, bufSize int) *Iterator {
98 return &Iterator{
99 cfg: cfg.(*frozenConfig),
100 reader: reader,
101 buf: make([]byte, bufSize),
102 head: 0,
103 tail: 0,
104 depth: 0,
105 }
106}
107
108// ParseBytes creates an Iterator instance from byte array
109func ParseBytes(cfg API, input []byte) *Iterator {
110 return &Iterator{
111 cfg: cfg.(*frozenConfig),
112 reader: nil,
113 buf: input,
114 head: 0,
115 tail: len(input),
116 depth: 0,
117 }
118}
119
120// ParseString creates an Iterator instance from string
121func ParseString(cfg API, input string) *Iterator {
122 return ParseBytes(cfg, []byte(input))
123}
124
125// Pool returns a pool can provide more iterator with same configuration
126func (iter *Iterator) Pool() IteratorPool {
127 return iter.cfg
128}
129
130// Reset reuse iterator instance by specifying another reader
131func (iter *Iterator) Reset(reader io.Reader) *Iterator {
132 iter.reader = reader
133 iter.head = 0
134 iter.tail = 0
135 iter.depth = 0
136 return iter
137}
138
139// ResetBytes reuse iterator instance by specifying another byte array as input
140func (iter *Iterator) ResetBytes(input []byte) *Iterator {
141 iter.reader = nil
142 iter.buf = input
143 iter.head = 0
144 iter.tail = len(input)
145 iter.depth = 0
146 return iter
147}
148
149// WhatIsNext gets ValueType of relatively next json element
150func (iter *Iterator) WhatIsNext() ValueType {
151 valueType := valueTypes[iter.nextToken()]
152 iter.unreadByte()
153 return valueType
154}
155
156func (iter *Iterator) skipWhitespacesWithoutLoadMore() bool {
157 for i := iter.head; i < iter.tail; i++ {
158 c := iter.buf[i]
159 switch c {
160 case ' ', '\n', '\t', '\r':
161 continue
162 }
163 iter.head = i
164 return false
165 }
166 return true
167}
168
169func (iter *Iterator) isObjectEnd() bool {
170 c := iter.nextToken()
171 if c == ',' {
172 return false
173 }
174 if c == '}' {
175 return true
176 }
177 iter.ReportError("isObjectEnd", "object ended prematurely, unexpected char "+string([]byte{c}))
178 return true
179}
180
181func (iter *Iterator) nextToken() byte {
182 // a variation of skip whitespaces, returning the next non-whitespace token
183 for {
184 for i := iter.head; i < iter.tail; i++ {
185 c := iter.buf[i]
186 switch c {
187 case ' ', '\n', '\t', '\r':
188 continue
189 }
190 iter.head = i + 1
191 return c
192 }
193 if !iter.loadMore() {
194 return 0
195 }
196 }
197}
198
199// ReportError record a error in iterator instance with current position.
200func (iter *Iterator) ReportError(operation string, msg string) {
201 if iter.Error != nil {
202 if iter.Error != io.EOF {
203 return
204 }
205 }
206 peekStart := iter.head - 10
207 if peekStart < 0 {
208 peekStart = 0
209 }
210 peekEnd := iter.head + 10
211 if peekEnd > iter.tail {
212 peekEnd = iter.tail
213 }
214 parsing := string(iter.buf[peekStart:peekEnd])
215 contextStart := iter.head - 50
216 if contextStart < 0 {
217 contextStart = 0
218 }
219 contextEnd := iter.head + 50
220 if contextEnd > iter.tail {
221 contextEnd = iter.tail
222 }
223 context := string(iter.buf[contextStart:contextEnd])
224 iter.Error = fmt.Errorf("%s: %s, error found in #%v byte of ...|%s|..., bigger context ...|%s|...",
225 operation, msg, iter.head-peekStart, parsing, context)
226}
227
228// CurrentBuffer gets current buffer as string for debugging purpose
229func (iter *Iterator) CurrentBuffer() string {
230 peekStart := iter.head - 10
231 if peekStart < 0 {
232 peekStart = 0
233 }
234 return fmt.Sprintf("parsing #%v byte, around ...|%s|..., whole buffer ...|%s|...", iter.head,
235 string(iter.buf[peekStart:iter.head]), string(iter.buf[0:iter.tail]))
236}
237
238func (iter *Iterator) readByte() (ret byte) {
239 if iter.head == iter.tail {
240 if iter.loadMore() {
241 ret = iter.buf[iter.head]
242 iter.head++
243 return ret
244 }
245 return 0
246 }
247 ret = iter.buf[iter.head]
248 iter.head++
249 return ret
250}
251
252func (iter *Iterator) loadMore() bool {
253 if iter.reader == nil {
254 if iter.Error == nil {
255 iter.head = iter.tail
256 iter.Error = io.EOF
257 }
258 return false
259 }
260 if iter.captured != nil {
261 iter.captured = append(iter.captured,
262 iter.buf[iter.captureStartedAt:iter.tail]...)
263 iter.captureStartedAt = 0
264 }
265 for {
266 n, err := iter.reader.Read(iter.buf)
267 if n == 0 {
268 if err != nil {
269 if iter.Error == nil {
270 iter.Error = err
271 }
272 return false
273 }
274 } else {
275 iter.head = 0
276 iter.tail = n
277 return true
278 }
279 }
280}
281
282func (iter *Iterator) unreadByte() {
283 if iter.Error != nil {
284 return
285 }
286 iter.head--
287 return
288}
289
290// Read read the next JSON element as generic interface{}.
291func (iter *Iterator) Read() interface{} {
292 valueType := iter.WhatIsNext()
293 switch valueType {
294 case StringValue:
295 return iter.ReadString()
296 case NumberValue:
297 if iter.cfg.configBeforeFrozen.UseNumber {
298 return json.Number(iter.readNumberAsString())
299 }
300 return iter.ReadFloat64()
301 case NilValue:
302 iter.skipFourBytes('n', 'u', 'l', 'l')
303 return nil
304 case BoolValue:
305 return iter.ReadBool()
306 case ArrayValue:
307 arr := []interface{}{}
308 iter.ReadArrayCB(func(iter *Iterator) bool {
309 var elem interface{}
310 iter.ReadVal(&elem)
311 arr = append(arr, elem)
312 return true
313 })
314 return arr
315 case ObjectValue:
316 obj := map[string]interface{}{}
317 iter.ReadMapCB(func(Iter *Iterator, field string) bool {
318 var elem interface{}
319 iter.ReadVal(&elem)
320 obj[field] = elem
321 return true
322 })
323 return obj
324 default:
325 iter.ReportError("Read", fmt.Sprintf("unexpected value type: %v", valueType))
326 return nil
327 }
328}
329
330// limit maximum depth of nesting, as allowed by https://tools.ietf.org/html/rfc7159#section-9
331const maxDepth = 10000
332
333func (iter *Iterator) incrementDepth() (success bool) {
334 iter.depth++
335 if iter.depth <= maxDepth {
336 return true
337 }
338 iter.ReportError("incrementDepth", "exceeded max depth")
339 return false
340}
341
342func (iter *Iterator) decrementDepth() (success bool) {
343 iter.depth--
344 if iter.depth >= 0 {
345 return true
346 }
347 iter.ReportError("decrementDepth", "unexpected negative nesting")
348 return false
349}
diff --git a/vendor/github.com/json-iterator/go/iter_array.go b/vendor/github.com/json-iterator/go/iter_array.go
deleted file mode 100644
index 204fe0e..0000000
--- a/vendor/github.com/json-iterator/go/iter_array.go
+++ /dev/null
@@ -1,64 +0,0 @@
1package jsoniter
2
3// ReadArray read array element, tells if the array has more element to read.
4func (iter *Iterator) ReadArray() (ret bool) {
5 c := iter.nextToken()
6 switch c {
7 case 'n':
8 iter.skipThreeBytes('u', 'l', 'l')
9 return false // null
10 case '[':
11 c = iter.nextToken()
12 if c != ']' {
13 iter.unreadByte()
14 return true
15 }
16 return false
17 case ']':
18 return false
19 case ',':
20 return true
21 default:
22 iter.ReportError("ReadArray", "expect [ or , or ] or n, but found "+string([]byte{c}))
23 return
24 }
25}
26
27// ReadArrayCB read array with callback
28func (iter *Iterator) ReadArrayCB(callback func(*Iterator) bool) (ret bool) {
29 c := iter.nextToken()
30 if c == '[' {
31 if !iter.incrementDepth() {
32 return false
33 }
34 c = iter.nextToken()
35 if c != ']' {
36 iter.unreadByte()
37 if !callback(iter) {
38 iter.decrementDepth()
39 return false
40 }
41 c = iter.nextToken()
42 for c == ',' {
43 if !callback(iter) {
44 iter.decrementDepth()
45 return false
46 }
47 c = iter.nextToken()
48 }
49 if c != ']' {
50 iter.ReportError("ReadArrayCB", "expect ] in the end, but found "+string([]byte{c}))
51 iter.decrementDepth()
52 return false
53 }
54 return iter.decrementDepth()
55 }
56 return iter.decrementDepth()
57 }
58 if c == 'n' {
59 iter.skipThreeBytes('u', 'l', 'l')
60 return true // null
61 }
62 iter.ReportError("ReadArrayCB", "expect [ or n, but found "+string([]byte{c}))
63 return false
64}
diff --git a/vendor/github.com/json-iterator/go/iter_float.go b/vendor/github.com/json-iterator/go/iter_float.go
deleted file mode 100644
index 8a3d8b6..0000000
--- a/vendor/github.com/json-iterator/go/iter_float.go
+++ /dev/null
@@ -1,342 +0,0 @@
1package jsoniter
2
3import (
4 "encoding/json"
5 "io"
6 "math/big"
7 "strconv"
8 "strings"
9 "unsafe"
10)
11
12var floatDigits []int8
13
14const invalidCharForNumber = int8(-1)
15const endOfNumber = int8(-2)
16const dotInNumber = int8(-3)
17
18func init() {
19 floatDigits = make([]int8, 256)
20 for i := 0; i < len(floatDigits); i++ {
21 floatDigits[i] = invalidCharForNumber
22 }
23 for i := int8('0'); i <= int8('9'); i++ {
24 floatDigits[i] = i - int8('0')
25 }
26 floatDigits[','] = endOfNumber
27 floatDigits[']'] = endOfNumber
28 floatDigits['}'] = endOfNumber
29 floatDigits[' '] = endOfNumber
30 floatDigits['\t'] = endOfNumber
31 floatDigits['\n'] = endOfNumber
32 floatDigits['.'] = dotInNumber
33}
34
35// ReadBigFloat read big.Float
36func (iter *Iterator) ReadBigFloat() (ret *big.Float) {
37 str := iter.readNumberAsString()
38 if iter.Error != nil && iter.Error != io.EOF {
39 return nil
40 }
41 prec := 64
42 if len(str) > prec {
43 prec = len(str)
44 }
45 val, _, err := big.ParseFloat(str, 10, uint(prec), big.ToZero)
46 if err != nil {
47 iter.Error = err
48 return nil
49 }
50 return val
51}
52
53// ReadBigInt read big.Int
54func (iter *Iterator) ReadBigInt() (ret *big.Int) {
55 str := iter.readNumberAsString()
56 if iter.Error != nil && iter.Error != io.EOF {
57 return nil
58 }
59 ret = big.NewInt(0)
60 var success bool
61 ret, success = ret.SetString(str, 10)
62 if !success {
63 iter.ReportError("ReadBigInt", "invalid big int")
64 return nil
65 }
66 return ret
67}
68
69//ReadFloat32 read float32
70func (iter *Iterator) ReadFloat32() (ret float32) {
71 c := iter.nextToken()
72 if c == '-' {
73 return -iter.readPositiveFloat32()
74 }
75 iter.unreadByte()
76 return iter.readPositiveFloat32()
77}
78
79func (iter *Iterator) readPositiveFloat32() (ret float32) {
80 i := iter.head
81 // first char
82 if i == iter.tail {
83 return iter.readFloat32SlowPath()
84 }
85 c := iter.buf[i]
86 i++
87 ind := floatDigits[c]
88 switch ind {
89 case invalidCharForNumber:
90 return iter.readFloat32SlowPath()
91 case endOfNumber:
92 iter.ReportError("readFloat32", "empty number")
93 return
94 case dotInNumber:
95 iter.ReportError("readFloat32", "leading dot is invalid")
96 return
97 case 0:
98 if i == iter.tail {
99 return iter.readFloat32SlowPath()
100 }
101 c = iter.buf[i]
102 switch c {
103 case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
104 iter.ReportError("readFloat32", "leading zero is invalid")
105 return
106 }
107 }
108 value := uint64(ind)
109 // chars before dot
110non_decimal_loop:
111 for ; i < iter.tail; i++ {
112 c = iter.buf[i]
113 ind := floatDigits[c]
114 switch ind {
115 case invalidCharForNumber:
116 return iter.readFloat32SlowPath()
117 case endOfNumber:
118 iter.head = i
119 return float32(value)
120 case dotInNumber:
121 break non_decimal_loop
122 }
123 if value > uint64SafeToMultiple10 {
124 return iter.readFloat32SlowPath()
125 }
126 value = (value << 3) + (value << 1) + uint64(ind) // value = value * 10 + ind;
127 }
128 // chars after dot
129 if c == '.' {
130 i++
131 decimalPlaces := 0
132 if i == iter.tail {
133 return iter.readFloat32SlowPath()
134 }
135 for ; i < iter.tail; i++ {
136 c = iter.buf[i]
137 ind := floatDigits[c]
138 switch ind {
139 case endOfNumber:
140 if decimalPlaces > 0 && decimalPlaces < len(pow10) {
141 iter.head = i
142 return float32(float64(value) / float64(pow10[decimalPlaces]))
143 }
144 // too many decimal places
145 return iter.readFloat32SlowPath()
146 case invalidCharForNumber, dotInNumber:
147 return iter.readFloat32SlowPath()
148 }
149 decimalPlaces++
150 if value > uint64SafeToMultiple10 {
151 return iter.readFloat32SlowPath()
152 }
153 value = (value << 3) + (value << 1) + uint64(ind)
154 }
155 }
156 return iter.readFloat32SlowPath()
157}
158
159func (iter *Iterator) readNumberAsString() (ret string) {
160 strBuf := [16]byte{}
161 str := strBuf[0:0]
162load_loop:
163 for {
164 for i := iter.head; i < iter.tail; i++ {
165 c := iter.buf[i]
166 switch c {
167 case '+', '-', '.', 'e', 'E', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
168 str = append(str, c)
169 continue
170 default:
171 iter.head = i
172 break load_loop
173 }
174 }
175 if !iter.loadMore() {
176 break
177 }
178 }
179 if iter.Error != nil && iter.Error != io.EOF {
180 return
181 }
182 if len(str) == 0 {
183 iter.ReportError("readNumberAsString", "invalid number")
184 }
185 return *(*string)(unsafe.Pointer(&str))
186}
187
188func (iter *Iterator) readFloat32SlowPath() (ret float32) {
189 str := iter.readNumberAsString()
190 if iter.Error != nil && iter.Error != io.EOF {
191 return
192 }
193 errMsg := validateFloat(str)
194 if errMsg != "" {
195 iter.ReportError("readFloat32SlowPath", errMsg)
196 return
197 }
198 val, err := strconv.ParseFloat(str, 32)
199 if err != nil {
200 iter.Error = err
201 return
202 }
203 return float32(val)
204}
205
206// ReadFloat64 read float64
207func (iter *Iterator) ReadFloat64() (ret float64) {
208 c := iter.nextToken()
209 if c == '-' {
210 return -iter.readPositiveFloat64()
211 }
212 iter.unreadByte()
213 return iter.readPositiveFloat64()
214}
215
216func (iter *Iterator) readPositiveFloat64() (ret float64) {
217 i := iter.head
218 // first char
219 if i == iter.tail {
220 return iter.readFloat64SlowPath()
221 }
222 c := iter.buf[i]
223 i++
224 ind := floatDigits[c]
225 switch ind {
226 case invalidCharForNumber:
227 return iter.readFloat64SlowPath()
228 case endOfNumber:
229 iter.ReportError("readFloat64", "empty number")
230 return
231 case dotInNumber:
232 iter.ReportError("readFloat64", "leading dot is invalid")
233 return
234 case 0:
235 if i == iter.tail {
236 return iter.readFloat64SlowPath()
237 }
238 c = iter.buf[i]
239 switch c {
240 case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
241 iter.ReportError("readFloat64", "leading zero is invalid")
242 return
243 }
244 }
245 value := uint64(ind)
246 // chars before dot
247non_decimal_loop:
248 for ; i < iter.tail; i++ {
249 c = iter.buf[i]
250 ind := floatDigits[c]
251 switch ind {
252 case invalidCharForNumber:
253 return iter.readFloat64SlowPath()
254 case endOfNumber:
255 iter.head = i
256 return float64(value)
257 case dotInNumber:
258 break non_decimal_loop
259 }
260 if value > uint64SafeToMultiple10 {
261 return iter.readFloat64SlowPath()
262 }
263 value = (value << 3) + (value << 1) + uint64(ind) // value = value * 10 + ind;
264 }
265 // chars after dot
266 if c == '.' {
267 i++
268 decimalPlaces := 0
269 if i == iter.tail {
270 return iter.readFloat64SlowPath()
271 }
272 for ; i < iter.tail; i++ {
273 c = iter.buf[i]
274 ind := floatDigits[c]
275 switch ind {
276 case endOfNumber:
277 if decimalPlaces > 0 && decimalPlaces < len(pow10) {
278 iter.head = i
279 return float64(value) / float64(pow10[decimalPlaces])
280 }
281 // too many decimal places
282 return iter.readFloat64SlowPath()
283 case invalidCharForNumber, dotInNumber:
284 return iter.readFloat64SlowPath()
285 }
286 decimalPlaces++
287 if value > uint64SafeToMultiple10 {
288 return iter.readFloat64SlowPath()
289 }
290 value = (value << 3) + (value << 1) + uint64(ind)
291 if value > maxFloat64 {
292 return iter.readFloat64SlowPath()
293 }
294 }
295 }
296 return iter.readFloat64SlowPath()
297}
298
299func (iter *Iterator) readFloat64SlowPath() (ret float64) {
300 str := iter.readNumberAsString()
301 if iter.Error != nil && iter.Error != io.EOF {
302 return
303 }
304 errMsg := validateFloat(str)
305 if errMsg != "" {
306 iter.ReportError("readFloat64SlowPath", errMsg)
307 return
308 }
309 val, err := strconv.ParseFloat(str, 64)
310 if err != nil {
311 iter.Error = err
312 return
313 }
314 return val
315}
316
317func validateFloat(str string) string {
318 // strconv.ParseFloat is not validating `1.` or `1.e1`
319 if len(str) == 0 {
320 return "empty number"
321 }
322 if str[0] == '-' {
323 return "-- is not valid"
324 }
325 dotPos := strings.IndexByte(str, '.')
326 if dotPos != -1 {
327 if dotPos == len(str)-1 {
328 return "dot can not be last character"
329 }
330 switch str[dotPos+1] {
331 case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
332 default:
333 return "missing digit after dot"
334 }
335 }
336 return ""
337}
338
339// ReadNumber read json.Number
340func (iter *Iterator) ReadNumber() (ret json.Number) {
341 return json.Number(iter.readNumberAsString())
342}
diff --git a/vendor/github.com/json-iterator/go/iter_int.go b/vendor/github.com/json-iterator/go/iter_int.go
deleted file mode 100644
index d786a89..0000000
--- a/vendor/github.com/json-iterator/go/iter_int.go
+++ /dev/null
@@ -1,346 +0,0 @@
1package jsoniter
2
3import (
4 "math"
5 "strconv"
6)
7
8var intDigits []int8
9
10const uint32SafeToMultiply10 = uint32(0xffffffff)/10 - 1
11const uint64SafeToMultiple10 = uint64(0xffffffffffffffff)/10 - 1
12const maxFloat64 = 1<<53 - 1
13
14func init() {
15 intDigits = make([]int8, 256)
16 for i := 0; i < len(intDigits); i++ {
17 intDigits[i] = invalidCharForNumber
18 }
19 for i := int8('0'); i <= int8('9'); i++ {
20 intDigits[i] = i - int8('0')
21 }
22}
23
24// ReadUint read uint
25func (iter *Iterator) ReadUint() uint {
26 if strconv.IntSize == 32 {
27 return uint(iter.ReadUint32())
28 }
29 return uint(iter.ReadUint64())
30}
31
32// ReadInt read int
33func (iter *Iterator) ReadInt() int {
34 if strconv.IntSize == 32 {
35 return int(iter.ReadInt32())
36 }
37 return int(iter.ReadInt64())
38}
39
40// ReadInt8 read int8
41func (iter *Iterator) ReadInt8() (ret int8) {
42 c := iter.nextToken()
43 if c == '-' {
44 val := iter.readUint32(iter.readByte())
45 if val > math.MaxInt8+1 {
46 iter.ReportError("ReadInt8", "overflow: "+strconv.FormatInt(int64(val), 10))
47 return
48 }
49 return -int8(val)
50 }
51 val := iter.readUint32(c)
52 if val > math.MaxInt8 {
53 iter.ReportError("ReadInt8", "overflow: "+strconv.FormatInt(int64(val), 10))
54 return
55 }
56 return int8(val)
57}
58
59// ReadUint8 read uint8
60func (iter *Iterator) ReadUint8() (ret uint8) {
61 val := iter.readUint32(iter.nextToken())
62 if val > math.MaxUint8 {
63 iter.ReportError("ReadUint8", "overflow: "+strconv.FormatInt(int64(val), 10))
64 return
65 }
66 return uint8(val)
67}
68
69// ReadInt16 read int16
70func (iter *Iterator) ReadInt16() (ret int16) {
71 c := iter.nextToken()
72 if c == '-' {
73 val := iter.readUint32(iter.readByte())
74 if val > math.MaxInt16+1 {
75 iter.ReportError("ReadInt16", "overflow: "+strconv.FormatInt(int64(val), 10))
76 return
77 }
78 return -int16(val)
79 }
80 val := iter.readUint32(c)
81 if val > math.MaxInt16 {
82 iter.ReportError("ReadInt16", "overflow: "+strconv.FormatInt(int64(val), 10))
83 return
84 }
85 return int16(val)
86}
87
88// ReadUint16 read uint16
89func (iter *Iterator) ReadUint16() (ret uint16) {
90 val := iter.readUint32(iter.nextToken())
91 if val > math.MaxUint16 {
92 iter.ReportError("ReadUint16", "overflow: "+strconv.FormatInt(int64(val), 10))
93 return
94 }
95 return uint16(val)
96}
97
98// ReadInt32 read int32
99func (iter *Iterator) ReadInt32() (ret int32) {
100 c := iter.nextToken()
101 if c == '-' {
102 val := iter.readUint32(iter.readByte())
103 if val > math.MaxInt32+1 {
104 iter.ReportError("ReadInt32", "overflow: "+strconv.FormatInt(int64(val), 10))
105 return
106 }
107 return -int32(val)
108 }
109 val := iter.readUint32(c)
110 if val > math.MaxInt32 {
111 iter.ReportError("ReadInt32", "overflow: "+strconv.FormatInt(int64(val), 10))
112 return
113 }
114 return int32(val)
115}
116
117// ReadUint32 read uint32
118func (iter *Iterator) ReadUint32() (ret uint32) {
119 return iter.readUint32(iter.nextToken())
120}
121
122func (iter *Iterator) readUint32(c byte) (ret uint32) {
123 ind := intDigits[c]
124 if ind == 0 {
125 iter.assertInteger()
126 return 0 // single zero
127 }
128 if ind == invalidCharForNumber {
129 iter.ReportError("readUint32", "unexpected character: "+string([]byte{byte(ind)}))
130 return
131 }
132 value := uint32(ind)
133 if iter.tail-iter.head > 10 {
134 i := iter.head
135 ind2 := intDigits[iter.buf[i]]
136 if ind2 == invalidCharForNumber {
137 iter.head = i
138 iter.assertInteger()
139 return value
140 }
141 i++
142 ind3 := intDigits[iter.buf[i]]
143 if ind3 == invalidCharForNumber {
144 iter.head = i
145 iter.assertInteger()
146 return value*10 + uint32(ind2)
147 }
148 //iter.head = i + 1
149 //value = value * 100 + uint32(ind2) * 10 + uint32(ind3)
150 i++
151 ind4 := intDigits[iter.buf[i]]
152 if ind4 == invalidCharForNumber {
153 iter.head = i
154 iter.assertInteger()
155 return value*100 + uint32(ind2)*10 + uint32(ind3)
156 }
157 i++
158 ind5 := intDigits[iter.buf[i]]
159 if ind5 == invalidCharForNumber {
160 iter.head = i
161 iter.assertInteger()
162 return value*1000 + uint32(ind2)*100 + uint32(ind3)*10 + uint32(ind4)
163 }
164 i++
165 ind6 := intDigits[iter.buf[i]]
166 if ind6 == invalidCharForNumber {
167 iter.head = i
168 iter.assertInteger()
169 return value*10000 + uint32(ind2)*1000 + uint32(ind3)*100 + uint32(ind4)*10 + uint32(ind5)
170 }
171 i++
172 ind7 := intDigits[iter.buf[i]]
173 if ind7 == invalidCharForNumber {
174 iter.head = i
175 iter.assertInteger()
176 return value*100000 + uint32(ind2)*10000 + uint32(ind3)*1000 + uint32(ind4)*100 + uint32(ind5)*10 + uint32(ind6)
177 }
178 i++
179 ind8 := intDigits[iter.buf[i]]
180 if ind8 == invalidCharForNumber {
181 iter.head = i
182 iter.assertInteger()
183 return value*1000000 + uint32(ind2)*100000 + uint32(ind3)*10000 + uint32(ind4)*1000 + uint32(ind5)*100 + uint32(ind6)*10 + uint32(ind7)
184 }
185 i++
186 ind9 := intDigits[iter.buf[i]]
187 value = value*10000000 + uint32(ind2)*1000000 + uint32(ind3)*100000 + uint32(ind4)*10000 + uint32(ind5)*1000 + uint32(ind6)*100 + uint32(ind7)*10 + uint32(ind8)
188 iter.head = i
189 if ind9 == invalidCharForNumber {
190 iter.assertInteger()
191 return value
192 }
193 }
194 for {
195 for i := iter.head; i < iter.tail; i++ {
196 ind = intDigits[iter.buf[i]]
197 if ind == invalidCharForNumber {
198 iter.head = i
199 iter.assertInteger()
200 return value
201 }
202 if value > uint32SafeToMultiply10 {
203 value2 := (value << 3) + (value << 1) + uint32(ind)
204 if value2 < value {
205 iter.ReportError("readUint32", "overflow")
206 return
207 }
208 value = value2
209 continue
210 }
211 value = (value << 3) + (value << 1) + uint32(ind)
212 }
213 if !iter.loadMore() {
214 iter.assertInteger()
215 return value
216 }
217 }
218}
219
220// ReadInt64 read int64
221func (iter *Iterator) ReadInt64() (ret int64) {
222 c := iter.nextToken()
223 if c == '-' {
224 val := iter.readUint64(iter.readByte())
225 if val > math.MaxInt64+1 {
226 iter.ReportError("ReadInt64", "overflow: "+strconv.FormatUint(uint64(val), 10))
227 return
228 }
229 return -int64(val)
230 }
231 val := iter.readUint64(c)
232 if val > math.MaxInt64 {
233 iter.ReportError("ReadInt64", "overflow: "+strconv.FormatUint(uint64(val), 10))
234 return
235 }
236 return int64(val)
237}
238
239// ReadUint64 read uint64
240func (iter *Iterator) ReadUint64() uint64 {
241 return iter.readUint64(iter.nextToken())
242}
243
244func (iter *Iterator) readUint64(c byte) (ret uint64) {
245 ind := intDigits[c]
246 if ind == 0 {
247 iter.assertInteger()
248 return 0 // single zero
249 }
250 if ind == invalidCharForNumber {
251 iter.ReportError("readUint64", "unexpected character: "+string([]byte{byte(ind)}))
252 return
253 }
254 value := uint64(ind)
255 if iter.tail-iter.head > 10 {
256 i := iter.head
257 ind2 := intDigits[iter.buf[i]]
258 if ind2 == invalidCharForNumber {
259 iter.head = i
260 iter.assertInteger()
261 return value
262 }
263 i++
264 ind3 := intDigits[iter.buf[i]]
265 if ind3 == invalidCharForNumber {
266 iter.head = i
267 iter.assertInteger()
268 return value*10 + uint64(ind2)
269 }
270 //iter.head = i + 1
271 //value = value * 100 + uint32(ind2) * 10 + uint32(ind3)
272 i++
273 ind4 := intDigits[iter.buf[i]]
274 if ind4 == invalidCharForNumber {
275 iter.head = i
276 iter.assertInteger()
277 return value*100 + uint64(ind2)*10 + uint64(ind3)
278 }
279 i++
280 ind5 := intDigits[iter.buf[i]]
281 if ind5 == invalidCharForNumber {
282 iter.head = i
283 iter.assertInteger()
284 return value*1000 + uint64(ind2)*100 + uint64(ind3)*10 + uint64(ind4)
285 }
286 i++
287 ind6 := intDigits[iter.buf[i]]
288 if ind6 == invalidCharForNumber {
289 iter.head = i
290 iter.assertInteger()
291 return value*10000 + uint64(ind2)*1000 + uint64(ind3)*100 + uint64(ind4)*10 + uint64(ind5)
292 }
293 i++
294 ind7 := intDigits[iter.buf[i]]
295 if ind7 == invalidCharForNumber {
296 iter.head = i
297 iter.assertInteger()
298 return value*100000 + uint64(ind2)*10000 + uint64(ind3)*1000 + uint64(ind4)*100 + uint64(ind5)*10 + uint64(ind6)
299 }
300 i++
301 ind8 := intDigits[iter.buf[i]]
302 if ind8 == invalidCharForNumber {
303 iter.head = i
304 iter.assertInteger()
305 return value*1000000 + uint64(ind2)*100000 + uint64(ind3)*10000 + uint64(ind4)*1000 + uint64(ind5)*100 + uint64(ind6)*10 + uint64(ind7)
306 }
307 i++
308 ind9 := intDigits[iter.buf[i]]
309 value = value*10000000 + uint64(ind2)*1000000 + uint64(ind3)*100000 + uint64(ind4)*10000 + uint64(ind5)*1000 + uint64(ind6)*100 + uint64(ind7)*10 + uint64(ind8)
310 iter.head = i
311 if ind9 == invalidCharForNumber {
312 iter.assertInteger()
313 return value
314 }
315 }
316 for {
317 for i := iter.head; i < iter.tail; i++ {
318 ind = intDigits[iter.buf[i]]
319 if ind == invalidCharForNumber {
320 iter.head = i
321 iter.assertInteger()
322 return value
323 }
324 if value > uint64SafeToMultiple10 {
325 value2 := (value << 3) + (value << 1) + uint64(ind)
326 if value2 < value {
327 iter.ReportError("readUint64", "overflow")
328 return
329 }
330 value = value2
331 continue
332 }
333 value = (value << 3) + (value << 1) + uint64(ind)
334 }
335 if !iter.loadMore() {
336 iter.assertInteger()
337 return value
338 }
339 }
340}
341
342func (iter *Iterator) assertInteger() {
343 if iter.head < iter.tail && iter.buf[iter.head] == '.' {
344 iter.ReportError("assertInteger", "can not decode float as int")
345 }
346}
diff --git a/vendor/github.com/json-iterator/go/iter_object.go b/vendor/github.com/json-iterator/go/iter_object.go
deleted file mode 100644
index 58ee89c..0000000
--- a/vendor/github.com/json-iterator/go/iter_object.go
+++ /dev/null
@@ -1,267 +0,0 @@
1package jsoniter
2
3import (
4 "fmt"
5 "strings"
6)
7
8// ReadObject read one field from object.
9// If object ended, returns empty string.
10// Otherwise, returns the field name.
11func (iter *Iterator) ReadObject() (ret string) {
12 c := iter.nextToken()
13 switch c {
14 case 'n':
15 iter.skipThreeBytes('u', 'l', 'l')
16 return "" // null
17 case '{':
18 c = iter.nextToken()
19 if c == '"' {
20 iter.unreadByte()
21 field := iter.ReadString()
22 c = iter.nextToken()
23 if c != ':' {
24 iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
25 }
26 return field
27 }
28 if c == '}' {
29 return "" // end of object
30 }
31 iter.ReportError("ReadObject", `expect " after {, but found `+string([]byte{c}))
32 return
33 case ',':
34 field := iter.ReadString()
35 c = iter.nextToken()
36 if c != ':' {
37 iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
38 }
39 return field
40 case '}':
41 return "" // end of object
42 default:
43 iter.ReportError("ReadObject", fmt.Sprintf(`expect { or , or } or n, but found %s`, string([]byte{c})))
44 return
45 }
46}
47
48// CaseInsensitive
49func (iter *Iterator) readFieldHash() int64 {
50 hash := int64(0x811c9dc5)
51 c := iter.nextToken()
52 if c != '"' {
53 iter.ReportError("readFieldHash", `expect ", but found `+string([]byte{c}))
54 return 0
55 }
56 for {
57 for i := iter.head; i < iter.tail; i++ {
58 // require ascii string and no escape
59 b := iter.buf[i]
60 if b == '\\' {
61 iter.head = i
62 for _, b := range iter.readStringSlowPath() {
63 if 'A' <= b && b <= 'Z' && !iter.cfg.caseSensitive {
64 b += 'a' - 'A'
65 }
66 hash ^= int64(b)
67 hash *= 0x1000193
68 }
69 c = iter.nextToken()
70 if c != ':' {
71 iter.ReportError("readFieldHash", `expect :, but found `+string([]byte{c}))
72 return 0
73 }
74 return hash
75 }
76 if b == '"' {
77 iter.head = i + 1
78 c = iter.nextToken()
79 if c != ':' {
80 iter.ReportError("readFieldHash", `expect :, but found `+string([]byte{c}))
81 return 0
82 }
83 return hash
84 }
85 if 'A' <= b && b <= 'Z' && !iter.cfg.caseSensitive {
86 b += 'a' - 'A'
87 }
88 hash ^= int64(b)
89 hash *= 0x1000193
90 }
91 if !iter.loadMore() {
92 iter.ReportError("readFieldHash", `incomplete field name`)
93 return 0
94 }
95 }
96}
97
98func calcHash(str string, caseSensitive bool) int64 {
99 if !caseSensitive {
100 str = strings.ToLower(str)
101 }
102 hash := int64(0x811c9dc5)
103 for _, b := range []byte(str) {
104 hash ^= int64(b)
105 hash *= 0x1000193
106 }
107 return int64(hash)
108}
109
110// ReadObjectCB read object with callback, the key is ascii only and field name not copied
111func (iter *Iterator) ReadObjectCB(callback func(*Iterator, string) bool) bool {
112 c := iter.nextToken()
113 var field string
114 if c == '{' {
115 if !iter.incrementDepth() {
116 return false
117 }
118 c = iter.nextToken()
119 if c == '"' {
120 iter.unreadByte()
121 field = iter.ReadString()
122 c = iter.nextToken()
123 if c != ':' {
124 iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
125 }
126 if !callback(iter, field) {
127 iter.decrementDepth()
128 return false
129 }
130 c = iter.nextToken()
131 for c == ',' {
132 field = iter.ReadString()
133 c = iter.nextToken()
134 if c != ':' {
135 iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
136 }
137 if !callback(iter, field) {
138 iter.decrementDepth()
139 return false
140 }
141 c = iter.nextToken()
142 }
143 if c != '}' {
144 iter.ReportError("ReadObjectCB", `object not ended with }`)
145 iter.decrementDepth()
146 return false
147 }
148 return iter.decrementDepth()
149 }
150 if c == '}' {
151 return iter.decrementDepth()
152 }
153 iter.ReportError("ReadObjectCB", `expect " after {, but found `+string([]byte{c}))
154 iter.decrementDepth()
155 return false
156 }
157 if c == 'n' {
158 iter.skipThreeBytes('u', 'l', 'l')
159 return true // null
160 }
161 iter.ReportError("ReadObjectCB", `expect { or n, but found `+string([]byte{c}))
162 return false
163}
164
165// ReadMapCB read map with callback, the key can be any string
166func (iter *Iterator) ReadMapCB(callback func(*Iterator, string) bool) bool {
167 c := iter.nextToken()
168 if c == '{' {
169 if !iter.incrementDepth() {
170 return false
171 }
172 c = iter.nextToken()
173 if c == '"' {
174 iter.unreadByte()
175 field := iter.ReadString()
176 if iter.nextToken() != ':' {
177 iter.ReportError("ReadMapCB", "expect : after object field, but found "+string([]byte{c}))
178 iter.decrementDepth()
179 return false
180 }
181 if !callback(iter, field) {
182 iter.decrementDepth()
183 return false
184 }
185 c = iter.nextToken()
186 for c == ',' {
187 field = iter.ReadString()
188 if iter.nextToken() != ':' {
189 iter.ReportError("ReadMapCB", "expect : after object field, but found "+string([]byte{c}))
190 iter.decrementDepth()
191 return false
192 }
193 if !callback(iter, field) {
194 iter.decrementDepth()
195 return false
196 }
197 c = iter.nextToken()
198 }
199 if c != '}' {
200 iter.ReportError("ReadMapCB", `object not ended with }`)
201 iter.decrementDepth()
202 return false
203 }
204 return iter.decrementDepth()
205 }
206 if c == '}' {
207 return iter.decrementDepth()
208 }
209 iter.ReportError("ReadMapCB", `expect " after {, but found `+string([]byte{c}))
210 iter.decrementDepth()
211 return false
212 }
213 if c == 'n' {
214 iter.skipThreeBytes('u', 'l', 'l')
215 return true // null
216 }
217 iter.ReportError("ReadMapCB", `expect { or n, but found `+string([]byte{c}))
218 return false
219}
220
221func (iter *Iterator) readObjectStart() bool {
222 c := iter.nextToken()
223 if c == '{' {
224 c = iter.nextToken()
225 if c == '}' {
226 return false
227 }
228 iter.unreadByte()
229 return true
230 } else if c == 'n' {
231 iter.skipThreeBytes('u', 'l', 'l')
232 return false
233 }
234 iter.ReportError("readObjectStart", "expect { or n, but found "+string([]byte{c}))
235 return false
236}
237
238func (iter *Iterator) readObjectFieldAsBytes() (ret []byte) {
239 str := iter.ReadStringAsSlice()
240 if iter.skipWhitespacesWithoutLoadMore() {
241 if ret == nil {
242 ret = make([]byte, len(str))
243 copy(ret, str)
244 }
245 if !iter.loadMore() {
246 return
247 }
248 }
249 if iter.buf[iter.head] != ':' {
250 iter.ReportError("readObjectFieldAsBytes", "expect : after object field, but found "+string([]byte{iter.buf[iter.head]}))
251 return
252 }
253 iter.head++
254 if iter.skipWhitespacesWithoutLoadMore() {
255 if ret == nil {
256 ret = make([]byte, len(str))
257 copy(ret, str)
258 }
259 if !iter.loadMore() {
260 return
261 }
262 }
263 if ret == nil {
264 return str
265 }
266 return ret
267}
diff --git a/vendor/github.com/json-iterator/go/iter_skip.go b/vendor/github.com/json-iterator/go/iter_skip.go
deleted file mode 100644
index e91eefb..0000000
--- a/vendor/github.com/json-iterator/go/iter_skip.go
+++ /dev/null
@@ -1,130 +0,0 @@
1package jsoniter
2
3import "fmt"
4
5// ReadNil reads a json object as nil and
6// returns whether it's a nil or not
7func (iter *Iterator) ReadNil() (ret bool) {
8 c := iter.nextToken()
9 if c == 'n' {
10 iter.skipThreeBytes('u', 'l', 'l') // null
11 return true
12 }
13 iter.unreadByte()
14 return false
15}
16
17// ReadBool reads a json object as BoolValue
18func (iter *Iterator) ReadBool() (ret bool) {
19 c := iter.nextToken()
20 if c == 't' {
21 iter.skipThreeBytes('r', 'u', 'e')
22 return true
23 }
24 if c == 'f' {
25 iter.skipFourBytes('a', 'l', 's', 'e')
26 return false
27 }
28 iter.ReportError("ReadBool", "expect t or f, but found "+string([]byte{c}))
29 return
30}
31
32// SkipAndReturnBytes skip next JSON element, and return its content as []byte.
33// The []byte can be kept, it is a copy of data.
34func (iter *Iterator) SkipAndReturnBytes() []byte {
35 iter.startCapture(iter.head)
36 iter.Skip()
37 return iter.stopCapture()
38}
39
40// SkipAndAppendBytes skips next JSON element and appends its content to
41// buffer, returning the result.
42func (iter *Iterator) SkipAndAppendBytes(buf []byte) []byte {
43 iter.startCaptureTo(buf, iter.head)
44 iter.Skip()
45 return iter.stopCapture()
46}
47
48func (iter *Iterator) startCaptureTo(buf []byte, captureStartedAt int) {
49 if iter.captured != nil {
50 panic("already in capture mode")
51 }
52 iter.captureStartedAt = captureStartedAt
53 iter.captured = buf
54}
55
56func (iter *Iterator) startCapture(captureStartedAt int) {
57 iter.startCaptureTo(make([]byte, 0, 32), captureStartedAt)
58}
59
60func (iter *Iterator) stopCapture() []byte {
61 if iter.captured == nil {
62 panic("not in capture mode")
63 }
64 captured := iter.captured
65 remaining := iter.buf[iter.captureStartedAt:iter.head]
66 iter.captureStartedAt = -1
67 iter.captured = nil
68 return append(captured, remaining...)
69}
70
71// Skip skips a json object and positions to relatively the next json object
72func (iter *Iterator) Skip() {
73 c := iter.nextToken()
74 switch c {
75 case '"':
76 iter.skipString()
77 case 'n':
78 iter.skipThreeBytes('u', 'l', 'l') // null
79 case 't':
80 iter.skipThreeBytes('r', 'u', 'e') // true
81 case 'f':
82 iter.skipFourBytes('a', 'l', 's', 'e') // false
83 case '0':
84 iter.unreadByte()
85 iter.ReadFloat32()
86 case '-', '1', '2', '3', '4', '5', '6', '7', '8', '9':
87 iter.skipNumber()
88 case '[':
89 iter.skipArray()
90 case '{':
91 iter.skipObject()
92 default:
93 iter.ReportError("Skip", fmt.Sprintf("do not know how to skip: %v", c))
94 return
95 }
96}
97
98func (iter *Iterator) skipFourBytes(b1, b2, b3, b4 byte) {
99 if iter.readByte() != b1 {
100 iter.ReportError("skipFourBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3, b4})))
101 return
102 }
103 if iter.readByte() != b2 {
104 iter.ReportError("skipFourBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3, b4})))
105 return
106 }
107 if iter.readByte() != b3 {
108 iter.ReportError("skipFourBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3, b4})))
109 return
110 }
111 if iter.readByte() != b4 {
112 iter.ReportError("skipFourBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3, b4})))
113 return
114 }
115}
116
117func (iter *Iterator) skipThreeBytes(b1, b2, b3 byte) {
118 if iter.readByte() != b1 {
119 iter.ReportError("skipThreeBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3})))
120 return
121 }
122 if iter.readByte() != b2 {
123 iter.ReportError("skipThreeBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3})))
124 return
125 }
126 if iter.readByte() != b3 {
127 iter.ReportError("skipThreeBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3})))
128 return
129 }
130}
diff --git a/vendor/github.com/json-iterator/go/iter_skip_sloppy.go b/vendor/github.com/json-iterator/go/iter_skip_sloppy.go
deleted file mode 100644
index 9303de4..0000000
--- a/vendor/github.com/json-iterator/go/iter_skip_sloppy.go
+++ /dev/null
@@ -1,163 +0,0 @@
1//+build jsoniter_sloppy
2
3package jsoniter
4
5// sloppy but faster implementation, do not validate the input json
6
7func (iter *Iterator) skipNumber() {
8 for {
9 for i := iter.head; i < iter.tail; i++ {
10 c := iter.buf[i]
11 switch c {
12 case ' ', '\n', '\r', '\t', ',', '}', ']':
13 iter.head = i
14 return
15 }
16 }
17 if !iter.loadMore() {
18 return
19 }
20 }
21}
22
23func (iter *Iterator) skipArray() {
24 level := 1
25 if !iter.incrementDepth() {
26 return
27 }
28 for {
29 for i := iter.head; i < iter.tail; i++ {
30 switch iter.buf[i] {
31 case '"': // If inside string, skip it
32 iter.head = i + 1
33 iter.skipString()
34 i = iter.head - 1 // it will be i++ soon
35 case '[': // If open symbol, increase level
36 level++
37 if !iter.incrementDepth() {
38 return
39 }
40 case ']': // If close symbol, increase level
41 level--
42 if !iter.decrementDepth() {
43 return
44 }
45
46 // If we have returned to the original level, we're done
47 if level == 0 {
48 iter.head = i + 1
49 return
50 }
51 }
52 }
53 if !iter.loadMore() {
54 iter.ReportError("skipObject", "incomplete array")
55 return
56 }
57 }
58}
59
60func (iter *Iterator) skipObject() {
61 level := 1
62 if !iter.incrementDepth() {
63 return
64 }
65
66 for {
67 for i := iter.head; i < iter.tail; i++ {
68 switch iter.buf[i] {
69 case '"': // If inside string, skip it
70 iter.head = i + 1
71 iter.skipString()
72 i = iter.head - 1 // it will be i++ soon
73 case '{': // If open symbol, increase level
74 level++
75 if !iter.incrementDepth() {
76 return
77 }
78 case '}': // If close symbol, increase level
79 level--
80 if !iter.decrementDepth() {
81 return
82 }
83
84 // If we have returned to the original level, we're done
85 if level == 0 {
86 iter.head = i + 1
87 return
88 }
89 }
90 }
91 if !iter.loadMore() {
92 iter.ReportError("skipObject", "incomplete object")
93 return
94 }
95 }
96}
97
98func (iter *Iterator) skipString() {
99 for {
100 end, escaped := iter.findStringEnd()
101 if end == -1 {
102 if !iter.loadMore() {
103 iter.ReportError("skipString", "incomplete string")
104 return
105 }
106 if escaped {
107 iter.head = 1 // skip the first char as last char read is \
108 }
109 } else {
110 iter.head = end
111 return
112 }
113 }
114}
115
116// adapted from: https://github.com/buger/jsonparser/blob/master/parser.go
117// Tries to find the end of string
118// Support if string contains escaped quote symbols.
119func (iter *Iterator) findStringEnd() (int, bool) {
120 escaped := false
121 for i := iter.head; i < iter.tail; i++ {
122 c := iter.buf[i]
123 if c == '"' {
124 if !escaped {
125 return i + 1, false
126 }
127 j := i - 1
128 for {
129 if j < iter.head || iter.buf[j] != '\\' {
130 // even number of backslashes
131 // either end of buffer, or " found
132 return i + 1, true
133 }
134 j--
135 if j < iter.head || iter.buf[j] != '\\' {
136 // odd number of backslashes
137 // it is \" or \\\"
138 break
139 }
140 j--
141 }
142 } else if c == '\\' {
143 escaped = true
144 }
145 }
146 j := iter.tail - 1
147 for {
148 if j < iter.head || iter.buf[j] != '\\' {
149 // even number of backslashes
150 // either end of buffer, or " found
151 return -1, false // do not end with \
152 }
153 j--
154 if j < iter.head || iter.buf[j] != '\\' {
155 // odd number of backslashes
156 // it is \" or \\\"
157 break
158 }
159 j--
160
161 }
162 return -1, true // end with \
163}
diff --git a/vendor/github.com/json-iterator/go/iter_skip_strict.go b/vendor/github.com/json-iterator/go/iter_skip_strict.go
deleted file mode 100644
index 6cf66d0..0000000
--- a/vendor/github.com/json-iterator/go/iter_skip_strict.go
+++ /dev/null
@@ -1,99 +0,0 @@
1//+build !jsoniter_sloppy
2
3package jsoniter
4
5import (
6 "fmt"
7 "io"
8)
9
10func (iter *Iterator) skipNumber() {
11 if !iter.trySkipNumber() {
12 iter.unreadByte()
13 if iter.Error != nil && iter.Error != io.EOF {
14 return
15 }
16 iter.ReadFloat64()
17 if iter.Error != nil && iter.Error != io.EOF {
18 iter.Error = nil
19 iter.ReadBigFloat()
20 }
21 }
22}
23
24func (iter *Iterator) trySkipNumber() bool {
25 dotFound := false
26 for i := iter.head; i < iter.tail; i++ {
27 c := iter.buf[i]
28 switch c {
29 case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
30 case '.':
31 if dotFound {
32 iter.ReportError("validateNumber", `more than one dot found in number`)
33 return true // already failed
34 }
35 if i+1 == iter.tail {
36 return false
37 }
38 c = iter.buf[i+1]
39 switch c {
40 case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
41 default:
42 iter.ReportError("validateNumber", `missing digit after dot`)
43 return true // already failed
44 }
45 dotFound = true
46 default:
47 switch c {
48 case ',', ']', '}', ' ', '\t', '\n', '\r':
49 if iter.head == i {
50 return false // if - without following digits
51 }
52 iter.head = i
53 return true // must be valid
54 }
55 return false // may be invalid
56 }
57 }
58 return false
59}
60
61func (iter *Iterator) skipString() {
62 if !iter.trySkipString() {
63 iter.unreadByte()
64 iter.ReadString()
65 }
66}
67
68func (iter *Iterator) trySkipString() bool {
69 for i := iter.head; i < iter.tail; i++ {
70 c := iter.buf[i]
71 if c == '"' {
72 iter.head = i + 1
73 return true // valid
74 } else if c == '\\' {
75 return false
76 } else if c < ' ' {
77 iter.ReportError("trySkipString",
78 fmt.Sprintf(`invalid control character found: %d`, c))
79 return true // already failed
80 }
81 }
82 return false
83}
84
85func (iter *Iterator) skipObject() {
86 iter.unreadByte()
87 iter.ReadObjectCB(func(iter *Iterator, field string) bool {
88 iter.Skip()
89 return true
90 })
91}
92
93func (iter *Iterator) skipArray() {
94 iter.unreadByte()
95 iter.ReadArrayCB(func(iter *Iterator) bool {
96 iter.Skip()
97 return true
98 })
99}
diff --git a/vendor/github.com/json-iterator/go/iter_str.go b/vendor/github.com/json-iterator/go/iter_str.go
deleted file mode 100644
index adc487e..0000000
--- a/vendor/github.com/json-iterator/go/iter_str.go
+++ /dev/null
@@ -1,215 +0,0 @@
1package jsoniter
2
3import (
4 "fmt"
5 "unicode/utf16"
6)
7
8// ReadString read string from iterator
9func (iter *Iterator) ReadString() (ret string) {
10 c := iter.nextToken()
11 if c == '"' {
12 for i := iter.head; i < iter.tail; i++ {
13 c := iter.buf[i]
14 if c == '"' {
15 ret = string(iter.buf[iter.head:i])
16 iter.head = i + 1
17 return ret
18 } else if c == '\\' {
19 break
20 } else if c < ' ' {
21 iter.ReportError("ReadString",
22 fmt.Sprintf(`invalid control character found: %d`, c))
23 return
24 }
25 }
26 return iter.readStringSlowPath()
27 } else if c == 'n' {
28 iter.skipThreeBytes('u', 'l', 'l')
29 return ""
30 }
31 iter.ReportError("ReadString", `expects " or n, but found `+string([]byte{c}))
32 return
33}
34
35func (iter *Iterator) readStringSlowPath() (ret string) {
36 var str []byte
37 var c byte
38 for iter.Error == nil {
39 c = iter.readByte()
40 if c == '"' {
41 return string(str)
42 }
43 if c == '\\' {
44 c = iter.readByte()
45 str = iter.readEscapedChar(c, str)
46 } else {
47 str = append(str, c)
48 }
49 }
50 iter.ReportError("readStringSlowPath", "unexpected end of input")
51 return
52}
53
54func (iter *Iterator) readEscapedChar(c byte, str []byte) []byte {
55 switch c {
56 case 'u':
57 r := iter.readU4()
58 if utf16.IsSurrogate(r) {
59 c = iter.readByte()
60 if iter.Error != nil {
61 return nil
62 }
63 if c != '\\' {
64 iter.unreadByte()
65 str = appendRune(str, r)
66 return str
67 }
68 c = iter.readByte()
69 if iter.Error != nil {
70 return nil
71 }
72 if c != 'u' {
73 str = appendRune(str, r)
74 return iter.readEscapedChar(c, str)
75 }
76 r2 := iter.readU4()
77 if iter.Error != nil {
78 return nil
79 }
80 combined := utf16.DecodeRune(r, r2)
81 if combined == '\uFFFD' {
82 str = appendRune(str, r)
83 str = appendRune(str, r2)
84 } else {
85 str = appendRune(str, combined)
86 }
87 } else {
88 str = appendRune(str, r)
89 }
90 case '"':
91 str = append(str, '"')
92 case '\\':
93 str = append(str, '\\')
94 case '/':
95 str = append(str, '/')
96 case 'b':
97 str = append(str, '\b')
98 case 'f':
99 str = append(str, '\f')
100 case 'n':
101 str = append(str, '\n')
102 case 'r':
103 str = append(str, '\r')
104 case 't':
105 str = append(str, '\t')
106 default:
107 iter.ReportError("readEscapedChar",
108 `invalid escape char after \`)
109 return nil
110 }
111 return str
112}
113
114// ReadStringAsSlice read string from iterator without copying into string form.
115// The []byte can not be kept, as it will change after next iterator call.
116func (iter *Iterator) ReadStringAsSlice() (ret []byte) {
117 c := iter.nextToken()
118 if c == '"' {
119 for i := iter.head; i < iter.tail; i++ {
120 // require ascii string and no escape
121 // for: field name, base64, number
122 if iter.buf[i] == '"' {
123 // fast path: reuse the underlying buffer
124 ret = iter.buf[iter.head:i]
125 iter.head = i + 1
126 return ret
127 }
128 }
129 readLen := iter.tail - iter.head
130 copied := make([]byte, readLen, readLen*2)
131 copy(copied, iter.buf[iter.head:iter.tail])
132 iter.head = iter.tail
133 for iter.Error == nil {
134 c := iter.readByte()
135 if c == '"' {
136 return copied
137 }
138 copied = append(copied, c)
139 }
140 return copied
141 }
142 iter.ReportError("ReadStringAsSlice", `expects " or n, but found `+string([]byte{c}))
143 return
144}
145
146func (iter *Iterator) readU4() (ret rune) {
147 for i := 0; i < 4; i++ {
148 c := iter.readByte()
149 if iter.Error != nil {
150 return
151 }
152 if c >= '0' && c <= '9' {
153 ret = ret*16 + rune(c-'0')
154 } else if c >= 'a' && c <= 'f' {
155 ret = ret*16 + rune(c-'a'+10)
156 } else if c >= 'A' && c <= 'F' {
157 ret = ret*16 + rune(c-'A'+10)
158 } else {
159 iter.ReportError("readU4", "expects 0~9 or a~f, but found "+string([]byte{c}))
160 return
161 }
162 }
163 return ret
164}
165
166const (
167 t1 = 0x00 // 0000 0000
168 tx = 0x80 // 1000 0000
169 t2 = 0xC0 // 1100 0000
170 t3 = 0xE0 // 1110 0000
171 t4 = 0xF0 // 1111 0000
172 t5 = 0xF8 // 1111 1000
173
174 maskx = 0x3F // 0011 1111
175 mask2 = 0x1F // 0001 1111
176 mask3 = 0x0F // 0000 1111
177 mask4 = 0x07 // 0000 0111
178
179 rune1Max = 1<<7 - 1
180 rune2Max = 1<<11 - 1
181 rune3Max = 1<<16 - 1
182
183 surrogateMin = 0xD800
184 surrogateMax = 0xDFFF
185
186 maxRune = '\U0010FFFF' // Maximum valid Unicode code point.
187 runeError = '\uFFFD' // the "error" Rune or "Unicode replacement character"
188)
189
190func appendRune(p []byte, r rune) []byte {
191 // Negative values are erroneous. Making it unsigned addresses the problem.
192 switch i := uint32(r); {
193 case i <= rune1Max:
194 p = append(p, byte(r))
195 return p
196 case i <= rune2Max:
197 p = append(p, t2|byte(r>>6))
198 p = append(p, tx|byte(r)&maskx)
199 return p
200 case i > maxRune, surrogateMin <= i && i <= surrogateMax:
201 r = runeError
202 fallthrough
203 case i <= rune3Max:
204 p = append(p, t3|byte(r>>12))
205 p = append(p, tx|byte(r>>6)&maskx)
206 p = append(p, tx|byte(r)&maskx)
207 return p
208 default:
209 p = append(p, t4|byte(r>>18))
210 p = append(p, tx|byte(r>>12)&maskx)
211 p = append(p, tx|byte(r>>6)&maskx)
212 p = append(p, tx|byte(r)&maskx)
213 return p
214 }
215}
diff --git a/vendor/github.com/json-iterator/go/jsoniter.go b/vendor/github.com/json-iterator/go/jsoniter.go
deleted file mode 100644
index c2934f9..0000000
--- a/vendor/github.com/json-iterator/go/jsoniter.go
+++ /dev/null
@@ -1,18 +0,0 @@
1// Package jsoniter implements encoding and decoding of JSON as defined in
2// RFC 4627 and provides interfaces with identical syntax of standard lib encoding/json.
3// Converting from encoding/json to jsoniter is no more than replacing the package with jsoniter
4// and variable type declarations (if any).
5// jsoniter interfaces gives 100% compatibility with code using standard lib.
6//
7// "JSON and Go"
8// (https://golang.org/doc/articles/json_and_go.html)
9// gives a description of how Marshal/Unmarshal operate
10// between arbitrary or predefined json objects and bytes,
11// and it applies to jsoniter.Marshal/Unmarshal as well.
12//
13// Besides, jsoniter.Iterator provides a different set of interfaces
14// iterating given bytes/string/reader
15// and yielding parsed elements one by one.
16// This set of interfaces reads input as required and gives
17// better performance.
18package jsoniter
diff --git a/vendor/github.com/json-iterator/go/pool.go b/vendor/github.com/json-iterator/go/pool.go
deleted file mode 100644
index e2389b5..0000000
--- a/vendor/github.com/json-iterator/go/pool.go
+++ /dev/null
@@ -1,42 +0,0 @@
1package jsoniter
2
3import (
4 "io"
5)
6
7// IteratorPool a thread safe pool of iterators with same configuration
8type IteratorPool interface {
9 BorrowIterator(data []byte) *Iterator
10 ReturnIterator(iter *Iterator)
11}
12
13// StreamPool a thread safe pool of streams with same configuration
14type StreamPool interface {
15 BorrowStream(writer io.Writer) *Stream
16 ReturnStream(stream *Stream)
17}
18
19func (cfg *frozenConfig) BorrowStream(writer io.Writer) *Stream {
20 stream := cfg.streamPool.Get().(*Stream)
21 stream.Reset(writer)
22 return stream
23}
24
25func (cfg *frozenConfig) ReturnStream(stream *Stream) {
26 stream.out = nil
27 stream.Error = nil
28 stream.Attachment = nil
29 cfg.streamPool.Put(stream)
30}
31
32func (cfg *frozenConfig) BorrowIterator(data []byte) *Iterator {
33 iter := cfg.iteratorPool.Get().(*Iterator)
34 iter.ResetBytes(data)
35 return iter
36}
37
38func (cfg *frozenConfig) ReturnIterator(iter *Iterator) {
39 iter.Error = nil
40 iter.Attachment = nil
41 cfg.iteratorPool.Put(iter)
42}
diff --git a/vendor/github.com/json-iterator/go/reflect.go b/vendor/github.com/json-iterator/go/reflect.go
deleted file mode 100644
index 39acb32..0000000
--- a/vendor/github.com/json-iterator/go/reflect.go
+++ /dev/null
@@ -1,337 +0,0 @@
1package jsoniter
2
3import (
4 "fmt"
5 "reflect"
6 "unsafe"
7
8 "github.com/modern-go/reflect2"
9)
10
11// ValDecoder is an internal type registered to cache as needed.
12// Don't confuse jsoniter.ValDecoder with json.Decoder.
13// For json.Decoder's adapter, refer to jsoniter.AdapterDecoder(todo link).
14//
15// Reflection on type to create decoders, which is then cached
16// Reflection on value is avoided as we can, as the reflect.Value itself will allocate, with following exceptions
17// 1. create instance of new value, for example *int will need a int to be allocated
18// 2. append to slice, if the existing cap is not enough, allocate will be done using Reflect.New
19// 3. assignment to map, both key and value will be reflect.Value
20// For a simple struct binding, it will be reflect.Value free and allocation free
21type ValDecoder interface {
22 Decode(ptr unsafe.Pointer, iter *Iterator)
23}
24
25// ValEncoder is an internal type registered to cache as needed.
26// Don't confuse jsoniter.ValEncoder with json.Encoder.
27// For json.Encoder's adapter, refer to jsoniter.AdapterEncoder(todo godoc link).
28type ValEncoder interface {
29 IsEmpty(ptr unsafe.Pointer) bool
30 Encode(ptr unsafe.Pointer, stream *Stream)
31}
32
33type checkIsEmpty interface {
34 IsEmpty(ptr unsafe.Pointer) bool
35}
36
37type ctx struct {
38 *frozenConfig
39 prefix string
40 encoders map[reflect2.Type]ValEncoder
41 decoders map[reflect2.Type]ValDecoder
42}
43
44func (b *ctx) caseSensitive() bool {
45 if b.frozenConfig == nil {
46 // default is case-insensitive
47 return false
48 }
49 return b.frozenConfig.caseSensitive
50}
51
52func (b *ctx) append(prefix string) *ctx {
53 return &ctx{
54 frozenConfig: b.frozenConfig,
55 prefix: b.prefix + " " + prefix,
56 encoders: b.encoders,
57 decoders: b.decoders,
58 }
59}
60
61// ReadVal copy the underlying JSON into go interface, same as json.Unmarshal
62func (iter *Iterator) ReadVal(obj interface{}) {
63 depth := iter.depth
64 cacheKey := reflect2.RTypeOf(obj)
65 decoder := iter.cfg.getDecoderFromCache(cacheKey)
66 if decoder == nil {
67 typ := reflect2.TypeOf(obj)
68 if typ == nil || typ.Kind() != reflect.Ptr {
69 iter.ReportError("ReadVal", "can only unmarshal into pointer")
70 return
71 }
72 decoder = iter.cfg.DecoderOf(typ)
73 }
74 ptr := reflect2.PtrOf(obj)
75 if ptr == nil {
76 iter.ReportError("ReadVal", "can not read into nil pointer")
77 return
78 }
79 decoder.Decode(ptr, iter)
80 if iter.depth != depth {
81 iter.ReportError("ReadVal", "unexpected mismatched nesting")
82 return
83 }
84}
85
86// WriteVal copy the go interface into underlying JSON, same as json.Marshal
87func (stream *Stream) WriteVal(val interface{}) {
88 if nil == val {
89 stream.WriteNil()
90 return
91 }
92 cacheKey := reflect2.RTypeOf(val)
93 encoder := stream.cfg.getEncoderFromCache(cacheKey)
94 if encoder == nil {
95 typ := reflect2.TypeOf(val)
96 encoder = stream.cfg.EncoderOf(typ)
97 }
98 encoder.Encode(reflect2.PtrOf(val), stream)
99}
100
101func (cfg *frozenConfig) DecoderOf(typ reflect2.Type) ValDecoder {
102 cacheKey := typ.RType()
103 decoder := cfg.getDecoderFromCache(cacheKey)
104 if decoder != nil {
105 return decoder
106 }
107 ctx := &ctx{
108 frozenConfig: cfg,
109 prefix: "",
110 decoders: map[reflect2.Type]ValDecoder{},
111 encoders: map[reflect2.Type]ValEncoder{},
112 }
113 ptrType := typ.(*reflect2.UnsafePtrType)
114 decoder = decoderOfType(ctx, ptrType.Elem())
115 cfg.addDecoderToCache(cacheKey, decoder)
116 return decoder
117}
118
119func decoderOfType(ctx *ctx, typ reflect2.Type) ValDecoder {
120 decoder := getTypeDecoderFromExtension(ctx, typ)
121 if decoder != nil {
122 return decoder
123 }
124 decoder = createDecoderOfType(ctx, typ)
125 for _, extension := range extensions {
126 decoder = extension.DecorateDecoder(typ, decoder)
127 }
128 decoder = ctx.decoderExtension.DecorateDecoder(typ, decoder)
129 for _, extension := range ctx.extraExtensions {
130 decoder = extension.DecorateDecoder(typ, decoder)
131 }
132 return decoder
133}
134
135func createDecoderOfType(ctx *ctx, typ reflect2.Type) ValDecoder {
136 decoder := ctx.decoders[typ]
137 if decoder != nil {
138 return decoder
139 }
140 placeholder := &placeholderDecoder{}
141 ctx.decoders[typ] = placeholder
142 decoder = _createDecoderOfType(ctx, typ)
143 placeholder.decoder = decoder
144 return decoder
145}
146
147func _createDecoderOfType(ctx *ctx, typ reflect2.Type) ValDecoder {
148 decoder := createDecoderOfJsonRawMessage(ctx, typ)
149 if decoder != nil {
150 return decoder
151 }
152 decoder = createDecoderOfJsonNumber(ctx, typ)
153 if decoder != nil {
154 return decoder
155 }
156 decoder = createDecoderOfMarshaler(ctx, typ)
157 if decoder != nil {
158 return decoder
159 }
160 decoder = createDecoderOfAny(ctx, typ)
161 if decoder != nil {
162 return decoder
163 }
164 decoder = createDecoderOfNative(ctx, typ)
165 if decoder != nil {
166 return decoder
167 }
168 switch typ.Kind() {
169 case reflect.Interface:
170 ifaceType, isIFace := typ.(*reflect2.UnsafeIFaceType)
171 if isIFace {
172 return &ifaceDecoder{valType: ifaceType}
173 }
174 return &efaceDecoder{}
175 case reflect.Struct:
176 return decoderOfStruct(ctx, typ)
177 case reflect.Array:
178 return decoderOfArray(ctx, typ)
179 case reflect.Slice:
180 return decoderOfSlice(ctx, typ)
181 case reflect.Map:
182 return decoderOfMap(ctx, typ)
183 case reflect.Ptr:
184 return decoderOfOptional(ctx, typ)
185 default:
186 return &lazyErrorDecoder{err: fmt.Errorf("%s%s is unsupported type", ctx.prefix, typ.String())}
187 }
188}
189
190func (cfg *frozenConfig) EncoderOf(typ reflect2.Type) ValEncoder {
191 cacheKey := typ.RType()
192 encoder := cfg.getEncoderFromCache(cacheKey)
193 if encoder != nil {
194 return encoder
195 }
196 ctx := &ctx{
197 frozenConfig: cfg,
198 prefix: "",
199 decoders: map[reflect2.Type]ValDecoder{},
200 encoders: map[reflect2.Type]ValEncoder{},
201 }
202 encoder = encoderOfType(ctx, typ)
203 if typ.LikePtr() {
204 encoder = &onePtrEncoder{encoder}
205 }
206 cfg.addEncoderToCache(cacheKey, encoder)
207 return encoder
208}
209
210type onePtrEncoder struct {
211 encoder ValEncoder
212}
213
214func (encoder *onePtrEncoder) IsEmpty(ptr unsafe.Pointer) bool {
215 return encoder.encoder.IsEmpty(unsafe.Pointer(&ptr))
216}
217
218func (encoder *onePtrEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
219 encoder.encoder.Encode(unsafe.Pointer(&ptr), stream)
220}
221
222func encoderOfType(ctx *ctx, typ reflect2.Type) ValEncoder {
223 encoder := getTypeEncoderFromExtension(ctx, typ)
224 if encoder != nil {
225 return encoder
226 }
227 encoder = createEncoderOfType(ctx, typ)
228 for _, extension := range extensions {
229 encoder = extension.DecorateEncoder(typ, encoder)
230 }
231 encoder = ctx.encoderExtension.DecorateEncoder(typ, encoder)
232 for _, extension := range ctx.extraExtensions {
233 encoder = extension.DecorateEncoder(typ, encoder)
234 }
235 return encoder
236}
237
238func createEncoderOfType(ctx *ctx, typ reflect2.Type) ValEncoder {
239 encoder := ctx.encoders[typ]
240 if encoder != nil {
241 return encoder
242 }
243 placeholder := &placeholderEncoder{}
244 ctx.encoders[typ] = placeholder
245 encoder = _createEncoderOfType(ctx, typ)
246 placeholder.encoder = encoder
247 return encoder
248}
249func _createEncoderOfType(ctx *ctx, typ reflect2.Type) ValEncoder {
250 encoder := createEncoderOfJsonRawMessage(ctx, typ)
251 if encoder != nil {
252 return encoder
253 }
254 encoder = createEncoderOfJsonNumber(ctx, typ)
255 if encoder != nil {
256 return encoder
257 }
258 encoder = createEncoderOfMarshaler(ctx, typ)
259 if encoder != nil {
260 return encoder
261 }
262 encoder = createEncoderOfAny(ctx, typ)
263 if encoder != nil {
264 return encoder
265 }
266 encoder = createEncoderOfNative(ctx, typ)
267 if encoder != nil {
268 return encoder
269 }
270 kind := typ.Kind()
271 switch kind {
272 case reflect.Interface:
273 return &dynamicEncoder{typ}
274 case reflect.Struct:
275 return encoderOfStruct(ctx, typ)
276 case reflect.Array:
277 return encoderOfArray(ctx, typ)
278 case reflect.Slice:
279 return encoderOfSlice(ctx, typ)
280 case reflect.Map:
281 return encoderOfMap(ctx, typ)
282 case reflect.Ptr:
283 return encoderOfOptional(ctx, typ)
284 default:
285 return &lazyErrorEncoder{err: fmt.Errorf("%s%s is unsupported type", ctx.prefix, typ.String())}
286 }
287}
288
289type lazyErrorDecoder struct {
290 err error
291}
292
293func (decoder *lazyErrorDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
294 if iter.WhatIsNext() != NilValue {
295 if iter.Error == nil {
296 iter.Error = decoder.err
297 }
298 } else {
299 iter.Skip()
300 }
301}
302
303type lazyErrorEncoder struct {
304 err error
305}
306
307func (encoder *lazyErrorEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
308 if ptr == nil {
309 stream.WriteNil()
310 } else if stream.Error == nil {
311 stream.Error = encoder.err
312 }
313}
314
315func (encoder *lazyErrorEncoder) IsEmpty(ptr unsafe.Pointer) bool {
316 return false
317}
318
319type placeholderDecoder struct {
320 decoder ValDecoder
321}
322
323func (decoder *placeholderDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
324 decoder.decoder.Decode(ptr, iter)
325}
326
327type placeholderEncoder struct {
328 encoder ValEncoder
329}
330
331func (encoder *placeholderEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
332 encoder.encoder.Encode(ptr, stream)
333}
334
335func (encoder *placeholderEncoder) IsEmpty(ptr unsafe.Pointer) bool {
336 return encoder.encoder.IsEmpty(ptr)
337}
diff --git a/vendor/github.com/json-iterator/go/reflect_array.go b/vendor/github.com/json-iterator/go/reflect_array.go
deleted file mode 100644
index 13a0b7b..0000000
--- a/vendor/github.com/json-iterator/go/reflect_array.go
+++ /dev/null
@@ -1,104 +0,0 @@
1package jsoniter
2
3import (
4 "fmt"
5 "github.com/modern-go/reflect2"
6 "io"
7 "unsafe"
8)
9
10func decoderOfArray(ctx *ctx, typ reflect2.Type) ValDecoder {
11 arrayType := typ.(*reflect2.UnsafeArrayType)
12 decoder := decoderOfType(ctx.append("[arrayElem]"), arrayType.Elem())
13 return &arrayDecoder{arrayType, decoder}
14}
15
16func encoderOfArray(ctx *ctx, typ reflect2.Type) ValEncoder {
17 arrayType := typ.(*reflect2.UnsafeArrayType)
18 if arrayType.Len() == 0 {
19 return emptyArrayEncoder{}
20 }
21 encoder := encoderOfType(ctx.append("[arrayElem]"), arrayType.Elem())
22 return &arrayEncoder{arrayType, encoder}
23}
24
25type emptyArrayEncoder struct{}
26
27func (encoder emptyArrayEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
28 stream.WriteEmptyArray()
29}
30
31func (encoder emptyArrayEncoder) IsEmpty(ptr unsafe.Pointer) bool {
32 return true
33}
34
35type arrayEncoder struct {
36 arrayType *reflect2.UnsafeArrayType
37 elemEncoder ValEncoder
38}
39
40func (encoder *arrayEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
41 stream.WriteArrayStart()
42 elemPtr := unsafe.Pointer(ptr)
43 encoder.elemEncoder.Encode(elemPtr, stream)
44 for i := 1; i < encoder.arrayType.Len(); i++ {
45 stream.WriteMore()
46 elemPtr = encoder.arrayType.UnsafeGetIndex(ptr, i)
47 encoder.elemEncoder.Encode(elemPtr, stream)
48 }
49 stream.WriteArrayEnd()
50 if stream.Error != nil && stream.Error != io.EOF {
51 stream.Error = fmt.Errorf("%v: %s", encoder.arrayType, stream.Error.Error())
52 }
53}
54
55func (encoder *arrayEncoder) IsEmpty(ptr unsafe.Pointer) bool {
56 return false
57}
58
59type arrayDecoder struct {
60 arrayType *reflect2.UnsafeArrayType
61 elemDecoder ValDecoder
62}
63
64func (decoder *arrayDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
65 decoder.doDecode(ptr, iter)
66 if iter.Error != nil && iter.Error != io.EOF {
67 iter.Error = fmt.Errorf("%v: %s", decoder.arrayType, iter.Error.Error())
68 }
69}
70
71func (decoder *arrayDecoder) doDecode(ptr unsafe.Pointer, iter *Iterator) {
72 c := iter.nextToken()
73 arrayType := decoder.arrayType
74 if c == 'n' {
75 iter.skipThreeBytes('u', 'l', 'l')
76 return
77 }
78 if c != '[' {
79 iter.ReportError("decode array", "expect [ or n, but found "+string([]byte{c}))
80 return
81 }
82 c = iter.nextToken()
83 if c == ']' {
84 return
85 }
86 iter.unreadByte()
87 elemPtr := arrayType.UnsafeGetIndex(ptr, 0)
88 decoder.elemDecoder.Decode(elemPtr, iter)
89 length := 1
90 for c = iter.nextToken(); c == ','; c = iter.nextToken() {
91 if length >= arrayType.Len() {
92 iter.Skip()
93 continue
94 }
95 idx := length
96 length += 1
97 elemPtr = arrayType.UnsafeGetIndex(ptr, idx)
98 decoder.elemDecoder.Decode(elemPtr, iter)
99 }
100 if c != ']' {
101 iter.ReportError("decode array", "expect ], but found "+string([]byte{c}))
102 return
103 }
104}
diff --git a/vendor/github.com/json-iterator/go/reflect_dynamic.go b/vendor/github.com/json-iterator/go/reflect_dynamic.go
deleted file mode 100644
index 8b6bc8b..0000000
--- a/vendor/github.com/json-iterator/go/reflect_dynamic.go
+++ /dev/null
@@ -1,70 +0,0 @@
1package jsoniter
2
3import (
4 "github.com/modern-go/reflect2"
5 "reflect"
6 "unsafe"
7)
8
9type dynamicEncoder struct {
10 valType reflect2.Type
11}
12
13func (encoder *dynamicEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
14 obj := encoder.valType.UnsafeIndirect(ptr)
15 stream.WriteVal(obj)
16}
17
18func (encoder *dynamicEncoder) IsEmpty(ptr unsafe.Pointer) bool {
19 return encoder.valType.UnsafeIndirect(ptr) == nil
20}
21
22type efaceDecoder struct {
23}
24
25func (decoder *efaceDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
26 pObj := (*interface{})(ptr)
27 obj := *pObj
28 if obj == nil {
29 *pObj = iter.Read()
30 return
31 }
32 typ := reflect2.TypeOf(obj)
33 if typ.Kind() != reflect.Ptr {
34 *pObj = iter.Read()
35 return
36 }
37 ptrType := typ.(*reflect2.UnsafePtrType)
38 ptrElemType := ptrType.Elem()
39 if iter.WhatIsNext() == NilValue {
40 if ptrElemType.Kind() != reflect.Ptr {
41 iter.skipFourBytes('n', 'u', 'l', 'l')
42 *pObj = nil
43 return
44 }
45 }
46 if reflect2.IsNil(obj) {
47 obj := ptrElemType.New()
48 iter.ReadVal(obj)
49 *pObj = obj
50 return
51 }
52 iter.ReadVal(obj)
53}
54
55type ifaceDecoder struct {
56 valType *reflect2.UnsafeIFaceType
57}
58
59func (decoder *ifaceDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
60 if iter.ReadNil() {
61 decoder.valType.UnsafeSet(ptr, decoder.valType.UnsafeNew())
62 return
63 }
64 obj := decoder.valType.UnsafeIndirect(ptr)
65 if reflect2.IsNil(obj) {
66 iter.ReportError("decode non empty interface", "can not unmarshal into nil")
67 return
68 }
69 iter.ReadVal(obj)
70}
diff --git a/vendor/github.com/json-iterator/go/reflect_extension.go b/vendor/github.com/json-iterator/go/reflect_extension.go
deleted file mode 100644
index 74a97bf..0000000
--- a/vendor/github.com/json-iterator/go/reflect_extension.go
+++ /dev/null
@@ -1,483 +0,0 @@
1package jsoniter
2
3import (
4 "fmt"
5 "github.com/modern-go/reflect2"
6 "reflect"
7 "sort"
8 "strings"
9 "unicode"
10 "unsafe"
11)
12
13var typeDecoders = map[string]ValDecoder{}
14var fieldDecoders = map[string]ValDecoder{}
15var typeEncoders = map[string]ValEncoder{}
16var fieldEncoders = map[string]ValEncoder{}
17var extensions = []Extension{}
18
19// StructDescriptor describe how should we encode/decode the struct
20type StructDescriptor struct {
21 Type reflect2.Type
22 Fields []*Binding
23}
24
25// GetField get one field from the descriptor by its name.
26// Can not use map here to keep field orders.
27func (structDescriptor *StructDescriptor) GetField(fieldName string) *Binding {
28 for _, binding := range structDescriptor.Fields {
29 if binding.Field.Name() == fieldName {
30 return binding
31 }
32 }
33 return nil
34}
35
36// Binding describe how should we encode/decode the struct field
37type Binding struct {
38 levels []int
39 Field reflect2.StructField
40 FromNames []string
41 ToNames []string
42 Encoder ValEncoder
43 Decoder ValDecoder
44}
45
46// Extension the one for all SPI. Customize encoding/decoding by specifying alternate encoder/decoder.
47// Can also rename fields by UpdateStructDescriptor.
48type Extension interface {
49 UpdateStructDescriptor(structDescriptor *StructDescriptor)
50 CreateMapKeyDecoder(typ reflect2.Type) ValDecoder
51 CreateMapKeyEncoder(typ reflect2.Type) ValEncoder
52 CreateDecoder(typ reflect2.Type) ValDecoder
53 CreateEncoder(typ reflect2.Type) ValEncoder
54 DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder
55 DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder
56}
57
58// DummyExtension embed this type get dummy implementation for all methods of Extension
59type DummyExtension struct {
60}
61
62// UpdateStructDescriptor No-op
63func (extension *DummyExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor) {
64}
65
66// CreateMapKeyDecoder No-op
67func (extension *DummyExtension) CreateMapKeyDecoder(typ reflect2.Type) ValDecoder {
68 return nil
69}
70
71// CreateMapKeyEncoder No-op
72func (extension *DummyExtension) CreateMapKeyEncoder(typ reflect2.Type) ValEncoder {
73 return nil
74}
75
76// CreateDecoder No-op
77func (extension *DummyExtension) CreateDecoder(typ reflect2.Type) ValDecoder {
78 return nil
79}
80
81// CreateEncoder No-op
82func (extension *DummyExtension) CreateEncoder(typ reflect2.Type) ValEncoder {
83 return nil
84}
85
86// DecorateDecoder No-op
87func (extension *DummyExtension) DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder {
88 return decoder
89}
90
91// DecorateEncoder No-op
92func (extension *DummyExtension) DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder {
93 return encoder
94}
95
96type EncoderExtension map[reflect2.Type]ValEncoder
97
98// UpdateStructDescriptor No-op
99func (extension EncoderExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor) {
100}
101
102// CreateDecoder No-op
103func (extension EncoderExtension) CreateDecoder(typ reflect2.Type) ValDecoder {
104 return nil
105}
106
107// CreateEncoder get encoder from map
108func (extension EncoderExtension) CreateEncoder(typ reflect2.Type) ValEncoder {
109 return extension[typ]
110}
111
112// CreateMapKeyDecoder No-op
113func (extension EncoderExtension) CreateMapKeyDecoder(typ reflect2.Type) ValDecoder {
114 return nil
115}
116
117// CreateMapKeyEncoder No-op
118func (extension EncoderExtension) CreateMapKeyEncoder(typ reflect2.Type) ValEncoder {
119 return nil
120}
121
122// DecorateDecoder No-op
123func (extension EncoderExtension) DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder {
124 return decoder
125}
126
127// DecorateEncoder No-op
128func (extension EncoderExtension) DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder {
129 return encoder
130}
131
132type DecoderExtension map[reflect2.Type]ValDecoder
133
134// UpdateStructDescriptor No-op
135func (extension DecoderExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor) {
136}
137
138// CreateMapKeyDecoder No-op
139func (extension DecoderExtension) CreateMapKeyDecoder(typ reflect2.Type) ValDecoder {
140 return nil
141}
142
143// CreateMapKeyEncoder No-op
144func (extension DecoderExtension) CreateMapKeyEncoder(typ reflect2.Type) ValEncoder {
145 return nil
146}
147
148// CreateDecoder get decoder from map
149func (extension DecoderExtension) CreateDecoder(typ reflect2.Type) ValDecoder {
150 return extension[typ]
151}
152
153// CreateEncoder No-op
154func (extension DecoderExtension) CreateEncoder(typ reflect2.Type) ValEncoder {
155 return nil
156}
157
158// DecorateDecoder No-op
159func (extension DecoderExtension) DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder {
160 return decoder
161}
162
163// DecorateEncoder No-op
164func (extension DecoderExtension) DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder {
165 return encoder
166}
167
168type funcDecoder struct {
169 fun DecoderFunc
170}
171
172func (decoder *funcDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
173 decoder.fun(ptr, iter)
174}
175
176type funcEncoder struct {
177 fun EncoderFunc
178 isEmptyFunc func(ptr unsafe.Pointer) bool
179}
180
181func (encoder *funcEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
182 encoder.fun(ptr, stream)
183}
184
185func (encoder *funcEncoder) IsEmpty(ptr unsafe.Pointer) bool {
186 if encoder.isEmptyFunc == nil {
187 return false
188 }
189 return encoder.isEmptyFunc(ptr)
190}
191
192// DecoderFunc the function form of TypeDecoder
193type DecoderFunc func(ptr unsafe.Pointer, iter *Iterator)
194
195// EncoderFunc the function form of TypeEncoder
196type EncoderFunc func(ptr unsafe.Pointer, stream *Stream)
197
198// RegisterTypeDecoderFunc register TypeDecoder for a type with function
199func RegisterTypeDecoderFunc(typ string, fun DecoderFunc) {
200 typeDecoders[typ] = &funcDecoder{fun}
201}
202
203// RegisterTypeDecoder register TypeDecoder for a typ
204func RegisterTypeDecoder(typ string, decoder ValDecoder) {
205 typeDecoders[typ] = decoder
206}
207
208// RegisterFieldDecoderFunc register TypeDecoder for a struct field with function
209func RegisterFieldDecoderFunc(typ string, field string, fun DecoderFunc) {
210 RegisterFieldDecoder(typ, field, &funcDecoder{fun})
211}
212
213// RegisterFieldDecoder register TypeDecoder for a struct field
214func RegisterFieldDecoder(typ string, field string, decoder ValDecoder) {
215 fieldDecoders[fmt.Sprintf("%s/%s", typ, field)] = decoder
216}
217
218// RegisterTypeEncoderFunc register TypeEncoder for a type with encode/isEmpty function
219func RegisterTypeEncoderFunc(typ string, fun EncoderFunc, isEmptyFunc func(unsafe.Pointer) bool) {
220 typeEncoders[typ] = &funcEncoder{fun, isEmptyFunc}
221}
222
223// RegisterTypeEncoder register TypeEncoder for a type
224func RegisterTypeEncoder(typ string, encoder ValEncoder) {
225 typeEncoders[typ] = encoder
226}
227
228// RegisterFieldEncoderFunc register TypeEncoder for a struct field with encode/isEmpty function
229func RegisterFieldEncoderFunc(typ string, field string, fun EncoderFunc, isEmptyFunc func(unsafe.Pointer) bool) {
230 RegisterFieldEncoder(typ, field, &funcEncoder{fun, isEmptyFunc})
231}
232
233// RegisterFieldEncoder register TypeEncoder for a struct field
234func RegisterFieldEncoder(typ string, field string, encoder ValEncoder) {
235 fieldEncoders[fmt.Sprintf("%s/%s", typ, field)] = encoder
236}
237
238// RegisterExtension register extension
239func RegisterExtension(extension Extension) {
240 extensions = append(extensions, extension)
241}
242
243func getTypeDecoderFromExtension(ctx *ctx, typ reflect2.Type) ValDecoder {
244 decoder := _getTypeDecoderFromExtension(ctx, typ)
245 if decoder != nil {
246 for _, extension := range extensions {
247 decoder = extension.DecorateDecoder(typ, decoder)
248 }
249 decoder = ctx.decoderExtension.DecorateDecoder(typ, decoder)
250 for _, extension := range ctx.extraExtensions {
251 decoder = extension.DecorateDecoder(typ, decoder)
252 }
253 }
254 return decoder
255}
256func _getTypeDecoderFromExtension(ctx *ctx, typ reflect2.Type) ValDecoder {
257 for _, extension := range extensions {
258 decoder := extension.CreateDecoder(typ)
259 if decoder != nil {
260 return decoder
261 }
262 }
263 decoder := ctx.decoderExtension.CreateDecoder(typ)
264 if decoder != nil {
265 return decoder
266 }
267 for _, extension := range ctx.extraExtensions {
268 decoder := extension.CreateDecoder(typ)
269 if decoder != nil {
270 return decoder
271 }
272 }
273 typeName := typ.String()
274 decoder = typeDecoders[typeName]
275 if decoder != nil {
276 return decoder
277 }
278 if typ.Kind() == reflect.Ptr {
279 ptrType := typ.(*reflect2.UnsafePtrType)
280 decoder := typeDecoders[ptrType.Elem().String()]
281 if decoder != nil {
282 return &OptionalDecoder{ptrType.Elem(), decoder}
283 }
284 }
285 return nil
286}
287
288func getTypeEncoderFromExtension(ctx *ctx, typ reflect2.Type) ValEncoder {
289 encoder := _getTypeEncoderFromExtension(ctx, typ)
290 if encoder != nil {
291 for _, extension := range extensions {
292 encoder = extension.DecorateEncoder(typ, encoder)
293 }
294 encoder = ctx.encoderExtension.DecorateEncoder(typ, encoder)
295 for _, extension := range ctx.extraExtensions {
296 encoder = extension.DecorateEncoder(typ, encoder)
297 }
298 }
299 return encoder
300}
301
302func _getTypeEncoderFromExtension(ctx *ctx, typ reflect2.Type) ValEncoder {
303 for _, extension := range extensions {
304 encoder := extension.CreateEncoder(typ)
305 if encoder != nil {
306 return encoder
307 }
308 }
309 encoder := ctx.encoderExtension.CreateEncoder(typ)
310 if encoder != nil {
311 return encoder
312 }
313 for _, extension := range ctx.extraExtensions {
314 encoder := extension.CreateEncoder(typ)
315 if encoder != nil {
316 return encoder
317 }
318 }
319 typeName := typ.String()
320 encoder = typeEncoders[typeName]
321 if encoder != nil {
322 return encoder
323 }
324 if typ.Kind() == reflect.Ptr {
325 typePtr := typ.(*reflect2.UnsafePtrType)
326 encoder := typeEncoders[typePtr.Elem().String()]
327 if encoder != nil {
328 return &OptionalEncoder{encoder}
329 }
330 }
331 return nil
332}
333
334func describeStruct(ctx *ctx, typ reflect2.Type) *StructDescriptor {
335 structType := typ.(*reflect2.UnsafeStructType)
336 embeddedBindings := []*Binding{}
337 bindings := []*Binding{}
338 for i := 0; i < structType.NumField(); i++ {
339 field := structType.Field(i)
340 tag, hastag := field.Tag().Lookup(ctx.getTagKey())
341 if ctx.onlyTaggedField && !hastag && !field.Anonymous() {
342 continue
343 }
344 if tag == "-" || field.Name() == "_" {
345 continue
346 }
347 tagParts := strings.Split(tag, ",")
348 if field.Anonymous() && (tag == "" || tagParts[0] == "") {
349 if field.Type().Kind() == reflect.Struct {
350 structDescriptor := describeStruct(ctx, field.Type())
351 for _, binding := range structDescriptor.Fields {
352 binding.levels = append([]int{i}, binding.levels...)
353 omitempty := binding.Encoder.(*structFieldEncoder).omitempty
354 binding.Encoder = &structFieldEncoder{field, binding.Encoder, omitempty}
355 binding.Decoder = &structFieldDecoder{field, binding.Decoder}
356 embeddedBindings = append(embeddedBindings, binding)
357 }
358 continue
359 } else if field.Type().Kind() == reflect.Ptr {
360 ptrType := field.Type().(*reflect2.UnsafePtrType)
361 if ptrType.Elem().Kind() == reflect.Struct {
362 structDescriptor := describeStruct(ctx, ptrType.Elem())
363 for _, binding := range structDescriptor.Fields {
364 binding.levels = append([]int{i}, binding.levels...)
365 omitempty := binding.Encoder.(*structFieldEncoder).omitempty
366 binding.Encoder = &dereferenceEncoder{binding.Encoder}
367 binding.Encoder = &structFieldEncoder{field, binding.Encoder, omitempty}
368 binding.Decoder = &dereferenceDecoder{ptrType.Elem(), binding.Decoder}
369 binding.Decoder = &structFieldDecoder{field, binding.Decoder}
370 embeddedBindings = append(embeddedBindings, binding)
371 }
372 continue
373 }
374 }
375 }
376 fieldNames := calcFieldNames(field.Name(), tagParts[0], tag)
377 fieldCacheKey := fmt.Sprintf("%s/%s", typ.String(), field.Name())
378 decoder := fieldDecoders[fieldCacheKey]
379 if decoder == nil {
380 decoder = decoderOfType(ctx.append(field.Name()), field.Type())
381 }
382 encoder := fieldEncoders[fieldCacheKey]
383 if encoder == nil {
384 encoder = encoderOfType(ctx.append(field.Name()), field.Type())
385 }
386 binding := &Binding{
387 Field: field,
388 FromNames: fieldNames,
389 ToNames: fieldNames,
390 Decoder: decoder,
391 Encoder: encoder,
392 }
393 binding.levels = []int{i}
394 bindings = append(bindings, binding)
395 }
396 return createStructDescriptor(ctx, typ, bindings, embeddedBindings)
397}
398func createStructDescriptor(ctx *ctx, typ reflect2.Type, bindings []*Binding, embeddedBindings []*Binding) *StructDescriptor {
399 structDescriptor := &StructDescriptor{
400 Type: typ,
401 Fields: bindings,
402 }
403 for _, extension := range extensions {
404 extension.UpdateStructDescriptor(structDescriptor)
405 }
406 ctx.encoderExtension.UpdateStructDescriptor(structDescriptor)
407 ctx.decoderExtension.UpdateStructDescriptor(structDescriptor)
408 for _, extension := range ctx.extraExtensions {
409 extension.UpdateStructDescriptor(structDescriptor)
410 }
411 processTags(structDescriptor, ctx.frozenConfig)
412 // merge normal & embedded bindings & sort with original order
413 allBindings := sortableBindings(append(embeddedBindings, structDescriptor.Fields...))
414 sort.Sort(allBindings)
415 structDescriptor.Fields = allBindings
416 return structDescriptor
417}
418
419type sortableBindings []*Binding
420
421func (bindings sortableBindings) Len() int {
422 return len(bindings)
423}
424
425func (bindings sortableBindings) Less(i, j int) bool {
426 left := bindings[i].levels
427 right := bindings[j].levels
428 k := 0
429 for {
430 if left[k] < right[k] {
431 return true
432 } else if left[k] > right[k] {
433 return false
434 }
435 k++
436 }
437}
438
439func (bindings sortableBindings) Swap(i, j int) {
440 bindings[i], bindings[j] = bindings[j], bindings[i]
441}
442
443func processTags(structDescriptor *StructDescriptor, cfg *frozenConfig) {
444 for _, binding := range structDescriptor.Fields {
445 shouldOmitEmpty := false
446 tagParts := strings.Split(binding.Field.Tag().Get(cfg.getTagKey()), ",")
447 for _, tagPart := range tagParts[1:] {
448 if tagPart == "omitempty" {
449 shouldOmitEmpty = true
450 } else if tagPart == "string" {
451 if binding.Field.Type().Kind() == reflect.String {
452 binding.Decoder = &stringModeStringDecoder{binding.Decoder, cfg}
453 binding.Encoder = &stringModeStringEncoder{binding.Encoder, cfg}
454 } else {
455 binding.Decoder = &stringModeNumberDecoder{binding.Decoder}
456 binding.Encoder = &stringModeNumberEncoder{binding.Encoder}
457 }
458 }
459 }
460 binding.Decoder = &structFieldDecoder{binding.Field, binding.Decoder}
461 binding.Encoder = &structFieldEncoder{binding.Field, binding.Encoder, shouldOmitEmpty}
462 }
463}
464
465func calcFieldNames(originalFieldName string, tagProvidedFieldName string, wholeTag string) []string {
466 // ignore?
467 if wholeTag == "-" {
468 return []string{}
469 }
470 // rename?
471 var fieldNames []string
472 if tagProvidedFieldName == "" {
473 fieldNames = []string{originalFieldName}
474 } else {
475 fieldNames = []string{tagProvidedFieldName}
476 }
477 // private?
478 isNotExported := unicode.IsLower(rune(originalFieldName[0])) || originalFieldName[0] == '_'
479 if isNotExported {
480 fieldNames = []string{}
481 }
482 return fieldNames
483}
diff --git a/vendor/github.com/json-iterator/go/reflect_json_number.go b/vendor/github.com/json-iterator/go/reflect_json_number.go
deleted file mode 100644
index 98d45c1..0000000
--- a/vendor/github.com/json-iterator/go/reflect_json_number.go
+++ /dev/null
@@ -1,112 +0,0 @@
1package jsoniter
2
3import (
4 "encoding/json"
5 "github.com/modern-go/reflect2"
6 "strconv"
7 "unsafe"
8)
9
10type Number string
11
12// String returns the literal text of the number.
13func (n Number) String() string { return string(n) }
14
15// Float64 returns the number as a float64.
16func (n Number) Float64() (float64, error) {
17 return strconv.ParseFloat(string(n), 64)
18}
19
20// Int64 returns the number as an int64.
21func (n Number) Int64() (int64, error) {
22 return strconv.ParseInt(string(n), 10, 64)
23}
24
25func CastJsonNumber(val interface{}) (string, bool) {
26 switch typedVal := val.(type) {
27 case json.Number:
28 return string(typedVal), true
29 case Number:
30 return string(typedVal), true
31 }
32 return "", false
33}
34
35var jsonNumberType = reflect2.TypeOfPtr((*json.Number)(nil)).Elem()
36var jsoniterNumberType = reflect2.TypeOfPtr((*Number)(nil)).Elem()
37
38func createDecoderOfJsonNumber(ctx *ctx, typ reflect2.Type) ValDecoder {
39 if typ.AssignableTo(jsonNumberType) {
40 return &jsonNumberCodec{}
41 }
42 if typ.AssignableTo(jsoniterNumberType) {
43 return &jsoniterNumberCodec{}
44 }
45 return nil
46}
47
48func createEncoderOfJsonNumber(ctx *ctx, typ reflect2.Type) ValEncoder {
49 if typ.AssignableTo(jsonNumberType) {
50 return &jsonNumberCodec{}
51 }
52 if typ.AssignableTo(jsoniterNumberType) {
53 return &jsoniterNumberCodec{}
54 }
55 return nil
56}
57
58type jsonNumberCodec struct {
59}
60
61func (codec *jsonNumberCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
62 switch iter.WhatIsNext() {
63 case StringValue:
64 *((*json.Number)(ptr)) = json.Number(iter.ReadString())
65 case NilValue:
66 iter.skipFourBytes('n', 'u', 'l', 'l')
67 *((*json.Number)(ptr)) = ""
68 default:
69 *((*json.Number)(ptr)) = json.Number([]byte(iter.readNumberAsString()))
70 }
71}
72
73func (codec *jsonNumberCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
74 number := *((*json.Number)(ptr))
75 if len(number) == 0 {
76 stream.writeByte('0')
77 } else {
78 stream.WriteRaw(string(number))
79 }
80}
81
82func (codec *jsonNumberCodec) IsEmpty(ptr unsafe.Pointer) bool {
83 return len(*((*json.Number)(ptr))) == 0
84}
85
86type jsoniterNumberCodec struct {
87}
88
89func (codec *jsoniterNumberCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
90 switch iter.WhatIsNext() {
91 case StringValue:
92 *((*Number)(ptr)) = Number(iter.ReadString())
93 case NilValue:
94 iter.skipFourBytes('n', 'u', 'l', 'l')
95 *((*Number)(ptr)) = ""
96 default:
97 *((*Number)(ptr)) = Number([]byte(iter.readNumberAsString()))
98 }
99}
100
101func (codec *jsoniterNumberCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
102 number := *((*Number)(ptr))
103 if len(number) == 0 {
104 stream.writeByte('0')
105 } else {
106 stream.WriteRaw(string(number))
107 }
108}
109
110func (codec *jsoniterNumberCodec) IsEmpty(ptr unsafe.Pointer) bool {
111 return len(*((*Number)(ptr))) == 0
112}
diff --git a/vendor/github.com/json-iterator/go/reflect_json_raw_message.go b/vendor/github.com/json-iterator/go/reflect_json_raw_message.go
deleted file mode 100644
index eba434f..0000000
--- a/vendor/github.com/json-iterator/go/reflect_json_raw_message.go
+++ /dev/null
@@ -1,76 +0,0 @@
1package jsoniter
2
3import (
4 "encoding/json"
5 "github.com/modern-go/reflect2"
6 "unsafe"
7)
8
9var jsonRawMessageType = reflect2.TypeOfPtr((*json.RawMessage)(nil)).Elem()
10var jsoniterRawMessageType = reflect2.TypeOfPtr((*RawMessage)(nil)).Elem()
11
12func createEncoderOfJsonRawMessage(ctx *ctx, typ reflect2.Type) ValEncoder {
13 if typ == jsonRawMessageType {
14 return &jsonRawMessageCodec{}
15 }
16 if typ == jsoniterRawMessageType {
17 return &jsoniterRawMessageCodec{}
18 }
19 return nil
20}
21
22func createDecoderOfJsonRawMessage(ctx *ctx, typ reflect2.Type) ValDecoder {
23 if typ == jsonRawMessageType {
24 return &jsonRawMessageCodec{}
25 }
26 if typ == jsoniterRawMessageType {
27 return &jsoniterRawMessageCodec{}
28 }
29 return nil
30}
31
32type jsonRawMessageCodec struct {
33}
34
35func (codec *jsonRawMessageCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
36 if iter.ReadNil() {
37 *((*json.RawMessage)(ptr)) = nil
38 } else {
39 *((*json.RawMessage)(ptr)) = iter.SkipAndReturnBytes()
40 }
41}
42
43func (codec *jsonRawMessageCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
44 if *((*json.RawMessage)(ptr)) == nil {
45 stream.WriteNil()
46 } else {
47 stream.WriteRaw(string(*((*json.RawMessage)(ptr))))
48 }
49}
50
51func (codec *jsonRawMessageCodec) IsEmpty(ptr unsafe.Pointer) bool {
52 return len(*((*json.RawMessage)(ptr))) == 0
53}
54
55type jsoniterRawMessageCodec struct {
56}
57
58func (codec *jsoniterRawMessageCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
59 if iter.ReadNil() {
60 *((*RawMessage)(ptr)) = nil
61 } else {
62 *((*RawMessage)(ptr)) = iter.SkipAndReturnBytes()
63 }
64}
65
66func (codec *jsoniterRawMessageCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
67 if *((*RawMessage)(ptr)) == nil {
68 stream.WriteNil()
69 } else {
70 stream.WriteRaw(string(*((*RawMessage)(ptr))))
71 }
72}
73
74func (codec *jsoniterRawMessageCodec) IsEmpty(ptr unsafe.Pointer) bool {
75 return len(*((*RawMessage)(ptr))) == 0
76}
diff --git a/vendor/github.com/json-iterator/go/reflect_map.go b/vendor/github.com/json-iterator/go/reflect_map.go
deleted file mode 100644
index 5829671..0000000
--- a/vendor/github.com/json-iterator/go/reflect_map.go
+++ /dev/null
@@ -1,346 +0,0 @@
1package jsoniter
2
3import (
4 "fmt"
5 "github.com/modern-go/reflect2"
6 "io"
7 "reflect"
8 "sort"
9 "unsafe"
10)
11
12func decoderOfMap(ctx *ctx, typ reflect2.Type) ValDecoder {
13 mapType := typ.(*reflect2.UnsafeMapType)
14 keyDecoder := decoderOfMapKey(ctx.append("[mapKey]"), mapType.Key())
15 elemDecoder := decoderOfType(ctx.append("[mapElem]"), mapType.Elem())
16 return &mapDecoder{
17 mapType: mapType,
18 keyType: mapType.Key(),
19 elemType: mapType.Elem(),
20 keyDecoder: keyDecoder,
21 elemDecoder: elemDecoder,
22 }
23}
24
25func encoderOfMap(ctx *ctx, typ reflect2.Type) ValEncoder {
26 mapType := typ.(*reflect2.UnsafeMapType)
27 if ctx.sortMapKeys {
28 return &sortKeysMapEncoder{
29 mapType: mapType,
30 keyEncoder: encoderOfMapKey(ctx.append("[mapKey]"), mapType.Key()),
31 elemEncoder: encoderOfType(ctx.append("[mapElem]"), mapType.Elem()),
32 }
33 }
34 return &mapEncoder{
35 mapType: mapType,
36 keyEncoder: encoderOfMapKey(ctx.append("[mapKey]"), mapType.Key()),
37 elemEncoder: encoderOfType(ctx.append("[mapElem]"), mapType.Elem()),
38 }
39}
40
41func decoderOfMapKey(ctx *ctx, typ reflect2.Type) ValDecoder {
42 decoder := ctx.decoderExtension.CreateMapKeyDecoder(typ)
43 if decoder != nil {
44 return decoder
45 }
46 for _, extension := range ctx.extraExtensions {
47 decoder := extension.CreateMapKeyDecoder(typ)
48 if decoder != nil {
49 return decoder
50 }
51 }
52
53 ptrType := reflect2.PtrTo(typ)
54 if ptrType.Implements(unmarshalerType) {
55 return &referenceDecoder{
56 &unmarshalerDecoder{
57 valType: ptrType,
58 },
59 }
60 }
61 if typ.Implements(unmarshalerType) {
62 return &unmarshalerDecoder{
63 valType: typ,
64 }
65 }
66 if ptrType.Implements(textUnmarshalerType) {
67 return &referenceDecoder{
68 &textUnmarshalerDecoder{
69 valType: ptrType,
70 },
71 }
72 }
73 if typ.Implements(textUnmarshalerType) {
74 return &textUnmarshalerDecoder{
75 valType: typ,
76 }
77 }
78
79 switch typ.Kind() {
80 case reflect.String:
81 return decoderOfType(ctx, reflect2.DefaultTypeOfKind(reflect.String))
82 case reflect.Bool,
83 reflect.Uint8, reflect.Int8,
84 reflect.Uint16, reflect.Int16,
85 reflect.Uint32, reflect.Int32,
86 reflect.Uint64, reflect.Int64,
87 reflect.Uint, reflect.Int,
88 reflect.Float32, reflect.Float64,
89 reflect.Uintptr:
90 typ = reflect2.DefaultTypeOfKind(typ.Kind())
91 return &numericMapKeyDecoder{decoderOfType(ctx, typ)}
92 default:
93 return &lazyErrorDecoder{err: fmt.Errorf("unsupported map key type: %v", typ)}
94 }
95}
96
97func encoderOfMapKey(ctx *ctx, typ reflect2.Type) ValEncoder {
98 encoder := ctx.encoderExtension.CreateMapKeyEncoder(typ)
99 if encoder != nil {
100 return encoder
101 }
102 for _, extension := range ctx.extraExtensions {
103 encoder := extension.CreateMapKeyEncoder(typ)
104 if encoder != nil {
105 return encoder
106 }
107 }
108
109 if typ == textMarshalerType {
110 return &directTextMarshalerEncoder{
111 stringEncoder: ctx.EncoderOf(reflect2.TypeOf("")),
112 }
113 }
114 if typ.Implements(textMarshalerType) {
115 return &textMarshalerEncoder{
116 valType: typ,
117 stringEncoder: ctx.EncoderOf(reflect2.TypeOf("")),
118 }
119 }
120
121 switch typ.Kind() {
122 case reflect.String:
123 return encoderOfType(ctx, reflect2.DefaultTypeOfKind(reflect.String))
124 case reflect.Bool,
125 reflect.Uint8, reflect.Int8,
126 reflect.Uint16, reflect.Int16,
127 reflect.Uint32, reflect.Int32,
128 reflect.Uint64, reflect.Int64,
129 reflect.Uint, reflect.Int,
130 reflect.Float32, reflect.Float64,
131 reflect.Uintptr:
132 typ = reflect2.DefaultTypeOfKind(typ.Kind())
133 return &numericMapKeyEncoder{encoderOfType(ctx, typ)}
134 default:
135 if typ.Kind() == reflect.Interface {
136 return &dynamicMapKeyEncoder{ctx, typ}
137 }
138 return &lazyErrorEncoder{err: fmt.Errorf("unsupported map key type: %v", typ)}
139 }
140}
141
142type mapDecoder struct {
143 mapType *reflect2.UnsafeMapType
144 keyType reflect2.Type
145 elemType reflect2.Type
146 keyDecoder ValDecoder
147 elemDecoder ValDecoder
148}
149
150func (decoder *mapDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
151 mapType := decoder.mapType
152 c := iter.nextToken()
153 if c == 'n' {
154 iter.skipThreeBytes('u', 'l', 'l')
155 *(*unsafe.Pointer)(ptr) = nil
156 mapType.UnsafeSet(ptr, mapType.UnsafeNew())
157 return
158 }
159 if mapType.UnsafeIsNil(ptr) {
160 mapType.UnsafeSet(ptr, mapType.UnsafeMakeMap(0))
161 }
162 if c != '{' {
163 iter.ReportError("ReadMapCB", `expect { or n, but found `+string([]byte{c}))
164 return
165 }
166 c = iter.nextToken()
167 if c == '}' {
168 return
169 }
170 iter.unreadByte()
171 key := decoder.keyType.UnsafeNew()
172 decoder.keyDecoder.Decode(key, iter)
173 c = iter.nextToken()
174 if c != ':' {
175 iter.ReportError("ReadMapCB", "expect : after object field, but found "+string([]byte{c}))
176 return
177 }
178 elem := decoder.elemType.UnsafeNew()
179 decoder.elemDecoder.Decode(elem, iter)
180 decoder.mapType.UnsafeSetIndex(ptr, key, elem)
181 for c = iter.nextToken(); c == ','; c = iter.nextToken() {
182 key := decoder.keyType.UnsafeNew()
183 decoder.keyDecoder.Decode(key, iter)
184 c = iter.nextToken()
185 if c != ':' {
186 iter.ReportError("ReadMapCB", "expect : after object field, but found "+string([]byte{c}))
187 return
188 }
189 elem := decoder.elemType.UnsafeNew()
190 decoder.elemDecoder.Decode(elem, iter)
191 decoder.mapType.UnsafeSetIndex(ptr, key, elem)
192 }
193 if c != '}' {
194 iter.ReportError("ReadMapCB", `expect }, but found `+string([]byte{c}))
195 }
196}
197
198type numericMapKeyDecoder struct {
199 decoder ValDecoder
200}
201
202func (decoder *numericMapKeyDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
203 c := iter.nextToken()
204 if c != '"' {
205 iter.ReportError("ReadMapCB", `expect ", but found `+string([]byte{c}))
206 return
207 }
208 decoder.decoder.Decode(ptr, iter)
209 c = iter.nextToken()
210 if c != '"' {
211 iter.ReportError("ReadMapCB", `expect ", but found `+string([]byte{c}))
212 return
213 }
214}
215
216type numericMapKeyEncoder struct {
217 encoder ValEncoder
218}
219
220func (encoder *numericMapKeyEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
221 stream.writeByte('"')
222 encoder.encoder.Encode(ptr, stream)
223 stream.writeByte('"')
224}
225
226func (encoder *numericMapKeyEncoder) IsEmpty(ptr unsafe.Pointer) bool {
227 return false
228}
229
230type dynamicMapKeyEncoder struct {
231 ctx *ctx
232 valType reflect2.Type
233}
234
235func (encoder *dynamicMapKeyEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
236 obj := encoder.valType.UnsafeIndirect(ptr)
237 encoderOfMapKey(encoder.ctx, reflect2.TypeOf(obj)).Encode(reflect2.PtrOf(obj), stream)
238}
239
240func (encoder *dynamicMapKeyEncoder) IsEmpty(ptr unsafe.Pointer) bool {
241 obj := encoder.valType.UnsafeIndirect(ptr)
242 return encoderOfMapKey(encoder.ctx, reflect2.TypeOf(obj)).IsEmpty(reflect2.PtrOf(obj))
243}
244
245type mapEncoder struct {
246 mapType *reflect2.UnsafeMapType
247 keyEncoder ValEncoder
248 elemEncoder ValEncoder
249}
250
251func (encoder *mapEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
252 if *(*unsafe.Pointer)(ptr) == nil {
253 stream.WriteNil()
254 return
255 }
256 stream.WriteObjectStart()
257 iter := encoder.mapType.UnsafeIterate(ptr)
258 for i := 0; iter.HasNext(); i++ {
259 if i != 0 {
260 stream.WriteMore()
261 }
262 key, elem := iter.UnsafeNext()
263 encoder.keyEncoder.Encode(key, stream)
264 if stream.indention > 0 {
265 stream.writeTwoBytes(byte(':'), byte(' '))
266 } else {
267 stream.writeByte(':')
268 }
269 encoder.elemEncoder.Encode(elem, stream)
270 }
271 stream.WriteObjectEnd()
272}
273
274func (encoder *mapEncoder) IsEmpty(ptr unsafe.Pointer) bool {
275 iter := encoder.mapType.UnsafeIterate(ptr)
276 return !iter.HasNext()
277}
278
279type sortKeysMapEncoder struct {
280 mapType *reflect2.UnsafeMapType
281 keyEncoder ValEncoder
282 elemEncoder ValEncoder
283}
284
285func (encoder *sortKeysMapEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
286 if *(*unsafe.Pointer)(ptr) == nil {
287 stream.WriteNil()
288 return
289 }
290 stream.WriteObjectStart()
291 mapIter := encoder.mapType.UnsafeIterate(ptr)
292 subStream := stream.cfg.BorrowStream(nil)
293 subStream.Attachment = stream.Attachment
294 subIter := stream.cfg.BorrowIterator(nil)
295 keyValues := encodedKeyValues{}
296 for mapIter.HasNext() {
297 key, elem := mapIter.UnsafeNext()
298 subStreamIndex := subStream.Buffered()
299 encoder.keyEncoder.Encode(key, subStream)
300 if subStream.Error != nil && subStream.Error != io.EOF && stream.Error == nil {
301 stream.Error = subStream.Error
302 }
303 encodedKey := subStream.Buffer()[subStreamIndex:]
304 subIter.ResetBytes(encodedKey)
305 decodedKey := subIter.ReadString()
306 if stream.indention > 0 {
307 subStream.writeTwoBytes(byte(':'), byte(' '))
308 } else {
309 subStream.writeByte(':')
310 }
311 encoder.elemEncoder.Encode(elem, subStream)
312 keyValues = append(keyValues, encodedKV{
313 key: decodedKey,
314 keyValue: subStream.Buffer()[subStreamIndex:],
315 })
316 }
317 sort.Sort(keyValues)
318 for i, keyValue := range keyValues {
319 if i != 0 {
320 stream.WriteMore()
321 }
322 stream.Write(keyValue.keyValue)
323 }
324 if subStream.Error != nil && stream.Error == nil {
325 stream.Error = subStream.Error
326 }
327 stream.WriteObjectEnd()
328 stream.cfg.ReturnStream(subStream)
329 stream.cfg.ReturnIterator(subIter)
330}
331
332func (encoder *sortKeysMapEncoder) IsEmpty(ptr unsafe.Pointer) bool {
333 iter := encoder.mapType.UnsafeIterate(ptr)
334 return !iter.HasNext()
335}
336
337type encodedKeyValues []encodedKV
338
339type encodedKV struct {
340 key string
341 keyValue []byte
342}
343
344func (sv encodedKeyValues) Len() int { return len(sv) }
345func (sv encodedKeyValues) Swap(i, j int) { sv[i], sv[j] = sv[j], sv[i] }
346func (sv encodedKeyValues) Less(i, j int) bool { return sv[i].key < sv[j].key }
diff --git a/vendor/github.com/json-iterator/go/reflect_marshaler.go b/vendor/github.com/json-iterator/go/reflect_marshaler.go
deleted file mode 100644
index 3e21f37..0000000
--- a/vendor/github.com/json-iterator/go/reflect_marshaler.go
+++ /dev/null
@@ -1,225 +0,0 @@
1package jsoniter
2
3import (
4 "encoding"
5 "encoding/json"
6 "unsafe"
7
8 "github.com/modern-go/reflect2"
9)
10
11var marshalerType = reflect2.TypeOfPtr((*json.Marshaler)(nil)).Elem()
12var unmarshalerType = reflect2.TypeOfPtr((*json.Unmarshaler)(nil)).Elem()
13var textMarshalerType = reflect2.TypeOfPtr((*encoding.TextMarshaler)(nil)).Elem()
14var textUnmarshalerType = reflect2.TypeOfPtr((*encoding.TextUnmarshaler)(nil)).Elem()
15
16func createDecoderOfMarshaler(ctx *ctx, typ reflect2.Type) ValDecoder {
17 ptrType := reflect2.PtrTo(typ)
18 if ptrType.Implements(unmarshalerType) {
19 return &referenceDecoder{
20 &unmarshalerDecoder{ptrType},
21 }
22 }
23 if ptrType.Implements(textUnmarshalerType) {
24 return &referenceDecoder{
25 &textUnmarshalerDecoder{ptrType},
26 }
27 }
28 return nil
29}
30
31func createEncoderOfMarshaler(ctx *ctx, typ reflect2.Type) ValEncoder {
32 if typ == marshalerType {
33 checkIsEmpty := createCheckIsEmpty(ctx, typ)
34 var encoder ValEncoder = &directMarshalerEncoder{
35 checkIsEmpty: checkIsEmpty,
36 }
37 return encoder
38 }
39 if typ.Implements(marshalerType) {
40 checkIsEmpty := createCheckIsEmpty(ctx, typ)
41 var encoder ValEncoder = &marshalerEncoder{
42 valType: typ,
43 checkIsEmpty: checkIsEmpty,
44 }
45 return encoder
46 }
47 ptrType := reflect2.PtrTo(typ)
48 if ctx.prefix != "" && ptrType.Implements(marshalerType) {
49 checkIsEmpty := createCheckIsEmpty(ctx, ptrType)
50 var encoder ValEncoder = &marshalerEncoder{
51 valType: ptrType,
52 checkIsEmpty: checkIsEmpty,
53 }
54 return &referenceEncoder{encoder}
55 }
56 if typ == textMarshalerType {
57 checkIsEmpty := createCheckIsEmpty(ctx, typ)
58 var encoder ValEncoder = &directTextMarshalerEncoder{
59 checkIsEmpty: checkIsEmpty,
60 stringEncoder: ctx.EncoderOf(reflect2.TypeOf("")),
61 }
62 return encoder
63 }
64 if typ.Implements(textMarshalerType) {
65 checkIsEmpty := createCheckIsEmpty(ctx, typ)
66 var encoder ValEncoder = &textMarshalerEncoder{
67 valType: typ,
68 stringEncoder: ctx.EncoderOf(reflect2.TypeOf("")),
69 checkIsEmpty: checkIsEmpty,
70 }
71 return encoder
72 }
73 // if prefix is empty, the type is the root type
74 if ctx.prefix != "" && ptrType.Implements(textMarshalerType) {
75 checkIsEmpty := createCheckIsEmpty(ctx, ptrType)
76 var encoder ValEncoder = &textMarshalerEncoder{
77 valType: ptrType,
78 stringEncoder: ctx.EncoderOf(reflect2.TypeOf("")),
79 checkIsEmpty: checkIsEmpty,
80 }
81 return &referenceEncoder{encoder}
82 }
83 return nil
84}
85
86type marshalerEncoder struct {
87 checkIsEmpty checkIsEmpty
88 valType reflect2.Type
89}
90
91func (encoder *marshalerEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
92 obj := encoder.valType.UnsafeIndirect(ptr)
93 if encoder.valType.IsNullable() && reflect2.IsNil(obj) {
94 stream.WriteNil()
95 return
96 }
97 marshaler := obj.(json.Marshaler)
98 bytes, err := marshaler.MarshalJSON()
99 if err != nil {
100 stream.Error = err
101 } else {
102 // html escape was already done by jsoniter
103 // but the extra '\n' should be trimed
104 l := len(bytes)
105 if l > 0 && bytes[l-1] == '\n' {
106 bytes = bytes[:l-1]
107 }
108 stream.Write(bytes)
109 }
110}
111
112func (encoder *marshalerEncoder) IsEmpty(ptr unsafe.Pointer) bool {
113 return encoder.checkIsEmpty.IsEmpty(ptr)
114}
115
116type directMarshalerEncoder struct {
117 checkIsEmpty checkIsEmpty
118}
119
120func (encoder *directMarshalerEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
121 marshaler := *(*json.Marshaler)(ptr)
122 if marshaler == nil {
123 stream.WriteNil()
124 return
125 }
126 bytes, err := marshaler.MarshalJSON()
127 if err != nil {
128 stream.Error = err
129 } else {
130 stream.Write(bytes)
131 }
132}
133
134func (encoder *directMarshalerEncoder) IsEmpty(ptr unsafe.Pointer) bool {
135 return encoder.checkIsEmpty.IsEmpty(ptr)
136}
137
138type textMarshalerEncoder struct {
139 valType reflect2.Type
140 stringEncoder ValEncoder
141 checkIsEmpty checkIsEmpty
142}
143
144func (encoder *textMarshalerEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
145 obj := encoder.valType.UnsafeIndirect(ptr)
146 if encoder.valType.IsNullable() && reflect2.IsNil(obj) {
147 stream.WriteNil()
148 return
149 }
150 marshaler := (obj).(encoding.TextMarshaler)
151 bytes, err := marshaler.MarshalText()
152 if err != nil {
153 stream.Error = err
154 } else {
155 str := string(bytes)
156 encoder.stringEncoder.Encode(unsafe.Pointer(&str), stream)
157 }
158}
159
160func (encoder *textMarshalerEncoder) IsEmpty(ptr unsafe.Pointer) bool {
161 return encoder.checkIsEmpty.IsEmpty(ptr)
162}
163
164type directTextMarshalerEncoder struct {
165 stringEncoder ValEncoder
166 checkIsEmpty checkIsEmpty
167}
168
169func (encoder *directTextMarshalerEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
170 marshaler := *(*encoding.TextMarshaler)(ptr)
171 if marshaler == nil {
172 stream.WriteNil()
173 return
174 }
175 bytes, err := marshaler.MarshalText()
176 if err != nil {
177 stream.Error = err
178 } else {
179 str := string(bytes)
180 encoder.stringEncoder.Encode(unsafe.Pointer(&str), stream)
181 }
182}
183
184func (encoder *directTextMarshalerEncoder) IsEmpty(ptr unsafe.Pointer) bool {
185 return encoder.checkIsEmpty.IsEmpty(ptr)
186}
187
188type unmarshalerDecoder struct {
189 valType reflect2.Type
190}
191
192func (decoder *unmarshalerDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
193 valType := decoder.valType
194 obj := valType.UnsafeIndirect(ptr)
195 unmarshaler := obj.(json.Unmarshaler)
196 iter.nextToken()
197 iter.unreadByte() // skip spaces
198 bytes := iter.SkipAndReturnBytes()
199 err := unmarshaler.UnmarshalJSON(bytes)
200 if err != nil {
201 iter.ReportError("unmarshalerDecoder", err.Error())
202 }
203}
204
205type textUnmarshalerDecoder struct {
206 valType reflect2.Type
207}
208
209func (decoder *textUnmarshalerDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
210 valType := decoder.valType
211 obj := valType.UnsafeIndirect(ptr)
212 if reflect2.IsNil(obj) {
213 ptrType := valType.(*reflect2.UnsafePtrType)
214 elemType := ptrType.Elem()
215 elem := elemType.UnsafeNew()
216 ptrType.UnsafeSet(ptr, unsafe.Pointer(&elem))
217 obj = valType.UnsafeIndirect(ptr)
218 }
219 unmarshaler := (obj).(encoding.TextUnmarshaler)
220 str := iter.ReadString()
221 err := unmarshaler.UnmarshalText([]byte(str))
222 if err != nil {
223 iter.ReportError("textUnmarshalerDecoder", err.Error())
224 }
225}
diff --git a/vendor/github.com/json-iterator/go/reflect_native.go b/vendor/github.com/json-iterator/go/reflect_native.go
deleted file mode 100644
index f88722d..0000000
--- a/vendor/github.com/json-iterator/go/reflect_native.go
+++ /dev/null
@@ -1,453 +0,0 @@
1package jsoniter
2
3import (
4 "encoding/base64"
5 "reflect"
6 "strconv"
7 "unsafe"
8
9 "github.com/modern-go/reflect2"
10)
11
12const ptrSize = 32 << uintptr(^uintptr(0)>>63)
13
14func createEncoderOfNative(ctx *ctx, typ reflect2.Type) ValEncoder {
15 if typ.Kind() == reflect.Slice && typ.(reflect2.SliceType).Elem().Kind() == reflect.Uint8 {
16 sliceDecoder := decoderOfSlice(ctx, typ)
17 return &base64Codec{sliceDecoder: sliceDecoder}
18 }
19 typeName := typ.String()
20 kind := typ.Kind()
21 switch kind {
22 case reflect.String:
23 if typeName != "string" {
24 return encoderOfType(ctx, reflect2.TypeOfPtr((*string)(nil)).Elem())
25 }
26 return &stringCodec{}
27 case reflect.Int:
28 if typeName != "int" {
29 return encoderOfType(ctx, reflect2.TypeOfPtr((*int)(nil)).Elem())
30 }
31 if strconv.IntSize == 32 {
32 return &int32Codec{}
33 }
34 return &int64Codec{}
35 case reflect.Int8:
36 if typeName != "int8" {
37 return encoderOfType(ctx, reflect2.TypeOfPtr((*int8)(nil)).Elem())
38 }
39 return &int8Codec{}
40 case reflect.Int16:
41 if typeName != "int16" {
42 return encoderOfType(ctx, reflect2.TypeOfPtr((*int16)(nil)).Elem())
43 }
44 return &int16Codec{}
45 case reflect.Int32:
46 if typeName != "int32" {
47 return encoderOfType(ctx, reflect2.TypeOfPtr((*int32)(nil)).Elem())
48 }
49 return &int32Codec{}
50 case reflect.Int64:
51 if typeName != "int64" {
52 return encoderOfType(ctx, reflect2.TypeOfPtr((*int64)(nil)).Elem())
53 }
54 return &int64Codec{}
55 case reflect.Uint:
56 if typeName != "uint" {
57 return encoderOfType(ctx, reflect2.TypeOfPtr((*uint)(nil)).Elem())
58 }
59 if strconv.IntSize == 32 {
60 return &uint32Codec{}
61 }
62 return &uint64Codec{}
63 case reflect.Uint8:
64 if typeName != "uint8" {
65 return encoderOfType(ctx, reflect2.TypeOfPtr((*uint8)(nil)).Elem())
66 }
67 return &uint8Codec{}
68 case reflect.Uint16:
69 if typeName != "uint16" {
70 return encoderOfType(ctx, reflect2.TypeOfPtr((*uint16)(nil)).Elem())
71 }
72 return &uint16Codec{}
73 case reflect.Uint32:
74 if typeName != "uint32" {
75 return encoderOfType(ctx, reflect2.TypeOfPtr((*uint32)(nil)).Elem())
76 }
77 return &uint32Codec{}
78 case reflect.Uintptr:
79 if typeName != "uintptr" {
80 return encoderOfType(ctx, reflect2.TypeOfPtr((*uintptr)(nil)).Elem())
81 }
82 if ptrSize == 32 {
83 return &uint32Codec{}
84 }
85 return &uint64Codec{}
86 case reflect.Uint64:
87 if typeName != "uint64" {
88 return encoderOfType(ctx, reflect2.TypeOfPtr((*uint64)(nil)).Elem())
89 }
90 return &uint64Codec{}
91 case reflect.Float32:
92 if typeName != "float32" {
93 return encoderOfType(ctx, reflect2.TypeOfPtr((*float32)(nil)).Elem())
94 }
95 return &float32Codec{}
96 case reflect.Float64:
97 if typeName != "float64" {
98 return encoderOfType(ctx, reflect2.TypeOfPtr((*float64)(nil)).Elem())
99 }
100 return &float64Codec{}
101 case reflect.Bool:
102 if typeName != "bool" {
103 return encoderOfType(ctx, reflect2.TypeOfPtr((*bool)(nil)).Elem())
104 }
105 return &boolCodec{}
106 }
107 return nil
108}
109
110func createDecoderOfNative(ctx *ctx, typ reflect2.Type) ValDecoder {
111 if typ.Kind() == reflect.Slice && typ.(reflect2.SliceType).Elem().Kind() == reflect.Uint8 {
112 sliceDecoder := decoderOfSlice(ctx, typ)
113 return &base64Codec{sliceDecoder: sliceDecoder}
114 }
115 typeName := typ.String()
116 switch typ.Kind() {
117 case reflect.String:
118 if typeName != "string" {
119 return decoderOfType(ctx, reflect2.TypeOfPtr((*string)(nil)).Elem())
120 }
121 return &stringCodec{}
122 case reflect.Int:
123 if typeName != "int" {
124 return decoderOfType(ctx, reflect2.TypeOfPtr((*int)(nil)).Elem())
125 }
126 if strconv.IntSize == 32 {
127 return &int32Codec{}
128 }
129 return &int64Codec{}
130 case reflect.Int8:
131 if typeName != "int8" {
132 return decoderOfType(ctx, reflect2.TypeOfPtr((*int8)(nil)).Elem())
133 }
134 return &int8Codec{}
135 case reflect.Int16:
136 if typeName != "int16" {
137 return decoderOfType(ctx, reflect2.TypeOfPtr((*int16)(nil)).Elem())
138 }
139 return &int16Codec{}
140 case reflect.Int32:
141 if typeName != "int32" {
142 return decoderOfType(ctx, reflect2.TypeOfPtr((*int32)(nil)).Elem())
143 }
144 return &int32Codec{}
145 case reflect.Int64:
146 if typeName != "int64" {
147 return decoderOfType(ctx, reflect2.TypeOfPtr((*int64)(nil)).Elem())
148 }
149 return &int64Codec{}
150 case reflect.Uint:
151 if typeName != "uint" {
152 return decoderOfType(ctx, reflect2.TypeOfPtr((*uint)(nil)).Elem())
153 }
154 if strconv.IntSize == 32 {
155 return &uint32Codec{}
156 }
157 return &uint64Codec{}
158 case reflect.Uint8:
159 if typeName != "uint8" {
160 return decoderOfType(ctx, reflect2.TypeOfPtr((*uint8)(nil)).Elem())
161 }
162 return &uint8Codec{}
163 case reflect.Uint16:
164 if typeName != "uint16" {
165 return decoderOfType(ctx, reflect2.TypeOfPtr((*uint16)(nil)).Elem())
166 }
167 return &uint16Codec{}
168 case reflect.Uint32:
169 if typeName != "uint32" {
170 return decoderOfType(ctx, reflect2.TypeOfPtr((*uint32)(nil)).Elem())
171 }
172 return &uint32Codec{}
173 case reflect.Uintptr:
174 if typeName != "uintptr" {
175 return decoderOfType(ctx, reflect2.TypeOfPtr((*uintptr)(nil)).Elem())
176 }
177 if ptrSize == 32 {
178 return &uint32Codec{}
179 }
180 return &uint64Codec{}
181 case reflect.Uint64:
182 if typeName != "uint64" {
183 return decoderOfType(ctx, reflect2.TypeOfPtr((*uint64)(nil)).Elem())
184 }
185 return &uint64Codec{}
186 case reflect.Float32:
187 if typeName != "float32" {
188 return decoderOfType(ctx, reflect2.TypeOfPtr((*float32)(nil)).Elem())
189 }
190 return &float32Codec{}
191 case reflect.Float64:
192 if typeName != "float64" {
193 return decoderOfType(ctx, reflect2.TypeOfPtr((*float64)(nil)).Elem())
194 }
195 return &float64Codec{}
196 case reflect.Bool:
197 if typeName != "bool" {
198 return decoderOfType(ctx, reflect2.TypeOfPtr((*bool)(nil)).Elem())
199 }
200 return &boolCodec{}
201 }
202 return nil
203}
204
205type stringCodec struct {
206}
207
208func (codec *stringCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
209 *((*string)(ptr)) = iter.ReadString()
210}
211
212func (codec *stringCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
213 str := *((*string)(ptr))
214 stream.WriteString(str)
215}
216
217func (codec *stringCodec) IsEmpty(ptr unsafe.Pointer) bool {
218 return *((*string)(ptr)) == ""
219}
220
221type int8Codec struct {
222}
223
224func (codec *int8Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
225 if !iter.ReadNil() {
226 *((*int8)(ptr)) = iter.ReadInt8()
227 }
228}
229
230func (codec *int8Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
231 stream.WriteInt8(*((*int8)(ptr)))
232}
233
234func (codec *int8Codec) IsEmpty(ptr unsafe.Pointer) bool {
235 return *((*int8)(ptr)) == 0
236}
237
238type int16Codec struct {
239}
240
241func (codec *int16Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
242 if !iter.ReadNil() {
243 *((*int16)(ptr)) = iter.ReadInt16()
244 }
245}
246
247func (codec *int16Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
248 stream.WriteInt16(*((*int16)(ptr)))
249}
250
251func (codec *int16Codec) IsEmpty(ptr unsafe.Pointer) bool {
252 return *((*int16)(ptr)) == 0
253}
254
255type int32Codec struct {
256}
257
258func (codec *int32Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
259 if !iter.ReadNil() {
260 *((*int32)(ptr)) = iter.ReadInt32()
261 }
262}
263
264func (codec *int32Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
265 stream.WriteInt32(*((*int32)(ptr)))
266}
267
268func (codec *int32Codec) IsEmpty(ptr unsafe.Pointer) bool {
269 return *((*int32)(ptr)) == 0
270}
271
272type int64Codec struct {
273}
274
275func (codec *int64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
276 if !iter.ReadNil() {
277 *((*int64)(ptr)) = iter.ReadInt64()
278 }
279}
280
281func (codec *int64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
282 stream.WriteInt64(*((*int64)(ptr)))
283}
284
285func (codec *int64Codec) IsEmpty(ptr unsafe.Pointer) bool {
286 return *((*int64)(ptr)) == 0
287}
288
289type uint8Codec struct {
290}
291
292func (codec *uint8Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
293 if !iter.ReadNil() {
294 *((*uint8)(ptr)) = iter.ReadUint8()
295 }
296}
297
298func (codec *uint8Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
299 stream.WriteUint8(*((*uint8)(ptr)))
300}
301
302func (codec *uint8Codec) IsEmpty(ptr unsafe.Pointer) bool {
303 return *((*uint8)(ptr)) == 0
304}
305
306type uint16Codec struct {
307}
308
309func (codec *uint16Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
310 if !iter.ReadNil() {
311 *((*uint16)(ptr)) = iter.ReadUint16()
312 }
313}
314
315func (codec *uint16Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
316 stream.WriteUint16(*((*uint16)(ptr)))
317}
318
319func (codec *uint16Codec) IsEmpty(ptr unsafe.Pointer) bool {
320 return *((*uint16)(ptr)) == 0
321}
322
323type uint32Codec struct {
324}
325
326func (codec *uint32Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
327 if !iter.ReadNil() {
328 *((*uint32)(ptr)) = iter.ReadUint32()
329 }
330}
331
332func (codec *uint32Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
333 stream.WriteUint32(*((*uint32)(ptr)))
334}
335
336func (codec *uint32Codec) IsEmpty(ptr unsafe.Pointer) bool {
337 return *((*uint32)(ptr)) == 0
338}
339
340type uint64Codec struct {
341}
342
343func (codec *uint64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
344 if !iter.ReadNil() {
345 *((*uint64)(ptr)) = iter.ReadUint64()
346 }
347}
348
349func (codec *uint64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
350 stream.WriteUint64(*((*uint64)(ptr)))
351}
352
353func (codec *uint64Codec) IsEmpty(ptr unsafe.Pointer) bool {
354 return *((*uint64)(ptr)) == 0
355}
356
357type float32Codec struct {
358}
359
360func (codec *float32Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
361 if !iter.ReadNil() {
362 *((*float32)(ptr)) = iter.ReadFloat32()
363 }
364}
365
366func (codec *float32Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
367 stream.WriteFloat32(*((*float32)(ptr)))
368}
369
370func (codec *float32Codec) IsEmpty(ptr unsafe.Pointer) bool {
371 return *((*float32)(ptr)) == 0
372}
373
374type float64Codec struct {
375}
376
377func (codec *float64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
378 if !iter.ReadNil() {
379 *((*float64)(ptr)) = iter.ReadFloat64()
380 }
381}
382
383func (codec *float64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
384 stream.WriteFloat64(*((*float64)(ptr)))
385}
386
387func (codec *float64Codec) IsEmpty(ptr unsafe.Pointer) bool {
388 return *((*float64)(ptr)) == 0
389}
390
391type boolCodec struct {
392}
393
394func (codec *boolCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
395 if !iter.ReadNil() {
396 *((*bool)(ptr)) = iter.ReadBool()
397 }
398}
399
400func (codec *boolCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
401 stream.WriteBool(*((*bool)(ptr)))
402}
403
404func (codec *boolCodec) IsEmpty(ptr unsafe.Pointer) bool {
405 return !(*((*bool)(ptr)))
406}
407
408type base64Codec struct {
409 sliceType *reflect2.UnsafeSliceType
410 sliceDecoder ValDecoder
411}
412
413func (codec *base64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
414 if iter.ReadNil() {
415 codec.sliceType.UnsafeSetNil(ptr)
416 return
417 }
418 switch iter.WhatIsNext() {
419 case StringValue:
420 src := iter.ReadString()
421 dst, err := base64.StdEncoding.DecodeString(src)
422 if err != nil {
423 iter.ReportError("decode base64", err.Error())
424 } else {
425 codec.sliceType.UnsafeSet(ptr, unsafe.Pointer(&dst))
426 }
427 case ArrayValue:
428 codec.sliceDecoder.Decode(ptr, iter)
429 default:
430 iter.ReportError("base64Codec", "invalid input")
431 }
432}
433
434func (codec *base64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
435 if codec.sliceType.UnsafeIsNil(ptr) {
436 stream.WriteNil()
437 return
438 }
439 src := *((*[]byte)(ptr))
440 encoding := base64.StdEncoding
441 stream.writeByte('"')
442 if len(src) != 0 {
443 size := encoding.EncodedLen(len(src))
444 buf := make([]byte, size)
445 encoding.Encode(buf, src)
446 stream.buf = append(stream.buf, buf...)
447 }
448 stream.writeByte('"')
449}
450
451func (codec *base64Codec) IsEmpty(ptr unsafe.Pointer) bool {
452 return len(*((*[]byte)(ptr))) == 0
453}
diff --git a/vendor/github.com/json-iterator/go/reflect_optional.go b/vendor/github.com/json-iterator/go/reflect_optional.go
deleted file mode 100644
index fa71f47..0000000
--- a/vendor/github.com/json-iterator/go/reflect_optional.go
+++ /dev/null
@@ -1,129 +0,0 @@
1package jsoniter
2
3import (
4 "github.com/modern-go/reflect2"
5 "unsafe"
6)
7
8func decoderOfOptional(ctx *ctx, typ reflect2.Type) ValDecoder {
9 ptrType := typ.(*reflect2.UnsafePtrType)
10 elemType := ptrType.Elem()
11 decoder := decoderOfType(ctx, elemType)
12 return &OptionalDecoder{elemType, decoder}
13}
14
15func encoderOfOptional(ctx *ctx, typ reflect2.Type) ValEncoder {
16 ptrType := typ.(*reflect2.UnsafePtrType)
17 elemType := ptrType.Elem()
18 elemEncoder := encoderOfType(ctx, elemType)
19 encoder := &OptionalEncoder{elemEncoder}
20 return encoder
21}
22
23type OptionalDecoder struct {
24 ValueType reflect2.Type
25 ValueDecoder ValDecoder
26}
27
28func (decoder *OptionalDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
29 if iter.ReadNil() {
30 *((*unsafe.Pointer)(ptr)) = nil
31 } else {
32 if *((*unsafe.Pointer)(ptr)) == nil {
33 //pointer to null, we have to allocate memory to hold the value
34 newPtr := decoder.ValueType.UnsafeNew()
35 decoder.ValueDecoder.Decode(newPtr, iter)
36 *((*unsafe.Pointer)(ptr)) = newPtr
37 } else {
38 //reuse existing instance
39 decoder.ValueDecoder.Decode(*((*unsafe.Pointer)(ptr)), iter)
40 }
41 }
42}
43
44type dereferenceDecoder struct {
45 // only to deference a pointer
46 valueType reflect2.Type
47 valueDecoder ValDecoder
48}
49
50func (decoder *dereferenceDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
51 if *((*unsafe.Pointer)(ptr)) == nil {
52 //pointer to null, we have to allocate memory to hold the value
53 newPtr := decoder.valueType.UnsafeNew()
54 decoder.valueDecoder.Decode(newPtr, iter)
55 *((*unsafe.Pointer)(ptr)) = newPtr
56 } else {
57 //reuse existing instance
58 decoder.valueDecoder.Decode(*((*unsafe.Pointer)(ptr)), iter)
59 }
60}
61
62type OptionalEncoder struct {
63 ValueEncoder ValEncoder
64}
65
66func (encoder *OptionalEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
67 if *((*unsafe.Pointer)(ptr)) == nil {
68 stream.WriteNil()
69 } else {
70 encoder.ValueEncoder.Encode(*((*unsafe.Pointer)(ptr)), stream)
71 }
72}
73
74func (encoder *OptionalEncoder) IsEmpty(ptr unsafe.Pointer) bool {
75 return *((*unsafe.Pointer)(ptr)) == nil
76}
77
78type dereferenceEncoder struct {
79 ValueEncoder ValEncoder
80}
81
82func (encoder *dereferenceEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
83 if *((*unsafe.Pointer)(ptr)) == nil {
84 stream.WriteNil()
85 } else {
86 encoder.ValueEncoder.Encode(*((*unsafe.Pointer)(ptr)), stream)
87 }
88}
89
90func (encoder *dereferenceEncoder) IsEmpty(ptr unsafe.Pointer) bool {
91 dePtr := *((*unsafe.Pointer)(ptr))
92 if dePtr == nil {
93 return true
94 }
95 return encoder.ValueEncoder.IsEmpty(dePtr)
96}
97
98func (encoder *dereferenceEncoder) IsEmbeddedPtrNil(ptr unsafe.Pointer) bool {
99 deReferenced := *((*unsafe.Pointer)(ptr))
100 if deReferenced == nil {
101 return true
102 }
103 isEmbeddedPtrNil, converted := encoder.ValueEncoder.(IsEmbeddedPtrNil)
104 if !converted {
105 return false
106 }
107 fieldPtr := unsafe.Pointer(deReferenced)
108 return isEmbeddedPtrNil.IsEmbeddedPtrNil(fieldPtr)
109}
110
111type referenceEncoder struct {
112 encoder ValEncoder
113}
114
115func (encoder *referenceEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
116 encoder.encoder.Encode(unsafe.Pointer(&ptr), stream)
117}
118
119func (encoder *referenceEncoder) IsEmpty(ptr unsafe.Pointer) bool {
120 return encoder.encoder.IsEmpty(unsafe.Pointer(&ptr))
121}
122
123type referenceDecoder struct {
124 decoder ValDecoder
125}
126
127func (decoder *referenceDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
128 decoder.decoder.Decode(unsafe.Pointer(&ptr), iter)
129}
diff --git a/vendor/github.com/json-iterator/go/reflect_slice.go b/vendor/github.com/json-iterator/go/reflect_slice.go
deleted file mode 100644
index 9441d79..0000000
--- a/vendor/github.com/json-iterator/go/reflect_slice.go
+++ /dev/null
@@ -1,99 +0,0 @@
1package jsoniter
2
3import (
4 "fmt"
5 "github.com/modern-go/reflect2"
6 "io"
7 "unsafe"
8)
9
10func decoderOfSlice(ctx *ctx, typ reflect2.Type) ValDecoder {
11 sliceType := typ.(*reflect2.UnsafeSliceType)
12 decoder := decoderOfType(ctx.append("[sliceElem]"), sliceType.Elem())
13 return &sliceDecoder{sliceType, decoder}
14}
15
16func encoderOfSlice(ctx *ctx, typ reflect2.Type) ValEncoder {
17 sliceType := typ.(*reflect2.UnsafeSliceType)
18 encoder := encoderOfType(ctx.append("[sliceElem]"), sliceType.Elem())
19 return &sliceEncoder{sliceType, encoder}
20}
21
22type sliceEncoder struct {
23 sliceType *reflect2.UnsafeSliceType
24 elemEncoder ValEncoder
25}
26
27func (encoder *sliceEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
28 if encoder.sliceType.UnsafeIsNil(ptr) {
29 stream.WriteNil()
30 return
31 }
32 length := encoder.sliceType.UnsafeLengthOf(ptr)
33 if length == 0 {
34 stream.WriteEmptyArray()
35 return
36 }
37 stream.WriteArrayStart()
38 encoder.elemEncoder.Encode(encoder.sliceType.UnsafeGetIndex(ptr, 0), stream)
39 for i := 1; i < length; i++ {
40 stream.WriteMore()
41 elemPtr := encoder.sliceType.UnsafeGetIndex(ptr, i)
42 encoder.elemEncoder.Encode(elemPtr, stream)
43 }
44 stream.WriteArrayEnd()
45 if stream.Error != nil && stream.Error != io.EOF {
46 stream.Error = fmt.Errorf("%v: %s", encoder.sliceType, stream.Error.Error())
47 }
48}
49
50func (encoder *sliceEncoder) IsEmpty(ptr unsafe.Pointer) bool {
51 return encoder.sliceType.UnsafeLengthOf(ptr) == 0
52}
53
54type sliceDecoder struct {
55 sliceType *reflect2.UnsafeSliceType
56 elemDecoder ValDecoder
57}
58
59func (decoder *sliceDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
60 decoder.doDecode(ptr, iter)
61 if iter.Error != nil && iter.Error != io.EOF {
62 iter.Error = fmt.Errorf("%v: %s", decoder.sliceType, iter.Error.Error())
63 }
64}
65
66func (decoder *sliceDecoder) doDecode(ptr unsafe.Pointer, iter *Iterator) {
67 c := iter.nextToken()
68 sliceType := decoder.sliceType
69 if c == 'n' {
70 iter.skipThreeBytes('u', 'l', 'l')
71 sliceType.UnsafeSetNil(ptr)
72 return
73 }
74 if c != '[' {
75 iter.ReportError("decode slice", "expect [ or n, but found "+string([]byte{c}))
76 return
77 }
78 c = iter.nextToken()
79 if c == ']' {
80 sliceType.UnsafeSet(ptr, sliceType.UnsafeMakeSlice(0, 0))
81 return
82 }
83 iter.unreadByte()
84 sliceType.UnsafeGrow(ptr, 1)
85 elemPtr := sliceType.UnsafeGetIndex(ptr, 0)
86 decoder.elemDecoder.Decode(elemPtr, iter)
87 length := 1
88 for c = iter.nextToken(); c == ','; c = iter.nextToken() {
89 idx := length
90 length += 1
91 sliceType.UnsafeGrow(ptr, length)
92 elemPtr = sliceType.UnsafeGetIndex(ptr, idx)
93 decoder.elemDecoder.Decode(elemPtr, iter)
94 }
95 if c != ']' {
96 iter.ReportError("decode slice", "expect ], but found "+string([]byte{c}))
97 return
98 }
99}
diff --git a/vendor/github.com/json-iterator/go/reflect_struct_decoder.go b/vendor/github.com/json-iterator/go/reflect_struct_decoder.go
deleted file mode 100644
index 92ae912..0000000
--- a/vendor/github.com/json-iterator/go/reflect_struct_decoder.go
+++ /dev/null
@@ -1,1097 +0,0 @@
1package jsoniter
2
3import (
4 "fmt"
5 "io"
6 "strings"
7 "unsafe"
8
9 "github.com/modern-go/reflect2"
10)
11
12func decoderOfStruct(ctx *ctx, typ reflect2.Type) ValDecoder {
13 bindings := map[string]*Binding{}
14 structDescriptor := describeStruct(ctx, typ)
15 for _, binding := range structDescriptor.Fields {
16 for _, fromName := range binding.FromNames {
17 old := bindings[fromName]
18 if old == nil {
19 bindings[fromName] = binding
20 continue
21 }
22 ignoreOld, ignoreNew := resolveConflictBinding(ctx.frozenConfig, old, binding)
23 if ignoreOld {
24 delete(bindings, fromName)
25 }
26 if !ignoreNew {
27 bindings[fromName] = binding
28 }
29 }
30 }
31 fields := map[string]*structFieldDecoder{}
32 for k, binding := range bindings {
33 fields[k] = binding.Decoder.(*structFieldDecoder)
34 }
35
36 if !ctx.caseSensitive() {
37 for k, binding := range bindings {
38 if _, found := fields[strings.ToLower(k)]; !found {
39 fields[strings.ToLower(k)] = binding.Decoder.(*structFieldDecoder)
40 }
41 }
42 }
43
44 return createStructDecoder(ctx, typ, fields)
45}
46
47func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structFieldDecoder) ValDecoder {
48 if ctx.disallowUnknownFields {
49 return &generalStructDecoder{typ: typ, fields: fields, disallowUnknownFields: true}
50 }
51 knownHash := map[int64]struct{}{
52 0: {},
53 }
54
55 switch len(fields) {
56 case 0:
57 return &skipObjectDecoder{typ}
58 case 1:
59 for fieldName, fieldDecoder := range fields {
60 fieldHash := calcHash(fieldName, ctx.caseSensitive())
61 _, known := knownHash[fieldHash]
62 if known {
63 return &generalStructDecoder{typ, fields, false}
64 }
65 knownHash[fieldHash] = struct{}{}
66 return &oneFieldStructDecoder{typ, fieldHash, fieldDecoder}
67 }
68 case 2:
69 var fieldHash1 int64
70 var fieldHash2 int64
71 var fieldDecoder1 *structFieldDecoder
72 var fieldDecoder2 *structFieldDecoder
73 for fieldName, fieldDecoder := range fields {
74 fieldHash := calcHash(fieldName, ctx.caseSensitive())
75 _, known := knownHash[fieldHash]
76 if known {
77 return &generalStructDecoder{typ, fields, false}
78 }
79 knownHash[fieldHash] = struct{}{}
80 if fieldHash1 == 0 {
81 fieldHash1 = fieldHash
82 fieldDecoder1 = fieldDecoder
83 } else {
84 fieldHash2 = fieldHash
85 fieldDecoder2 = fieldDecoder
86 }
87 }
88 return &twoFieldsStructDecoder{typ, fieldHash1, fieldDecoder1, fieldHash2, fieldDecoder2}
89 case 3:
90 var fieldName1 int64
91 var fieldName2 int64
92 var fieldName3 int64
93 var fieldDecoder1 *structFieldDecoder
94 var fieldDecoder2 *structFieldDecoder
95 var fieldDecoder3 *structFieldDecoder
96 for fieldName, fieldDecoder := range fields {
97 fieldHash := calcHash(fieldName, ctx.caseSensitive())
98 _, known := knownHash[fieldHash]
99 if known {
100 return &generalStructDecoder{typ, fields, false}
101 }
102 knownHash[fieldHash] = struct{}{}
103 if fieldName1 == 0 {
104 fieldName1 = fieldHash
105 fieldDecoder1 = fieldDecoder
106 } else if fieldName2 == 0 {
107 fieldName2 = fieldHash
108 fieldDecoder2 = fieldDecoder
109 } else {
110 fieldName3 = fieldHash
111 fieldDecoder3 = fieldDecoder
112 }
113 }
114 return &threeFieldsStructDecoder{typ,
115 fieldName1, fieldDecoder1,
116 fieldName2, fieldDecoder2,
117 fieldName3, fieldDecoder3}
118 case 4:
119 var fieldName1 int64
120 var fieldName2 int64
121 var fieldName3 int64
122 var fieldName4 int64
123 var fieldDecoder1 *structFieldDecoder
124 var fieldDecoder2 *structFieldDecoder
125 var fieldDecoder3 *structFieldDecoder
126 var fieldDecoder4 *structFieldDecoder
127 for fieldName, fieldDecoder := range fields {
128 fieldHash := calcHash(fieldName, ctx.caseSensitive())
129 _, known := knownHash[fieldHash]
130 if known {
131 return &generalStructDecoder{typ, fields, false}
132 }
133 knownHash[fieldHash] = struct{}{}
134 if fieldName1 == 0 {
135 fieldName1 = fieldHash
136 fieldDecoder1 = fieldDecoder
137 } else if fieldName2 == 0 {
138 fieldName2 = fieldHash
139 fieldDecoder2 = fieldDecoder
140 } else if fieldName3 == 0 {
141 fieldName3 = fieldHash
142 fieldDecoder3 = fieldDecoder
143 } else {
144 fieldName4 = fieldHash
145 fieldDecoder4 = fieldDecoder
146 }
147 }
148 return &fourFieldsStructDecoder{typ,
149 fieldName1, fieldDecoder1,
150 fieldName2, fieldDecoder2,
151 fieldName3, fieldDecoder3,
152 fieldName4, fieldDecoder4}
153 case 5:
154 var fieldName1 int64
155 var fieldName2 int64
156 var fieldName3 int64
157 var fieldName4 int64
158 var fieldName5 int64
159 var fieldDecoder1 *structFieldDecoder
160 var fieldDecoder2 *structFieldDecoder
161 var fieldDecoder3 *structFieldDecoder
162 var fieldDecoder4 *structFieldDecoder
163 var fieldDecoder5 *structFieldDecoder
164 for fieldName, fieldDecoder := range fields {
165 fieldHash := calcHash(fieldName, ctx.caseSensitive())
166 _, known := knownHash[fieldHash]
167 if known {
168 return &generalStructDecoder{typ, fields, false}
169 }
170 knownHash[fieldHash] = struct{}{}
171 if fieldName1 == 0 {
172 fieldName1 = fieldHash
173 fieldDecoder1 = fieldDecoder
174 } else if fieldName2 == 0 {
175 fieldName2 = fieldHash
176 fieldDecoder2 = fieldDecoder
177 } else if fieldName3 == 0 {
178 fieldName3 = fieldHash
179 fieldDecoder3 = fieldDecoder
180 } else if fieldName4 == 0 {
181 fieldName4 = fieldHash
182 fieldDecoder4 = fieldDecoder
183 } else {
184 fieldName5 = fieldHash
185 fieldDecoder5 = fieldDecoder
186 }
187 }
188 return &fiveFieldsStructDecoder{typ,
189 fieldName1, fieldDecoder1,
190 fieldName2, fieldDecoder2,
191 fieldName3, fieldDecoder3,
192 fieldName4, fieldDecoder4,
193 fieldName5, fieldDecoder5}
194 case 6:
195 var fieldName1 int64
196 var fieldName2 int64
197 var fieldName3 int64
198 var fieldName4 int64
199 var fieldName5 int64
200 var fieldName6 int64
201 var fieldDecoder1 *structFieldDecoder
202 var fieldDecoder2 *structFieldDecoder
203 var fieldDecoder3 *structFieldDecoder
204 var fieldDecoder4 *structFieldDecoder
205 var fieldDecoder5 *structFieldDecoder
206 var fieldDecoder6 *structFieldDecoder
207 for fieldName, fieldDecoder := range fields {
208 fieldHash := calcHash(fieldName, ctx.caseSensitive())
209 _, known := knownHash[fieldHash]
210 if known {
211 return &generalStructDecoder{typ, fields, false}
212 }
213 knownHash[fieldHash] = struct{}{}
214 if fieldName1 == 0 {
215 fieldName1 = fieldHash
216 fieldDecoder1 = fieldDecoder
217 } else if fieldName2 == 0 {
218 fieldName2 = fieldHash
219 fieldDecoder2 = fieldDecoder
220 } else if fieldName3 == 0 {
221 fieldName3 = fieldHash
222 fieldDecoder3 = fieldDecoder
223 } else if fieldName4 == 0 {
224 fieldName4 = fieldHash
225 fieldDecoder4 = fieldDecoder
226 } else if fieldName5 == 0 {
227 fieldName5 = fieldHash
228 fieldDecoder5 = fieldDecoder
229 } else {
230 fieldName6 = fieldHash
231 fieldDecoder6 = fieldDecoder
232 }
233 }
234 return &sixFieldsStructDecoder{typ,
235 fieldName1, fieldDecoder1,
236 fieldName2, fieldDecoder2,
237 fieldName3, fieldDecoder3,
238 fieldName4, fieldDecoder4,
239 fieldName5, fieldDecoder5,
240 fieldName6, fieldDecoder6}
241 case 7:
242 var fieldName1 int64
243 var fieldName2 int64
244 var fieldName3 int64
245 var fieldName4 int64
246 var fieldName5 int64
247 var fieldName6 int64
248 var fieldName7 int64
249 var fieldDecoder1 *structFieldDecoder
250 var fieldDecoder2 *structFieldDecoder
251 var fieldDecoder3 *structFieldDecoder
252 var fieldDecoder4 *structFieldDecoder
253 var fieldDecoder5 *structFieldDecoder
254 var fieldDecoder6 *structFieldDecoder
255 var fieldDecoder7 *structFieldDecoder
256 for fieldName, fieldDecoder := range fields {
257 fieldHash := calcHash(fieldName, ctx.caseSensitive())
258 _, known := knownHash[fieldHash]
259 if known {
260 return &generalStructDecoder{typ, fields, false}
261 }
262 knownHash[fieldHash] = struct{}{}
263 if fieldName1 == 0 {
264 fieldName1 = fieldHash
265 fieldDecoder1 = fieldDecoder
266 } else if fieldName2 == 0 {
267 fieldName2 = fieldHash
268 fieldDecoder2 = fieldDecoder
269 } else if fieldName3 == 0 {
270 fieldName3 = fieldHash
271 fieldDecoder3 = fieldDecoder
272 } else if fieldName4 == 0 {
273 fieldName4 = fieldHash
274 fieldDecoder4 = fieldDecoder
275 } else if fieldName5 == 0 {
276 fieldName5 = fieldHash
277 fieldDecoder5 = fieldDecoder
278 } else if fieldName6 == 0 {
279 fieldName6 = fieldHash
280 fieldDecoder6 = fieldDecoder
281 } else {
282 fieldName7 = fieldHash
283 fieldDecoder7 = fieldDecoder
284 }
285 }
286 return &sevenFieldsStructDecoder{typ,
287 fieldName1, fieldDecoder1,
288 fieldName2, fieldDecoder2,
289 fieldName3, fieldDecoder3,
290 fieldName4, fieldDecoder4,
291 fieldName5, fieldDecoder5,
292 fieldName6, fieldDecoder6,
293 fieldName7, fieldDecoder7}
294 case 8:
295 var fieldName1 int64
296 var fieldName2 int64
297 var fieldName3 int64
298 var fieldName4 int64
299 var fieldName5 int64
300 var fieldName6 int64
301 var fieldName7 int64
302 var fieldName8 int64
303 var fieldDecoder1 *structFieldDecoder
304 var fieldDecoder2 *structFieldDecoder
305 var fieldDecoder3 *structFieldDecoder
306 var fieldDecoder4 *structFieldDecoder
307 var fieldDecoder5 *structFieldDecoder
308 var fieldDecoder6 *structFieldDecoder
309 var fieldDecoder7 *structFieldDecoder
310 var fieldDecoder8 *structFieldDecoder
311 for fieldName, fieldDecoder := range fields {
312 fieldHash := calcHash(fieldName, ctx.caseSensitive())
313 _, known := knownHash[fieldHash]
314 if known {
315 return &generalStructDecoder{typ, fields, false}
316 }
317 knownHash[fieldHash] = struct{}{}
318 if fieldName1 == 0 {
319 fieldName1 = fieldHash
320 fieldDecoder1 = fieldDecoder
321 } else if fieldName2 == 0 {
322 fieldName2 = fieldHash
323 fieldDecoder2 = fieldDecoder
324 } else if fieldName3 == 0 {
325 fieldName3 = fieldHash
326 fieldDecoder3 = fieldDecoder
327 } else if fieldName4 == 0 {
328 fieldName4 = fieldHash
329 fieldDecoder4 = fieldDecoder
330 } else if fieldName5 == 0 {
331 fieldName5 = fieldHash
332 fieldDecoder5 = fieldDecoder
333 } else if fieldName6 == 0 {
334 fieldName6 = fieldHash
335 fieldDecoder6 = fieldDecoder
336 } else if fieldName7 == 0 {
337 fieldName7 = fieldHash
338 fieldDecoder7 = fieldDecoder
339 } else {
340 fieldName8 = fieldHash
341 fieldDecoder8 = fieldDecoder
342 }
343 }
344 return &eightFieldsStructDecoder{typ,
345 fieldName1, fieldDecoder1,
346 fieldName2, fieldDecoder2,
347 fieldName3, fieldDecoder3,
348 fieldName4, fieldDecoder4,
349 fieldName5, fieldDecoder5,
350 fieldName6, fieldDecoder6,
351 fieldName7, fieldDecoder7,
352 fieldName8, fieldDecoder8}
353 case 9:
354 var fieldName1 int64
355 var fieldName2 int64
356 var fieldName3 int64
357 var fieldName4 int64
358 var fieldName5 int64
359 var fieldName6 int64
360 var fieldName7 int64
361 var fieldName8 int64
362 var fieldName9 int64
363 var fieldDecoder1 *structFieldDecoder
364 var fieldDecoder2 *structFieldDecoder
365 var fieldDecoder3 *structFieldDecoder
366 var fieldDecoder4 *structFieldDecoder
367 var fieldDecoder5 *structFieldDecoder
368 var fieldDecoder6 *structFieldDecoder
369 var fieldDecoder7 *structFieldDecoder
370 var fieldDecoder8 *structFieldDecoder
371 var fieldDecoder9 *structFieldDecoder
372 for fieldName, fieldDecoder := range fields {
373 fieldHash := calcHash(fieldName, ctx.caseSensitive())
374 _, known := knownHash[fieldHash]
375 if known {
376 return &generalStructDecoder{typ, fields, false}
377 }
378 knownHash[fieldHash] = struct{}{}
379 if fieldName1 == 0 {
380 fieldName1 = fieldHash
381 fieldDecoder1 = fieldDecoder
382 } else if fieldName2 == 0 {
383 fieldName2 = fieldHash
384 fieldDecoder2 = fieldDecoder
385 } else if fieldName3 == 0 {
386 fieldName3 = fieldHash
387 fieldDecoder3 = fieldDecoder
388 } else if fieldName4 == 0 {
389 fieldName4 = fieldHash
390 fieldDecoder4 = fieldDecoder
391 } else if fieldName5 == 0 {
392 fieldName5 = fieldHash
393 fieldDecoder5 = fieldDecoder
394 } else if fieldName6 == 0 {
395 fieldName6 = fieldHash
396 fieldDecoder6 = fieldDecoder
397 } else if fieldName7 == 0 {
398 fieldName7 = fieldHash
399 fieldDecoder7 = fieldDecoder
400 } else if fieldName8 == 0 {
401 fieldName8 = fieldHash
402 fieldDecoder8 = fieldDecoder
403 } else {
404 fieldName9 = fieldHash
405 fieldDecoder9 = fieldDecoder
406 }
407 }
408 return &nineFieldsStructDecoder{typ,
409 fieldName1, fieldDecoder1,
410 fieldName2, fieldDecoder2,
411 fieldName3, fieldDecoder3,
412 fieldName4, fieldDecoder4,
413 fieldName5, fieldDecoder5,
414 fieldName6, fieldDecoder6,
415 fieldName7, fieldDecoder7,
416 fieldName8, fieldDecoder8,
417 fieldName9, fieldDecoder9}
418 case 10:
419 var fieldName1 int64
420 var fieldName2 int64
421 var fieldName3 int64
422 var fieldName4 int64
423 var fieldName5 int64
424 var fieldName6 int64
425 var fieldName7 int64
426 var fieldName8 int64
427 var fieldName9 int64
428 var fieldName10 int64
429 var fieldDecoder1 *structFieldDecoder
430 var fieldDecoder2 *structFieldDecoder
431 var fieldDecoder3 *structFieldDecoder
432 var fieldDecoder4 *structFieldDecoder
433 var fieldDecoder5 *structFieldDecoder
434 var fieldDecoder6 *structFieldDecoder
435 var fieldDecoder7 *structFieldDecoder
436 var fieldDecoder8 *structFieldDecoder
437 var fieldDecoder9 *structFieldDecoder
438 var fieldDecoder10 *structFieldDecoder
439 for fieldName, fieldDecoder := range fields {
440 fieldHash := calcHash(fieldName, ctx.caseSensitive())
441 _, known := knownHash[fieldHash]
442 if known {
443 return &generalStructDecoder{typ, fields, false}
444 }
445 knownHash[fieldHash] = struct{}{}
446 if fieldName1 == 0 {
447 fieldName1 = fieldHash
448 fieldDecoder1 = fieldDecoder
449 } else if fieldName2 == 0 {
450 fieldName2 = fieldHash
451 fieldDecoder2 = fieldDecoder
452 } else if fieldName3 == 0 {
453 fieldName3 = fieldHash
454 fieldDecoder3 = fieldDecoder
455 } else if fieldName4 == 0 {
456 fieldName4 = fieldHash
457 fieldDecoder4 = fieldDecoder
458 } else if fieldName5 == 0 {
459 fieldName5 = fieldHash
460 fieldDecoder5 = fieldDecoder
461 } else if fieldName6 == 0 {
462 fieldName6 = fieldHash
463 fieldDecoder6 = fieldDecoder
464 } else if fieldName7 == 0 {
465 fieldName7 = fieldHash
466 fieldDecoder7 = fieldDecoder
467 } else if fieldName8 == 0 {
468 fieldName8 = fieldHash
469 fieldDecoder8 = fieldDecoder
470 } else if fieldName9 == 0 {
471 fieldName9 = fieldHash
472 fieldDecoder9 = fieldDecoder
473 } else {
474 fieldName10 = fieldHash
475 fieldDecoder10 = fieldDecoder
476 }
477 }
478 return &tenFieldsStructDecoder{typ,
479 fieldName1, fieldDecoder1,
480 fieldName2, fieldDecoder2,
481 fieldName3, fieldDecoder3,
482 fieldName4, fieldDecoder4,
483 fieldName5, fieldDecoder5,
484 fieldName6, fieldDecoder6,
485 fieldName7, fieldDecoder7,
486 fieldName8, fieldDecoder8,
487 fieldName9, fieldDecoder9,
488 fieldName10, fieldDecoder10}
489 }
490 return &generalStructDecoder{typ, fields, false}
491}
492
493type generalStructDecoder struct {
494 typ reflect2.Type
495 fields map[string]*structFieldDecoder
496 disallowUnknownFields bool
497}
498
499func (decoder *generalStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
500 if !iter.readObjectStart() {
501 return
502 }
503 if !iter.incrementDepth() {
504 return
505 }
506 var c byte
507 for c = ','; c == ','; c = iter.nextToken() {
508 decoder.decodeOneField(ptr, iter)
509 }
510 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
511 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
512 }
513 if c != '}' {
514 iter.ReportError("struct Decode", `expect }, but found `+string([]byte{c}))
515 }
516 iter.decrementDepth()
517}
518
519func (decoder *generalStructDecoder) decodeOneField(ptr unsafe.Pointer, iter *Iterator) {
520 var field string
521 var fieldDecoder *structFieldDecoder
522 if iter.cfg.objectFieldMustBeSimpleString {
523 fieldBytes := iter.ReadStringAsSlice()
524 field = *(*string)(unsafe.Pointer(&fieldBytes))
525 fieldDecoder = decoder.fields[field]
526 if fieldDecoder == nil && !iter.cfg.caseSensitive {
527 fieldDecoder = decoder.fields[strings.ToLower(field)]
528 }
529 } else {
530 field = iter.ReadString()
531 fieldDecoder = decoder.fields[field]
532 if fieldDecoder == nil && !iter.cfg.caseSensitive {
533 fieldDecoder = decoder.fields[strings.ToLower(field)]
534 }
535 }
536 if fieldDecoder == nil {
537 if decoder.disallowUnknownFields {
538 msg := "found unknown field: " + field
539 iter.ReportError("ReadObject", msg)
540 }
541 c := iter.nextToken()
542 if c != ':' {
543 iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
544 }
545 iter.Skip()
546 return
547 }
548 c := iter.nextToken()
549 if c != ':' {
550 iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
551 }
552 fieldDecoder.Decode(ptr, iter)
553}
554
555type skipObjectDecoder struct {
556 typ reflect2.Type
557}
558
559func (decoder *skipObjectDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
560 valueType := iter.WhatIsNext()
561 if valueType != ObjectValue && valueType != NilValue {
562 iter.ReportError("skipObjectDecoder", "expect object or null")
563 return
564 }
565 iter.Skip()
566}
567
568type oneFieldStructDecoder struct {
569 typ reflect2.Type
570 fieldHash int64
571 fieldDecoder *structFieldDecoder
572}
573
574func (decoder *oneFieldStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
575 if !iter.readObjectStart() {
576 return
577 }
578 if !iter.incrementDepth() {
579 return
580 }
581 for {
582 if iter.readFieldHash() == decoder.fieldHash {
583 decoder.fieldDecoder.Decode(ptr, iter)
584 } else {
585 iter.Skip()
586 }
587 if iter.isObjectEnd() {
588 break
589 }
590 }
591 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
592 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
593 }
594 iter.decrementDepth()
595}
596
597type twoFieldsStructDecoder struct {
598 typ reflect2.Type
599 fieldHash1 int64
600 fieldDecoder1 *structFieldDecoder
601 fieldHash2 int64
602 fieldDecoder2 *structFieldDecoder
603}
604
605func (decoder *twoFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
606 if !iter.readObjectStart() {
607 return
608 }
609 if !iter.incrementDepth() {
610 return
611 }
612 for {
613 switch iter.readFieldHash() {
614 case decoder.fieldHash1:
615 decoder.fieldDecoder1.Decode(ptr, iter)
616 case decoder.fieldHash2:
617 decoder.fieldDecoder2.Decode(ptr, iter)
618 default:
619 iter.Skip()
620 }
621 if iter.isObjectEnd() {
622 break
623 }
624 }
625 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
626 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
627 }
628 iter.decrementDepth()
629}
630
631type threeFieldsStructDecoder struct {
632 typ reflect2.Type
633 fieldHash1 int64
634 fieldDecoder1 *structFieldDecoder
635 fieldHash2 int64
636 fieldDecoder2 *structFieldDecoder
637 fieldHash3 int64
638 fieldDecoder3 *structFieldDecoder
639}
640
641func (decoder *threeFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
642 if !iter.readObjectStart() {
643 return
644 }
645 if !iter.incrementDepth() {
646 return
647 }
648 for {
649 switch iter.readFieldHash() {
650 case decoder.fieldHash1:
651 decoder.fieldDecoder1.Decode(ptr, iter)
652 case decoder.fieldHash2:
653 decoder.fieldDecoder2.Decode(ptr, iter)
654 case decoder.fieldHash3:
655 decoder.fieldDecoder3.Decode(ptr, iter)
656 default:
657 iter.Skip()
658 }
659 if iter.isObjectEnd() {
660 break
661 }
662 }
663 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
664 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
665 }
666 iter.decrementDepth()
667}
668
669type fourFieldsStructDecoder struct {
670 typ reflect2.Type
671 fieldHash1 int64
672 fieldDecoder1 *structFieldDecoder
673 fieldHash2 int64
674 fieldDecoder2 *structFieldDecoder
675 fieldHash3 int64
676 fieldDecoder3 *structFieldDecoder
677 fieldHash4 int64
678 fieldDecoder4 *structFieldDecoder
679}
680
681func (decoder *fourFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
682 if !iter.readObjectStart() {
683 return
684 }
685 if !iter.incrementDepth() {
686 return
687 }
688 for {
689 switch iter.readFieldHash() {
690 case decoder.fieldHash1:
691 decoder.fieldDecoder1.Decode(ptr, iter)
692 case decoder.fieldHash2:
693 decoder.fieldDecoder2.Decode(ptr, iter)
694 case decoder.fieldHash3:
695 decoder.fieldDecoder3.Decode(ptr, iter)
696 case decoder.fieldHash4:
697 decoder.fieldDecoder4.Decode(ptr, iter)
698 default:
699 iter.Skip()
700 }
701 if iter.isObjectEnd() {
702 break
703 }
704 }
705 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
706 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
707 }
708 iter.decrementDepth()
709}
710
711type fiveFieldsStructDecoder struct {
712 typ reflect2.Type
713 fieldHash1 int64
714 fieldDecoder1 *structFieldDecoder
715 fieldHash2 int64
716 fieldDecoder2 *structFieldDecoder
717 fieldHash3 int64
718 fieldDecoder3 *structFieldDecoder
719 fieldHash4 int64
720 fieldDecoder4 *structFieldDecoder
721 fieldHash5 int64
722 fieldDecoder5 *structFieldDecoder
723}
724
725func (decoder *fiveFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
726 if !iter.readObjectStart() {
727 return
728 }
729 if !iter.incrementDepth() {
730 return
731 }
732 for {
733 switch iter.readFieldHash() {
734 case decoder.fieldHash1:
735 decoder.fieldDecoder1.Decode(ptr, iter)
736 case decoder.fieldHash2:
737 decoder.fieldDecoder2.Decode(ptr, iter)
738 case decoder.fieldHash3:
739 decoder.fieldDecoder3.Decode(ptr, iter)
740 case decoder.fieldHash4:
741 decoder.fieldDecoder4.Decode(ptr, iter)
742 case decoder.fieldHash5:
743 decoder.fieldDecoder5.Decode(ptr, iter)
744 default:
745 iter.Skip()
746 }
747 if iter.isObjectEnd() {
748 break
749 }
750 }
751 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
752 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
753 }
754 iter.decrementDepth()
755}
756
757type sixFieldsStructDecoder struct {
758 typ reflect2.Type
759 fieldHash1 int64
760 fieldDecoder1 *structFieldDecoder
761 fieldHash2 int64
762 fieldDecoder2 *structFieldDecoder
763 fieldHash3 int64
764 fieldDecoder3 *structFieldDecoder
765 fieldHash4 int64
766 fieldDecoder4 *structFieldDecoder
767 fieldHash5 int64
768 fieldDecoder5 *structFieldDecoder
769 fieldHash6 int64
770 fieldDecoder6 *structFieldDecoder
771}
772
773func (decoder *sixFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
774 if !iter.readObjectStart() {
775 return
776 }
777 if !iter.incrementDepth() {
778 return
779 }
780 for {
781 switch iter.readFieldHash() {
782 case decoder.fieldHash1:
783 decoder.fieldDecoder1.Decode(ptr, iter)
784 case decoder.fieldHash2:
785 decoder.fieldDecoder2.Decode(ptr, iter)
786 case decoder.fieldHash3:
787 decoder.fieldDecoder3.Decode(ptr, iter)
788 case decoder.fieldHash4:
789 decoder.fieldDecoder4.Decode(ptr, iter)
790 case decoder.fieldHash5:
791 decoder.fieldDecoder5.Decode(ptr, iter)
792 case decoder.fieldHash6:
793 decoder.fieldDecoder6.Decode(ptr, iter)
794 default:
795 iter.Skip()
796 }
797 if iter.isObjectEnd() {
798 break
799 }
800 }
801 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
802 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
803 }
804 iter.decrementDepth()
805}
806
807type sevenFieldsStructDecoder struct {
808 typ reflect2.Type
809 fieldHash1 int64
810 fieldDecoder1 *structFieldDecoder
811 fieldHash2 int64
812 fieldDecoder2 *structFieldDecoder
813 fieldHash3 int64
814 fieldDecoder3 *structFieldDecoder
815 fieldHash4 int64
816 fieldDecoder4 *structFieldDecoder
817 fieldHash5 int64
818 fieldDecoder5 *structFieldDecoder
819 fieldHash6 int64
820 fieldDecoder6 *structFieldDecoder
821 fieldHash7 int64
822 fieldDecoder7 *structFieldDecoder
823}
824
825func (decoder *sevenFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
826 if !iter.readObjectStart() {
827 return
828 }
829 if !iter.incrementDepth() {
830 return
831 }
832 for {
833 switch iter.readFieldHash() {
834 case decoder.fieldHash1:
835 decoder.fieldDecoder1.Decode(ptr, iter)
836 case decoder.fieldHash2:
837 decoder.fieldDecoder2.Decode(ptr, iter)
838 case decoder.fieldHash3:
839 decoder.fieldDecoder3.Decode(ptr, iter)
840 case decoder.fieldHash4:
841 decoder.fieldDecoder4.Decode(ptr, iter)
842 case decoder.fieldHash5:
843 decoder.fieldDecoder5.Decode(ptr, iter)
844 case decoder.fieldHash6:
845 decoder.fieldDecoder6.Decode(ptr, iter)
846 case decoder.fieldHash7:
847 decoder.fieldDecoder7.Decode(ptr, iter)
848 default:
849 iter.Skip()
850 }
851 if iter.isObjectEnd() {
852 break
853 }
854 }
855 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
856 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
857 }
858 iter.decrementDepth()
859}
860
861type eightFieldsStructDecoder struct {
862 typ reflect2.Type
863 fieldHash1 int64
864 fieldDecoder1 *structFieldDecoder
865 fieldHash2 int64
866 fieldDecoder2 *structFieldDecoder
867 fieldHash3 int64
868 fieldDecoder3 *structFieldDecoder
869 fieldHash4 int64
870 fieldDecoder4 *structFieldDecoder
871 fieldHash5 int64
872 fieldDecoder5 *structFieldDecoder
873 fieldHash6 int64
874 fieldDecoder6 *structFieldDecoder
875 fieldHash7 int64
876 fieldDecoder7 *structFieldDecoder
877 fieldHash8 int64
878 fieldDecoder8 *structFieldDecoder
879}
880
881func (decoder *eightFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
882 if !iter.readObjectStart() {
883 return
884 }
885 if !iter.incrementDepth() {
886 return
887 }
888 for {
889 switch iter.readFieldHash() {
890 case decoder.fieldHash1:
891 decoder.fieldDecoder1.Decode(ptr, iter)
892 case decoder.fieldHash2:
893 decoder.fieldDecoder2.Decode(ptr, iter)
894 case decoder.fieldHash3:
895 decoder.fieldDecoder3.Decode(ptr, iter)
896 case decoder.fieldHash4:
897 decoder.fieldDecoder4.Decode(ptr, iter)
898 case decoder.fieldHash5:
899 decoder.fieldDecoder5.Decode(ptr, iter)
900 case decoder.fieldHash6:
901 decoder.fieldDecoder6.Decode(ptr, iter)
902 case decoder.fieldHash7:
903 decoder.fieldDecoder7.Decode(ptr, iter)
904 case decoder.fieldHash8:
905 decoder.fieldDecoder8.Decode(ptr, iter)
906 default:
907 iter.Skip()
908 }
909 if iter.isObjectEnd() {
910 break
911 }
912 }
913 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
914 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
915 }
916 iter.decrementDepth()
917}
918
919type nineFieldsStructDecoder struct {
920 typ reflect2.Type
921 fieldHash1 int64
922 fieldDecoder1 *structFieldDecoder
923 fieldHash2 int64
924 fieldDecoder2 *structFieldDecoder
925 fieldHash3 int64
926 fieldDecoder3 *structFieldDecoder
927 fieldHash4 int64
928 fieldDecoder4 *structFieldDecoder
929 fieldHash5 int64
930 fieldDecoder5 *structFieldDecoder
931 fieldHash6 int64
932 fieldDecoder6 *structFieldDecoder
933 fieldHash7 int64
934 fieldDecoder7 *structFieldDecoder
935 fieldHash8 int64
936 fieldDecoder8 *structFieldDecoder
937 fieldHash9 int64
938 fieldDecoder9 *structFieldDecoder
939}
940
941func (decoder *nineFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
942 if !iter.readObjectStart() {
943 return
944 }
945 if !iter.incrementDepth() {
946 return
947 }
948 for {
949 switch iter.readFieldHash() {
950 case decoder.fieldHash1:
951 decoder.fieldDecoder1.Decode(ptr, iter)
952 case decoder.fieldHash2:
953 decoder.fieldDecoder2.Decode(ptr, iter)
954 case decoder.fieldHash3:
955 decoder.fieldDecoder3.Decode(ptr, iter)
956 case decoder.fieldHash4:
957 decoder.fieldDecoder4.Decode(ptr, iter)
958 case decoder.fieldHash5:
959 decoder.fieldDecoder5.Decode(ptr, iter)
960 case decoder.fieldHash6:
961 decoder.fieldDecoder6.Decode(ptr, iter)
962 case decoder.fieldHash7:
963 decoder.fieldDecoder7.Decode(ptr, iter)
964 case decoder.fieldHash8:
965 decoder.fieldDecoder8.Decode(ptr, iter)
966 case decoder.fieldHash9:
967 decoder.fieldDecoder9.Decode(ptr, iter)
968 default:
969 iter.Skip()
970 }
971 if iter.isObjectEnd() {
972 break
973 }
974 }
975 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
976 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
977 }
978 iter.decrementDepth()
979}
980
981type tenFieldsStructDecoder struct {
982 typ reflect2.Type
983 fieldHash1 int64
984 fieldDecoder1 *structFieldDecoder
985 fieldHash2 int64
986 fieldDecoder2 *structFieldDecoder
987 fieldHash3 int64
988 fieldDecoder3 *structFieldDecoder
989 fieldHash4 int64
990 fieldDecoder4 *structFieldDecoder
991 fieldHash5 int64
992 fieldDecoder5 *structFieldDecoder
993 fieldHash6 int64
994 fieldDecoder6 *structFieldDecoder
995 fieldHash7 int64
996 fieldDecoder7 *structFieldDecoder
997 fieldHash8 int64
998 fieldDecoder8 *structFieldDecoder
999 fieldHash9 int64
1000 fieldDecoder9 *structFieldDecoder
1001 fieldHash10 int64
1002 fieldDecoder10 *structFieldDecoder
1003}
1004
1005func (decoder *tenFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
1006 if !iter.readObjectStart() {
1007 return
1008 }
1009 if !iter.incrementDepth() {
1010 return
1011 }
1012 for {
1013 switch iter.readFieldHash() {
1014 case decoder.fieldHash1:
1015 decoder.fieldDecoder1.Decode(ptr, iter)
1016 case decoder.fieldHash2:
1017 decoder.fieldDecoder2.Decode(ptr, iter)
1018 case decoder.fieldHash3:
1019 decoder.fieldDecoder3.Decode(ptr, iter)
1020 case decoder.fieldHash4:
1021 decoder.fieldDecoder4.Decode(ptr, iter)
1022 case decoder.fieldHash5:
1023 decoder.fieldDecoder5.Decode(ptr, iter)
1024 case decoder.fieldHash6:
1025 decoder.fieldDecoder6.Decode(ptr, iter)
1026 case decoder.fieldHash7:
1027 decoder.fieldDecoder7.Decode(ptr, iter)
1028 case decoder.fieldHash8:
1029 decoder.fieldDecoder8.Decode(ptr, iter)
1030 case decoder.fieldHash9:
1031 decoder.fieldDecoder9.Decode(ptr, iter)
1032 case decoder.fieldHash10:
1033 decoder.fieldDecoder10.Decode(ptr, iter)
1034 default:
1035 iter.Skip()
1036 }
1037 if iter.isObjectEnd() {
1038 break
1039 }
1040 }
1041 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
1042 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
1043 }
1044 iter.decrementDepth()
1045}
1046
1047type structFieldDecoder struct {
1048 field reflect2.StructField
1049 fieldDecoder ValDecoder
1050}
1051
1052func (decoder *structFieldDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
1053 fieldPtr := decoder.field.UnsafeGet(ptr)
1054 decoder.fieldDecoder.Decode(fieldPtr, iter)
1055 if iter.Error != nil && iter.Error != io.EOF {
1056 iter.Error = fmt.Errorf("%s: %s", decoder.field.Name(), iter.Error.Error())
1057 }
1058}
1059
1060type stringModeStringDecoder struct {
1061 elemDecoder ValDecoder
1062 cfg *frozenConfig
1063}
1064
1065func (decoder *stringModeStringDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
1066 decoder.elemDecoder.Decode(ptr, iter)
1067 str := *((*string)(ptr))
1068 tempIter := decoder.cfg.BorrowIterator([]byte(str))
1069 defer decoder.cfg.ReturnIterator(tempIter)
1070 *((*string)(ptr)) = tempIter.ReadString()
1071}
1072
1073type stringModeNumberDecoder struct {
1074 elemDecoder ValDecoder
1075}
1076
1077func (decoder *stringModeNumberDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
1078 if iter.WhatIsNext() == NilValue {
1079 decoder.elemDecoder.Decode(ptr, iter)
1080 return
1081 }
1082
1083 c := iter.nextToken()
1084 if c != '"' {
1085 iter.ReportError("stringModeNumberDecoder", `expect ", but found `+string([]byte{c}))
1086 return
1087 }
1088 decoder.elemDecoder.Decode(ptr, iter)
1089 if iter.Error != nil {
1090 return
1091 }
1092 c = iter.readByte()
1093 if c != '"' {
1094 iter.ReportError("stringModeNumberDecoder", `expect ", but found `+string([]byte{c}))
1095 return
1096 }
1097}
diff --git a/vendor/github.com/json-iterator/go/reflect_struct_encoder.go b/vendor/github.com/json-iterator/go/reflect_struct_encoder.go
deleted file mode 100644
index 152e3ef..0000000
--- a/vendor/github.com/json-iterator/go/reflect_struct_encoder.go
+++ /dev/null
@@ -1,211 +0,0 @@
1package jsoniter
2
3import (
4 "fmt"
5 "github.com/modern-go/reflect2"
6 "io"
7 "reflect"
8 "unsafe"
9)
10
11func encoderOfStruct(ctx *ctx, typ reflect2.Type) ValEncoder {
12 type bindingTo struct {
13 binding *Binding
14 toName string
15 ignored bool
16 }
17 orderedBindings := []*bindingTo{}
18 structDescriptor := describeStruct(ctx, typ)
19 for _, binding := range structDescriptor.Fields {
20 for _, toName := range binding.ToNames {
21 new := &bindingTo{
22 binding: binding,
23 toName: toName,
24 }
25 for _, old := range orderedBindings {
26 if old.toName != toName {
27 continue
28 }
29 old.ignored, new.ignored = resolveConflictBinding(ctx.frozenConfig, old.binding, new.binding)
30 }
31 orderedBindings = append(orderedBindings, new)
32 }
33 }
34 if len(orderedBindings) == 0 {
35 return &emptyStructEncoder{}
36 }
37 finalOrderedFields := []structFieldTo{}
38 for _, bindingTo := range orderedBindings {
39 if !bindingTo.ignored {
40 finalOrderedFields = append(finalOrderedFields, structFieldTo{
41 encoder: bindingTo.binding.Encoder.(*structFieldEncoder),
42 toName: bindingTo.toName,
43 })
44 }
45 }
46 return &structEncoder{typ, finalOrderedFields}
47}
48
49func createCheckIsEmpty(ctx *ctx, typ reflect2.Type) checkIsEmpty {
50 encoder := createEncoderOfNative(ctx, typ)
51 if encoder != nil {
52 return encoder
53 }
54 kind := typ.Kind()
55 switch kind {
56 case reflect.Interface:
57 return &dynamicEncoder{typ}
58 case reflect.Struct:
59 return &structEncoder{typ: typ}
60 case reflect.Array:
61 return &arrayEncoder{}
62 case reflect.Slice:
63 return &sliceEncoder{}
64 case reflect.Map:
65 return encoderOfMap(ctx, typ)
66 case reflect.Ptr:
67 return &OptionalEncoder{}
68 default:
69 return &lazyErrorEncoder{err: fmt.Errorf("unsupported type: %v", typ)}
70 }
71}
72
73func resolveConflictBinding(cfg *frozenConfig, old, new *Binding) (ignoreOld, ignoreNew bool) {
74 newTagged := new.Field.Tag().Get(cfg.getTagKey()) != ""
75 oldTagged := old.Field.Tag().Get(cfg.getTagKey()) != ""
76 if newTagged {
77 if oldTagged {
78 if len(old.levels) > len(new.levels) {
79 return true, false
80 } else if len(new.levels) > len(old.levels) {
81 return false, true
82 } else {
83 return true, true
84 }
85 } else {
86 return true, false
87 }
88 } else {
89 if oldTagged {
90 return true, false
91 }
92 if len(old.levels) > len(new.levels) {
93 return true, false
94 } else if len(new.levels) > len(old.levels) {
95 return false, true
96 } else {
97 return true, true
98 }
99 }
100}
101
102type structFieldEncoder struct {
103 field reflect2.StructField
104 fieldEncoder ValEncoder
105 omitempty bool
106}
107
108func (encoder *structFieldEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
109 fieldPtr := encoder.field.UnsafeGet(ptr)
110 encoder.fieldEncoder.Encode(fieldPtr, stream)
111 if stream.Error != nil && stream.Error != io.EOF {
112 stream.Error = fmt.Errorf("%s: %s", encoder.field.Name(), stream.Error.Error())
113 }
114}
115
116func (encoder *structFieldEncoder) IsEmpty(ptr unsafe.Pointer) bool {
117 fieldPtr := encoder.field.UnsafeGet(ptr)
118 return encoder.fieldEncoder.IsEmpty(fieldPtr)
119}
120
121func (encoder *structFieldEncoder) IsEmbeddedPtrNil(ptr unsafe.Pointer) bool {
122 isEmbeddedPtrNil, converted := encoder.fieldEncoder.(IsEmbeddedPtrNil)
123 if !converted {
124 return false
125 }
126 fieldPtr := encoder.field.UnsafeGet(ptr)
127 return isEmbeddedPtrNil.IsEmbeddedPtrNil(fieldPtr)
128}
129
130type IsEmbeddedPtrNil interface {
131 IsEmbeddedPtrNil(ptr unsafe.Pointer) bool
132}
133
134type structEncoder struct {
135 typ reflect2.Type
136 fields []structFieldTo
137}
138
139type structFieldTo struct {
140 encoder *structFieldEncoder
141 toName string
142}
143
144func (encoder *structEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
145 stream.WriteObjectStart()
146 isNotFirst := false
147 for _, field := range encoder.fields {
148 if field.encoder.omitempty && field.encoder.IsEmpty(ptr) {
149 continue
150 }
151 if field.encoder.IsEmbeddedPtrNil(ptr) {
152 continue
153 }
154 if isNotFirst {
155 stream.WriteMore()
156 }
157 stream.WriteObjectField(field.toName)
158 field.encoder.Encode(ptr, stream)
159 isNotFirst = true
160 }
161 stream.WriteObjectEnd()
162 if stream.Error != nil && stream.Error != io.EOF {
163 stream.Error = fmt.Errorf("%v.%s", encoder.typ, stream.Error.Error())
164 }
165}
166
167func (encoder *structEncoder) IsEmpty(ptr unsafe.Pointer) bool {
168 return false
169}
170
171type emptyStructEncoder struct {
172}
173
174func (encoder *emptyStructEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
175 stream.WriteEmptyObject()
176}
177
178func (encoder *emptyStructEncoder) IsEmpty(ptr unsafe.Pointer) bool {
179 return false
180}
181
182type stringModeNumberEncoder struct {
183 elemEncoder ValEncoder
184}
185
186func (encoder *stringModeNumberEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
187 stream.writeByte('"')
188 encoder.elemEncoder.Encode(ptr, stream)
189 stream.writeByte('"')
190}
191
192func (encoder *stringModeNumberEncoder) IsEmpty(ptr unsafe.Pointer) bool {
193 return encoder.elemEncoder.IsEmpty(ptr)
194}
195
196type stringModeStringEncoder struct {
197 elemEncoder ValEncoder
198 cfg *frozenConfig
199}
200
201func (encoder *stringModeStringEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
202 tempStream := encoder.cfg.BorrowStream(nil)
203 tempStream.Attachment = stream.Attachment
204 defer encoder.cfg.ReturnStream(tempStream)
205 encoder.elemEncoder.Encode(ptr, tempStream)
206 stream.WriteString(string(tempStream.Buffer()))
207}
208
209func (encoder *stringModeStringEncoder) IsEmpty(ptr unsafe.Pointer) bool {
210 return encoder.elemEncoder.IsEmpty(ptr)
211}
diff --git a/vendor/github.com/json-iterator/go/stream.go b/vendor/github.com/json-iterator/go/stream.go
deleted file mode 100644
index 23d8a3a..0000000
--- a/vendor/github.com/json-iterator/go/stream.go
+++ /dev/null
@@ -1,210 +0,0 @@
1package jsoniter
2
3import (
4 "io"
5)
6
7// stream is a io.Writer like object, with JSON specific write functions.
8// Error is not returned as return value, but stored as Error member on this stream instance.
9type Stream struct {
10 cfg *frozenConfig
11 out io.Writer
12 buf []byte
13 Error error
14 indention int
15 Attachment interface{} // open for customized encoder
16}
17
18// NewStream create new stream instance.
19// cfg can be jsoniter.ConfigDefault.
20// out can be nil if write to internal buffer.
21// bufSize is the initial size for the internal buffer in bytes.
22func NewStream(cfg API, out io.Writer, bufSize int) *Stream {
23 return &Stream{
24 cfg: cfg.(*frozenConfig),
25 out: out,
26 buf: make([]byte, 0, bufSize),
27 Error: nil,
28 indention: 0,
29 }
30}
31
32// Pool returns a pool can provide more stream with same configuration
33func (stream *Stream) Pool() StreamPool {
34 return stream.cfg
35}
36
37// Reset reuse this stream instance by assign a new writer
38func (stream *Stream) Reset(out io.Writer) {
39 stream.out = out
40 stream.buf = stream.buf[:0]
41}
42
43// Available returns how many bytes are unused in the buffer.
44func (stream *Stream) Available() int {
45 return cap(stream.buf) - len(stream.buf)
46}
47
48// Buffered returns the number of bytes that have been written into the current buffer.
49func (stream *Stream) Buffered() int {
50 return len(stream.buf)
51}
52
53// Buffer if writer is nil, use this method to take the result
54func (stream *Stream) Buffer() []byte {
55 return stream.buf
56}
57
58// SetBuffer allows to append to the internal buffer directly
59func (stream *Stream) SetBuffer(buf []byte) {
60 stream.buf = buf
61}
62
63// Write writes the contents of p into the buffer.
64// It returns the number of bytes written.
65// If nn < len(p), it also returns an error explaining
66// why the write is short.
67func (stream *Stream) Write(p []byte) (nn int, err error) {
68 stream.buf = append(stream.buf, p...)
69 if stream.out != nil {
70 nn, err = stream.out.Write(stream.buf)
71 stream.buf = stream.buf[nn:]
72 return
73 }
74 return len(p), nil
75}
76
77// WriteByte writes a single byte.
78func (stream *Stream) writeByte(c byte) {
79 stream.buf = append(stream.buf, c)
80}
81
82func (stream *Stream) writeTwoBytes(c1 byte, c2 byte) {
83 stream.buf = append(stream.buf, c1, c2)
84}
85
86func (stream *Stream) writeThreeBytes(c1 byte, c2 byte, c3 byte) {
87 stream.buf = append(stream.buf, c1, c2, c3)
88}
89
90func (stream *Stream) writeFourBytes(c1 byte, c2 byte, c3 byte, c4 byte) {
91 stream.buf = append(stream.buf, c1, c2, c3, c4)
92}
93
94func (stream *Stream) writeFiveBytes(c1 byte, c2 byte, c3 byte, c4 byte, c5 byte) {
95 stream.buf = append(stream.buf, c1, c2, c3, c4, c5)
96}
97
98// Flush writes any buffered data to the underlying io.Writer.
99func (stream *Stream) Flush() error {
100 if stream.out == nil {
101 return nil
102 }
103 if stream.Error != nil {
104 return stream.Error
105 }
106 _, err := stream.out.Write(stream.buf)
107 if err != nil {
108 if stream.Error == nil {
109 stream.Error = err
110 }
111 return err
112 }
113 stream.buf = stream.buf[:0]
114 return nil
115}
116
117// WriteRaw write string out without quotes, just like []byte
118func (stream *Stream) WriteRaw(s string) {
119 stream.buf = append(stream.buf, s...)
120}
121
122// WriteNil write null to stream
123func (stream *Stream) WriteNil() {
124 stream.writeFourBytes('n', 'u', 'l', 'l')
125}
126
127// WriteTrue write true to stream
128func (stream *Stream) WriteTrue() {
129 stream.writeFourBytes('t', 'r', 'u', 'e')
130}
131
132// WriteFalse write false to stream
133func (stream *Stream) WriteFalse() {
134 stream.writeFiveBytes('f', 'a', 'l', 's', 'e')
135}
136
137// WriteBool write true or false into stream
138func (stream *Stream) WriteBool(val bool) {
139 if val {
140 stream.WriteTrue()
141 } else {
142 stream.WriteFalse()
143 }
144}
145
146// WriteObjectStart write { with possible indention
147func (stream *Stream) WriteObjectStart() {
148 stream.indention += stream.cfg.indentionStep
149 stream.writeByte('{')
150 stream.writeIndention(0)
151}
152
153// WriteObjectField write "field": with possible indention
154func (stream *Stream) WriteObjectField(field string) {
155 stream.WriteString(field)
156 if stream.indention > 0 {
157 stream.writeTwoBytes(':', ' ')
158 } else {
159 stream.writeByte(':')
160 }
161}
162
163// WriteObjectEnd write } with possible indention
164func (stream *Stream) WriteObjectEnd() {
165 stream.writeIndention(stream.cfg.indentionStep)
166 stream.indention -= stream.cfg.indentionStep
167 stream.writeByte('}')
168}
169
170// WriteEmptyObject write {}
171func (stream *Stream) WriteEmptyObject() {
172 stream.writeByte('{')
173 stream.writeByte('}')
174}
175
176// WriteMore write , with possible indention
177func (stream *Stream) WriteMore() {
178 stream.writeByte(',')
179 stream.writeIndention(0)
180}
181
182// WriteArrayStart write [ with possible indention
183func (stream *Stream) WriteArrayStart() {
184 stream.indention += stream.cfg.indentionStep
185 stream.writeByte('[')
186 stream.writeIndention(0)
187}
188
189// WriteEmptyArray write []
190func (stream *Stream) WriteEmptyArray() {
191 stream.writeTwoBytes('[', ']')
192}
193
194// WriteArrayEnd write ] with possible indention
195func (stream *Stream) WriteArrayEnd() {
196 stream.writeIndention(stream.cfg.indentionStep)
197 stream.indention -= stream.cfg.indentionStep
198 stream.writeByte(']')
199}
200
201func (stream *Stream) writeIndention(delta int) {
202 if stream.indention == 0 {
203 return
204 }
205 stream.writeByte('\n')
206 toWrite := stream.indention - delta
207 for i := 0; i < toWrite; i++ {
208 stream.buf = append(stream.buf, ' ')
209 }
210}
diff --git a/vendor/github.com/json-iterator/go/stream_float.go b/vendor/github.com/json-iterator/go/stream_float.go
deleted file mode 100644
index 826aa59..0000000
--- a/vendor/github.com/json-iterator/go/stream_float.go
+++ /dev/null
@@ -1,111 +0,0 @@
1package jsoniter
2
3import (
4 "fmt"
5 "math"
6 "strconv"
7)
8
9var pow10 []uint64
10
11func init() {
12 pow10 = []uint64{1, 10, 100, 1000, 10000, 100000, 1000000}
13}
14
15// WriteFloat32 write float32 to stream
16func (stream *Stream) WriteFloat32(val float32) {
17 if math.IsInf(float64(val), 0) || math.IsNaN(float64(val)) {
18 stream.Error = fmt.Errorf("unsupported value: %f", val)
19 return
20 }
21 abs := math.Abs(float64(val))
22 fmt := byte('f')
23 // Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right.
24 if abs != 0 {
25 if float32(abs) < 1e-6 || float32(abs) >= 1e21 {
26 fmt = 'e'
27 }
28 }
29 stream.buf = strconv.AppendFloat(stream.buf, float64(val), fmt, -1, 32)
30}
31
32// WriteFloat32Lossy write float32 to stream with ONLY 6 digits precision although much much faster
33func (stream *Stream) WriteFloat32Lossy(val float32) {
34 if math.IsInf(float64(val), 0) || math.IsNaN(float64(val)) {
35 stream.Error = fmt.Errorf("unsupported value: %f", val)
36 return
37 }
38 if val < 0 {
39 stream.writeByte('-')
40 val = -val
41 }
42 if val > 0x4ffffff {
43 stream.WriteFloat32(val)
44 return
45 }
46 precision := 6
47 exp := uint64(1000000) // 6
48 lval := uint64(float64(val)*float64(exp) + 0.5)
49 stream.WriteUint64(lval / exp)
50 fval := lval % exp
51 if fval == 0 {
52 return
53 }
54 stream.writeByte('.')
55 for p := precision - 1; p > 0 && fval < pow10[p]; p-- {
56 stream.writeByte('0')
57 }
58 stream.WriteUint64(fval)
59 for stream.buf[len(stream.buf)-1] == '0' {
60 stream.buf = stream.buf[:len(stream.buf)-1]
61 }
62}
63
64// WriteFloat64 write float64 to stream
65func (stream *Stream) WriteFloat64(val float64) {
66 if math.IsInf(val, 0) || math.IsNaN(val) {
67 stream.Error = fmt.Errorf("unsupported value: %f", val)
68 return
69 }
70 abs := math.Abs(val)
71 fmt := byte('f')
72 // Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right.
73 if abs != 0 {
74 if abs < 1e-6 || abs >= 1e21 {
75 fmt = 'e'
76 }
77 }
78 stream.buf = strconv.AppendFloat(stream.buf, float64(val), fmt, -1, 64)
79}
80
81// WriteFloat64Lossy write float64 to stream with ONLY 6 digits precision although much much faster
82func (stream *Stream) WriteFloat64Lossy(val float64) {
83 if math.IsInf(val, 0) || math.IsNaN(val) {
84 stream.Error = fmt.Errorf("unsupported value: %f", val)
85 return
86 }
87 if val < 0 {
88 stream.writeByte('-')
89 val = -val
90 }
91 if val > 0x4ffffff {
92 stream.WriteFloat64(val)
93 return
94 }
95 precision := 6
96 exp := uint64(1000000) // 6
97 lval := uint64(val*float64(exp) + 0.5)
98 stream.WriteUint64(lval / exp)
99 fval := lval % exp
100 if fval == 0 {
101 return
102 }
103 stream.writeByte('.')
104 for p := precision - 1; p > 0 && fval < pow10[p]; p-- {
105 stream.writeByte('0')
106 }
107 stream.WriteUint64(fval)
108 for stream.buf[len(stream.buf)-1] == '0' {
109 stream.buf = stream.buf[:len(stream.buf)-1]
110 }
111}
diff --git a/vendor/github.com/json-iterator/go/stream_int.go b/vendor/github.com/json-iterator/go/stream_int.go
deleted file mode 100644
index d1059ee..0000000
--- a/vendor/github.com/json-iterator/go/stream_int.go
+++ /dev/null
@@ -1,190 +0,0 @@
1package jsoniter
2
3var digits []uint32
4
5func init() {
6 digits = make([]uint32, 1000)
7 for i := uint32(0); i < 1000; i++ {
8 digits[i] = (((i / 100) + '0') << 16) + ((((i / 10) % 10) + '0') << 8) + i%10 + '0'
9 if i < 10 {
10 digits[i] += 2 << 24
11 } else if i < 100 {
12 digits[i] += 1 << 24
13 }
14 }
15}
16
17func writeFirstBuf(space []byte, v uint32) []byte {
18 start := v >> 24
19 if start == 0 {
20 space = append(space, byte(v>>16), byte(v>>8))
21 } else if start == 1 {
22 space = append(space, byte(v>>8))
23 }
24 space = append(space, byte(v))
25 return space
26}
27
28func writeBuf(buf []byte, v uint32) []byte {
29 return append(buf, byte(v>>16), byte(v>>8), byte(v))
30}
31
32// WriteUint8 write uint8 to stream
33func (stream *Stream) WriteUint8(val uint8) {
34 stream.buf = writeFirstBuf(stream.buf, digits[val])
35}
36
37// WriteInt8 write int8 to stream
38func (stream *Stream) WriteInt8(nval int8) {
39 var val uint8
40 if nval < 0 {
41 val = uint8(-nval)
42 stream.buf = append(stream.buf, '-')
43 } else {
44 val = uint8(nval)
45 }
46 stream.buf = writeFirstBuf(stream.buf, digits[val])
47}
48
49// WriteUint16 write uint16 to stream
50func (stream *Stream) WriteUint16(val uint16) {
51 q1 := val / 1000
52 if q1 == 0 {
53 stream.buf = writeFirstBuf(stream.buf, digits[val])
54 return
55 }
56 r1 := val - q1*1000
57 stream.buf = writeFirstBuf(stream.buf, digits[q1])
58 stream.buf = writeBuf(stream.buf, digits[r1])
59 return
60}
61
62// WriteInt16 write int16 to stream
63func (stream *Stream) WriteInt16(nval int16) {
64 var val uint16
65 if nval < 0 {
66 val = uint16(-nval)
67 stream.buf = append(stream.buf, '-')
68 } else {
69 val = uint16(nval)
70 }
71 stream.WriteUint16(val)
72}
73
74// WriteUint32 write uint32 to stream
75func (stream *Stream) WriteUint32(val uint32) {
76 q1 := val / 1000
77 if q1 == 0 {
78 stream.buf = writeFirstBuf(stream.buf, digits[val])
79 return
80 }
81 r1 := val - q1*1000
82 q2 := q1 / 1000
83 if q2 == 0 {
84 stream.buf = writeFirstBuf(stream.buf, digits[q1])
85 stream.buf = writeBuf(stream.buf, digits[r1])
86 return
87 }
88 r2 := q1 - q2*1000
89 q3 := q2 / 1000
90 if q3 == 0 {
91 stream.buf = writeFirstBuf(stream.buf, digits[q2])
92 } else {
93 r3 := q2 - q3*1000
94 stream.buf = append(stream.buf, byte(q3+'0'))
95 stream.buf = writeBuf(stream.buf, digits[r3])
96 }
97 stream.buf = writeBuf(stream.buf, digits[r2])
98 stream.buf = writeBuf(stream.buf, digits[r1])
99}
100
101// WriteInt32 write int32 to stream
102func (stream *Stream) WriteInt32(nval int32) {
103 var val uint32
104 if nval < 0 {
105 val = uint32(-nval)
106 stream.buf = append(stream.buf, '-')
107 } else {
108 val = uint32(nval)
109 }
110 stream.WriteUint32(val)
111}
112
113// WriteUint64 write uint64 to stream
114func (stream *Stream) WriteUint64(val uint64) {
115 q1 := val / 1000
116 if q1 == 0 {
117 stream.buf = writeFirstBuf(stream.buf, digits[val])
118 return
119 }
120 r1 := val - q1*1000
121 q2 := q1 / 1000
122 if q2 == 0 {
123 stream.buf = writeFirstBuf(stream.buf, digits[q1])
124 stream.buf = writeBuf(stream.buf, digits[r1])
125 return
126 }
127 r2 := q1 - q2*1000
128 q3 := q2 / 1000
129 if q3 == 0 {
130 stream.buf = writeFirstBuf(stream.buf, digits[q2])
131 stream.buf = writeBuf(stream.buf, digits[r2])
132 stream.buf = writeBuf(stream.buf, digits[r1])
133 return
134 }
135 r3 := q2 - q3*1000
136 q4 := q3 / 1000
137 if q4 == 0 {
138 stream.buf = writeFirstBuf(stream.buf, digits[q3])
139 stream.buf = writeBuf(stream.buf, digits[r3])
140 stream.buf = writeBuf(stream.buf, digits[r2])
141 stream.buf = writeBuf(stream.buf, digits[r1])
142 return
143 }
144 r4 := q3 - q4*1000
145 q5 := q4 / 1000
146 if q5 == 0 {
147 stream.buf = writeFirstBuf(stream.buf, digits[q4])
148 stream.buf = writeBuf(stream.buf, digits[r4])
149 stream.buf = writeBuf(stream.buf, digits[r3])
150 stream.buf = writeBuf(stream.buf, digits[r2])
151 stream.buf = writeBuf(stream.buf, digits[r1])
152 return
153 }
154 r5 := q4 - q5*1000
155 q6 := q5 / 1000
156 if q6 == 0 {
157 stream.buf = writeFirstBuf(stream.buf, digits[q5])
158 } else {
159 stream.buf = writeFirstBuf(stream.buf, digits[q6])
160 r6 := q5 - q6*1000
161 stream.buf = writeBuf(stream.buf, digits[r6])
162 }
163 stream.buf = writeBuf(stream.buf, digits[r5])
164 stream.buf = writeBuf(stream.buf, digits[r4])
165 stream.buf = writeBuf(stream.buf, digits[r3])
166 stream.buf = writeBuf(stream.buf, digits[r2])
167 stream.buf = writeBuf(stream.buf, digits[r1])
168}
169
170// WriteInt64 write int64 to stream
171func (stream *Stream) WriteInt64(nval int64) {
172 var val uint64
173 if nval < 0 {
174 val = uint64(-nval)
175 stream.buf = append(stream.buf, '-')
176 } else {
177 val = uint64(nval)
178 }
179 stream.WriteUint64(val)
180}
181
182// WriteInt write int to stream
183func (stream *Stream) WriteInt(val int) {
184 stream.WriteInt64(int64(val))
185}
186
187// WriteUint write uint to stream
188func (stream *Stream) WriteUint(val uint) {
189 stream.WriteUint64(uint64(val))
190}
diff --git a/vendor/github.com/json-iterator/go/stream_str.go b/vendor/github.com/json-iterator/go/stream_str.go
deleted file mode 100644
index 54c2ba0..0000000
--- a/vendor/github.com/json-iterator/go/stream_str.go
+++ /dev/null
@@ -1,372 +0,0 @@
1package jsoniter
2
3import (
4 "unicode/utf8"
5)
6
7// htmlSafeSet holds the value true if the ASCII character with the given
8// array position can be safely represented inside a JSON string, embedded
9// inside of HTML <script> tags, without any additional escaping.
10//
11// All values are true except for the ASCII control characters (0-31), the
12// double quote ("), the backslash character ("\"), HTML opening and closing
13// tags ("<" and ">"), and the ampersand ("&").
14var htmlSafeSet = [utf8.RuneSelf]bool{
15 ' ': true,
16 '!': true,
17 '"': false,
18 '#': true,
19 '$': true,
20 '%': true,
21 '&': false,
22 '\'': true,
23 '(': true,
24 ')': true,
25 '*': true,
26 '+': true,
27 ',': true,
28 '-': true,
29 '.': true,
30 '/': true,
31 '0': true,
32 '1': true,
33 '2': true,
34 '3': true,
35 '4': true,
36 '5': true,
37 '6': true,
38 '7': true,
39 '8': true,
40 '9': true,
41 ':': true,
42 ';': true,
43 '<': false,
44 '=': true,
45 '>': false,
46 '?': true,
47 '@': true,
48 'A': true,
49 'B': true,
50 'C': true,
51 'D': true,
52 'E': true,
53 'F': true,
54 'G': true,
55 'H': true,
56 'I': true,
57 'J': true,
58 'K': true,
59 'L': true,
60 'M': true,
61 'N': true,
62 'O': true,
63 'P': true,
64 'Q': true,
65 'R': true,
66 'S': true,
67 'T': true,
68 'U': true,
69 'V': true,
70 'W': true,
71 'X': true,
72 'Y': true,
73 'Z': true,
74 '[': true,
75 '\\': false,
76 ']': true,
77 '^': true,
78 '_': true,
79 '`': true,
80 'a': true,
81 'b': true,
82 'c': true,
83 'd': true,
84 'e': true,
85 'f': true,
86 'g': true,
87 'h': true,
88 'i': true,
89 'j': true,
90 'k': true,
91 'l': true,
92 'm': true,
93 'n': true,
94 'o': true,
95 'p': true,
96 'q': true,
97 'r': true,
98 's': true,
99 't': true,
100 'u': true,
101 'v': true,
102 'w': true,
103 'x': true,
104 'y': true,
105 'z': true,
106 '{': true,
107 '|': true,
108 '}': true,
109 '~': true,
110 '\u007f': true,
111}
112
113// safeSet holds the value true if the ASCII character with the given array
114// position can be represented inside a JSON string without any further
115// escaping.
116//
117// All values are true except for the ASCII control characters (0-31), the
118// double quote ("), and the backslash character ("\").
119var safeSet = [utf8.RuneSelf]bool{
120 ' ': true,
121 '!': true,
122 '"': false,
123 '#': true,
124 '$': true,
125 '%': true,
126 '&': true,
127 '\'': true,
128 '(': true,
129 ')': true,
130 '*': true,
131 '+': true,
132 ',': true,
133 '-': true,
134 '.': true,
135 '/': true,
136 '0': true,
137 '1': true,
138 '2': true,
139 '3': true,
140 '4': true,
141 '5': true,
142 '6': true,
143 '7': true,
144 '8': true,
145 '9': true,
146 ':': true,
147 ';': true,
148 '<': true,
149 '=': true,
150 '>': true,
151 '?': true,
152 '@': true,
153 'A': true,
154 'B': true,
155 'C': true,
156 'D': true,
157 'E': true,
158 'F': true,
159 'G': true,
160 'H': true,
161 'I': true,
162 'J': true,
163 'K': true,
164 'L': true,
165 'M': true,
166 'N': true,
167 'O': true,
168 'P': true,
169 'Q': true,
170 'R': true,
171 'S': true,
172 'T': true,
173 'U': true,
174 'V': true,
175 'W': true,
176 'X': true,
177 'Y': true,
178 'Z': true,
179 '[': true,
180 '\\': false,
181 ']': true,
182 '^': true,
183 '_': true,
184 '`': true,
185 'a': true,
186 'b': true,
187 'c': true,
188 'd': true,
189 'e': true,
190 'f': true,
191 'g': true,
192 'h': true,
193 'i': true,
194 'j': true,
195 'k': true,
196 'l': true,
197 'm': true,
198 'n': true,
199 'o': true,
200 'p': true,
201 'q': true,
202 'r': true,
203 's': true,
204 't': true,
205 'u': true,
206 'v': true,
207 'w': true,
208 'x': true,
209 'y': true,
210 'z': true,
211 '{': true,
212 '|': true,
213 '}': true,
214 '~': true,
215 '\u007f': true,
216}
217
218var hex = "0123456789abcdef"
219
220// WriteStringWithHTMLEscaped write string to stream with html special characters escaped
221func (stream *Stream) WriteStringWithHTMLEscaped(s string) {
222 valLen := len(s)
223 stream.buf = append(stream.buf, '"')
224 // write string, the fast path, without utf8 and escape support
225 i := 0
226 for ; i < valLen; i++ {
227 c := s[i]
228 if c < utf8.RuneSelf && htmlSafeSet[c] {
229 stream.buf = append(stream.buf, c)
230 } else {
231 break
232 }
233 }
234 if i == valLen {
235 stream.buf = append(stream.buf, '"')
236 return
237 }
238 writeStringSlowPathWithHTMLEscaped(stream, i, s, valLen)
239}
240
241func writeStringSlowPathWithHTMLEscaped(stream *Stream, i int, s string, valLen int) {
242 start := i
243 // for the remaining parts, we process them char by char
244 for i < valLen {
245 if b := s[i]; b < utf8.RuneSelf {
246 if htmlSafeSet[b] {
247 i++
248 continue
249 }
250 if start < i {
251 stream.WriteRaw(s[start:i])
252 }
253 switch b {
254 case '\\', '"':
255 stream.writeTwoBytes('\\', b)
256 case '\n':
257 stream.writeTwoBytes('\\', 'n')
258 case '\r':
259 stream.writeTwoBytes('\\', 'r')
260 case '\t':
261 stream.writeTwoBytes('\\', 't')
262 default:
263 // This encodes bytes < 0x20 except for \t, \n and \r.
264 // If escapeHTML is set, it also escapes <, >, and &
265 // because they can lead to security holes when
266 // user-controlled strings are rendered into JSON
267 // and served to some browsers.
268 stream.WriteRaw(`\u00`)
269 stream.writeTwoBytes(hex[b>>4], hex[b&0xF])
270 }
271 i++
272 start = i
273 continue
274 }
275 c, size := utf8.DecodeRuneInString(s[i:])
276 if c == utf8.RuneError && size == 1 {
277 if start < i {
278 stream.WriteRaw(s[start:i])
279 }
280 stream.WriteRaw(`\ufffd`)
281 i++
282 start = i
283 continue
284 }
285 // U+2028 is LINE SEPARATOR.
286 // U+2029 is PARAGRAPH SEPARATOR.
287 // They are both technically valid characters in JSON strings,
288 // but don't work in JSONP, which has to be evaluated as JavaScript,
289 // and can lead to security holes there. It is valid JSON to
290 // escape them, so we do so unconditionally.
291 // See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
292 if c == '\u2028' || c == '\u2029' {
293 if start < i {
294 stream.WriteRaw(s[start:i])
295 }
296 stream.WriteRaw(`\u202`)
297 stream.writeByte(hex[c&0xF])
298 i += size
299 start = i
300 continue
301 }
302 i += size
303 }
304 if start < len(s) {
305 stream.WriteRaw(s[start:])
306 }
307 stream.writeByte('"')
308}
309
310// WriteString write string to stream without html escape
311func (stream *Stream) WriteString(s string) {
312 valLen := len(s)
313 stream.buf = append(stream.buf, '"')
314 // write string, the fast path, without utf8 and escape support
315 i := 0
316 for ; i < valLen; i++ {
317 c := s[i]
318 if c > 31 && c != '"' && c != '\\' {
319 stream.buf = append(stream.buf, c)
320 } else {
321 break
322 }
323 }
324 if i == valLen {
325 stream.buf = append(stream.buf, '"')
326 return
327 }
328 writeStringSlowPath(stream, i, s, valLen)
329}
330
331func writeStringSlowPath(stream *Stream, i int, s string, valLen int) {
332 start := i
333 // for the remaining parts, we process them char by char
334 for i < valLen {
335 if b := s[i]; b < utf8.RuneSelf {
336 if safeSet[b] {
337 i++
338 continue
339 }
340 if start < i {
341 stream.WriteRaw(s[start:i])
342 }
343 switch b {
344 case '\\', '"':
345 stream.writeTwoBytes('\\', b)
346 case '\n':
347 stream.writeTwoBytes('\\', 'n')
348 case '\r':
349 stream.writeTwoBytes('\\', 'r')
350 case '\t':
351 stream.writeTwoBytes('\\', 't')
352 default:
353 // This encodes bytes < 0x20 except for \t, \n and \r.
354 // If escapeHTML is set, it also escapes <, >, and &
355 // because they can lead to security holes when
356 // user-controlled strings are rendered into JSON
357 // and served to some browsers.
358 stream.WriteRaw(`\u00`)
359 stream.writeTwoBytes(hex[b>>4], hex[b&0xF])
360 }
361 i++
362 start = i
363 continue
364 }
365 i++
366 continue
367 }
368 if start < len(s) {
369 stream.WriteRaw(s[start:])
370 }
371 stream.writeByte('"')
372}
diff --git a/vendor/github.com/json-iterator/go/test.sh b/vendor/github.com/json-iterator/go/test.sh
deleted file mode 100644
index f4e7c0b..0000000
--- a/vendor/github.com/json-iterator/go/test.sh
+++ /dev/null
@@ -1,12 +0,0 @@
1#!/usr/bin/env bash
2
3set -e
4echo "" > coverage.txt
5
6for d in $(go list ./... | grep -v vendor); do
7 go test -coverprofile=profile.out -coverpkg=github.com/json-iterator/go $d
8 if [ -f profile.out ]; then
9 cat profile.out >> coverage.txt
10 rm profile.out
11 fi
12done
generated by cgit v1.2.3 (git 2.45.2) at 2024-11-18 23:03:27 +0000