1 package jsoniter
2
3 import (
4 "reflect"
5 "unsafe"
6 )
7
8 type arrayLazyAny struct {
9 baseAny
10 cfg *frozenConfig
11 buf []byte
12 err error
13 }
14
15 func (any *arrayLazyAny) ValueType() ValueType {
16 return ArrayValue
17 }
18
19 func (any *arrayLazyAny) MustBeValid() Any {
20 return any
21 }
22
23 func (any *arrayLazyAny) LastError() error {
24 return any.err
25 }
26
27 func (any *arrayLazyAny) ToBool() bool {
28 iter := any.cfg.BorrowIterator(any.buf)
29 defer any.cfg.ReturnIterator(iter)
30 return iter.ReadArray()
31 }
32
33 func (any *arrayLazyAny) ToInt() int {
34 if any.ToBool() {
35 return 1
36 }
37 return 0
38 }
39
40 func (any *arrayLazyAny) ToInt32() int32 {
41 if any.ToBool() {
42 return 1
43 }
44 return 0
45 }
46
47 func (any *arrayLazyAny) ToInt64() int64 {
48 if any.ToBool() {
49 return 1
50 }
51 return 0
52 }
53
54 func (any *arrayLazyAny) ToUint() uint {
55 if any.ToBool() {
56 return 1
57 }
58 return 0
59 }
60
61 func (any *arrayLazyAny) ToUint32() uint32 {
62 if any.ToBool() {
63 return 1
64 }
65 return 0
66 }
67
68 func (any *arrayLazyAny) ToUint64() uint64 {
69 if any.ToBool() {
70 return 1
71 }
72 return 0
73 }
74
75 func (any *arrayLazyAny) ToFloat32() float32 {
76 if any.ToBool() {
77 return 1
78 }
79 return 0
80 }
81
82 func (any *arrayLazyAny) ToFloat64() float64 {
83 if any.ToBool() {
84 return 1
85 }
86 return 0
87 }
88
89 func (any *arrayLazyAny) ToString() string {
90 return *(*string)(unsafe.Pointer(&any.buf))
91 }
92
93 func (any *arrayLazyAny) ToVal(val interface{}) {
94 iter := any.cfg.BorrowIterator(any.buf)
95 defer any.cfg.ReturnIterator(iter)
96 iter.ReadVal(val)
97 }
98
99 func (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
133 func (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
145 func (any *arrayLazyAny) WriteTo(stream *Stream) {
146 stream.Write(any.buf)
147 }
148
149 func (any *arrayLazyAny) GetInterface() interface{} {
150 iter := any.cfg.BorrowIterator(any.buf)
151 defer any.cfg.ReturnIterator(iter)
152 return iter.Read()
153 }
154
155 type arrayAny struct {
156 baseAny
157 val reflect.Value
158 }
159
160 func wrapArray(val interface{}) *arrayAny {
161 return &arrayAny{baseAny{}, reflect.ValueOf(val)}
162 }
163
164 func (any *arrayAny) ValueType() ValueType {
165 return ArrayValue
166 }
167
168 func (any *arrayAny) MustBeValid() Any {
169 return any
170 }
171
172 func (any *arrayAny) LastError() error {
173 return nil
174 }
175
176 func (any *arrayAny) ToBool() bool {
177 return any.val.Len() != 0
178 }
179
180 func (any *arrayAny) ToInt() int {
181 if any.val.Len() == 0 {
182 return 0
183 }
184 return 1
185 }
186
187 func (any *arrayAny) ToInt32() int32 {
188 if any.val.Len() == 0 {
189 return 0
190 }
191 return 1
192 }
193
194 func (any *arrayAny) ToInt64() int64 {
195 if any.val.Len() == 0 {
196 return 0
197 }
198 return 1
199 }
200
201 func (any *arrayAny) ToUint() uint {
202 if any.val.Len() == 0 {
203 return 0
204 }
205 return 1
206 }
207
208 func (any *arrayAny) ToUint32() uint32 {
209 if any.val.Len() == 0 {
210 return 0
211 }
212 return 1
213 }
214
215 func (any *arrayAny) ToUint64() uint64 {
216 if any.val.Len() == 0 {
217 return 0
218 }
219 return 1
220 }
221
222 func (any *arrayAny) ToFloat32() float32 {
223 if any.val.Len() == 0 {
224 return 0
225 }
226 return 1
227 }
228
229 func (any *arrayAny) ToFloat64() float64 {
230 if any.val.Len() == 0 {
231 return 0
232 }
233 return 1
234 }
235
236 func (any *arrayAny) ToString() string {
237 str, _ := MarshalToString(any.val.Interface())
238 return str
239 }
240
241 func (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
268 func (any *arrayAny) Size() int {
269 return any.val.Len()
270 }
271
272 func (any *arrayAny) WriteTo(stream *Stream) {
273 stream.WriteVal(any.val)
274 }
275
276 func (any *arrayAny) GetInterface() interface{} {
277 return any.val.Interface()
278 }
279
View as plain text