podman

1
package jsoniter
2

3
import (
4
	"reflect"
5
	"unsafe"
6
)
7

8
type objectLazyAny struct {
9
	baseAny
10
	cfg *frozenConfig
11
	buf []byte
12
	err error
13
}
14

15
func (any *objectLazyAny) ValueType() ValueType {
16
	return ObjectValue
17
}
18

19
func (any *objectLazyAny) MustBeValid() Any {
20
	return any
21
}
22

23
func (any *objectLazyAny) LastError() error {
24
	return any.err
25
}
26

27
func (any *objectLazyAny) ToBool() bool {
28
	return true
29
}
30

31
func (any *objectLazyAny) ToInt() int {
32
	return 0
33
}
34

35
func (any *objectLazyAny) ToInt32() int32 {
36
	return 0
37
}
38

39
func (any *objectLazyAny) ToInt64() int64 {
40
	return 0
41
}
42

43
func (any *objectLazyAny) ToUint() uint {
44
	return 0
45
}
46

47
func (any *objectLazyAny) ToUint32() uint32 {
48
	return 0
49
}
50

51
func (any *objectLazyAny) ToUint64() uint64 {
52
	return 0
53
}
54

55
func (any *objectLazyAny) ToFloat32() float32 {
56
	return 0
57
}
58

59
func (any *objectLazyAny) ToFloat64() float64 {
60
	return 0
61
}
62

63
func (any *objectLazyAny) ToString() string {
64
	return *(*string)(unsafe.Pointer(&any.buf))
65
}
66

67
func (any *objectLazyAny) ToVal(obj interface{}) {
68
	iter := any.cfg.BorrowIterator(any.buf)
69
	defer any.cfg.ReturnIterator(iter)
70
	iter.ReadVal(obj)
71
}
72

73
func (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

107
func (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

119
func (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

131
func (any *objectLazyAny) WriteTo(stream *Stream) {
132
	stream.Write(any.buf)
133
}
134

135
func (any *objectLazyAny) GetInterface() interface{} {
136
	iter := any.cfg.BorrowIterator(any.buf)
137
	defer any.cfg.ReturnIterator(iter)
138
	return iter.Read()
139
}
140

141
type objectAny struct {
142
	baseAny
143
	err error
144
	val reflect.Value
145
}
146

147
func wrapStruct(val interface{}) *objectAny {
148
	return &objectAny{baseAny{}, nil, reflect.ValueOf(val)}
149
}
150

151
func (any *objectAny) ValueType() ValueType {
152
	return ObjectValue
153
}
154

155
func (any *objectAny) MustBeValid() Any {
156
	return any
157
}
158

159
func (any *objectAny) Parse() *Iterator {
160
	return nil
161
}
162

163
func (any *objectAny) LastError() error {
164
	return any.err
165
}
166

167
func (any *objectAny) ToBool() bool {
168
	return any.val.NumField() != 0
169
}
170

171
func (any *objectAny) ToInt() int {
172
	return 0
173
}
174

175
func (any *objectAny) ToInt32() int32 {
176
	return 0
177
}
178

179
func (any *objectAny) ToInt64() int64 {
180
	return 0
181
}
182

183
func (any *objectAny) ToUint() uint {
184
	return 0
185
}
186

187
func (any *objectAny) ToUint32() uint32 {
188
	return 0
189
}
190

191
func (any *objectAny) ToUint64() uint64 {
192
	return 0
193
}
194

195
func (any *objectAny) ToFloat32() float32 {
196
	return 0
197
}
198

199
func (any *objectAny) ToFloat64() float64 {
200
	return 0
201
}
202

203
func (any *objectAny) ToString() string {
204
	str, err := MarshalToString(any.val.Interface())
205
	any.err = err
206
	return str
207
}
208

209
func (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

240
func (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

248
func (any *objectAny) Size() int {
249
	return any.val.NumField()
250
}
251

252
func (any *objectAny) WriteTo(stream *Stream) {
253
	stream.WriteVal(any.val)
254
}
255

256
func (any *objectAny) GetInterface() interface{} {
257
	return any.val.Interface()
258
}
259

260
type mapAny struct {
261
	baseAny
262
	err error
263
	val reflect.Value
264
}
265

266
func wrapMap(val interface{}) *mapAny {
267
	return &mapAny{baseAny{}, nil, reflect.ValueOf(val)}
268
}
269

270
func (any *mapAny) ValueType() ValueType {
271
	return ObjectValue
272
}
273

274
func (any *mapAny) MustBeValid() Any {
275
	return any
276
}
277

278
func (any *mapAny) Parse() *Iterator {
279
	return nil
280
}
281

282
func (any *mapAny) LastError() error {
283
	return any.err
284
}
285

286
func (any *mapAny) ToBool() bool {
287
	return true
288
}
289

290
func (any *mapAny) ToInt() int {
291
	return 0
292
}
293

294
func (any *mapAny) ToInt32() int32 {
295
	return 0
296
}
297

298
func (any *mapAny) ToInt64() int64 {
299
	return 0
300
}
301

302
func (any *mapAny) ToUint() uint {
303
	return 0
304
}
305

306
func (any *mapAny) ToUint32() uint32 {
307
	return 0
308
}
309

310
func (any *mapAny) ToUint64() uint64 {
311
	return 0
312
}
313

314
func (any *mapAny) ToFloat32() float32 {
315
	return 0
316
}
317

318
func (any *mapAny) ToFloat64() float64 {
319
	return 0
320
}
321

322
func (any *mapAny) ToString() string {
323
	str, err := MarshalToString(any.val.Interface())
324
	any.err = err
325
	return str
326
}
327

328
func (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

356
func (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

364
func (any *mapAny) Size() int {
365
	return any.val.Len()
366
}
367

368
func (any *mapAny) WriteTo(stream *Stream) {
369
	stream.WriteVal(any.val)
370
}
371

372
func (any *mapAny) GetInterface() interface{} {
373
	return any.val.Interface()
374
}
375