podman

1
/*
2
 * Copyright 2021 ByteDance Inc.
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 *     http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16

17
package ast
18

19
import (
20
    `encoding/json`
21
    `fmt`
22
    `strconv`
23
    `unsafe`
24
    
25
    `github.com/bytedance/sonic/internal/native/types`
26
    `github.com/bytedance/sonic/internal/rt`
27
)
28

29
const (
30
    _V_NONE         types.ValueType = 0
31
    _V_NODE_BASE    types.ValueType = 1 << 5
32
    _V_LAZY         types.ValueType = 1 << 7
33
    _V_RAW          types.ValueType = 1 << 8
34
    _V_NUMBER                       = _V_NODE_BASE + 1
35
    _V_ANY                          = _V_NODE_BASE + 2
36
    _V_ARRAY_LAZY                   = _V_LAZY | types.V_ARRAY
37
    _V_OBJECT_LAZY                  = _V_LAZY | types.V_OBJECT
38
    _MASK_LAZY                      = _V_LAZY - 1
39
    _MASK_RAW                       = _V_RAW - 1
40
)
41

42
const (
43
    V_NONE   = 0
44
    V_ERROR  = 1
45
    V_NULL   = int(types.V_NULL)
46
    V_TRUE   = int(types.V_TRUE)
47
    V_FALSE  = int(types.V_FALSE)
48
    V_ARRAY  = int(types.V_ARRAY)
49
    V_OBJECT = int(types.V_OBJECT)
50
    V_STRING = int(types.V_STRING)
51
    V_NUMBER = int(_V_NUMBER)
52
    V_ANY    = int(_V_ANY)
53
)
54

55
type Node struct {
56
    t types.ValueType
57
    l uint
58
    p unsafe.Pointer
59
}
60

61
// UnmarshalJSON is just an adapter to json.Unmarshaler.
62
// If you want better performance, use Searcher.GetByPath() directly
63
func (self *Node) UnmarshalJSON(data []byte) (err error) {
64
    *self = NewRaw(string(data))
65
    return self.Check()
66
}
67

68
/** Node Type Accessor **/
69

70
// Type returns json type represented by the node
71
// It will be one of belows:
72
//    V_NONE   = 0 (empty node, key not exists)
73
//    V_ERROR  = 1 (error node)
74
//    V_NULL   = 2 (json value `null`, key exists)
75
//    V_TRUE   = 3 (json value `true`)
76
//    V_FALSE  = 4 (json value `false`)
77
//    V_ARRAY  = 5 (json value array)
78
//    V_OBJECT = 6 (json value object)
79
//    V_STRING = 7 (json value string)
80
//    V_NUMBER = 33 (json value number )
81
//    V_ANY    = 34 (golang interface{})
82
func (self Node) Type() int {
83
    return int(self.t & _MASK_LAZY & _MASK_RAW)
84
}
85

86
func (self Node) itype() types.ValueType {
87
    return self.t & _MASK_LAZY & _MASK_RAW
88
}
89

90
// Exists returns false only if the self is nil or empty node V_NONE
91
func (self *Node) Exists() bool {
92
    return self.Valid() && self.t != _V_NONE
93
}
94

95
// Valid reports if self is NOT V_ERROR or nil
96
func (self *Node) Valid() bool {
97
    if self == nil {
98
        return false
99
    }
100
    return self.t != V_ERROR
101
}
102

103
// Check checks if the node itself is valid, and return:
104
//   - ErrNotExist If the node is nil
105
//   - Its underlying error If the node is V_ERROR
106
func (self *Node)  Check() error {
107
    if self == nil {
108
        return ErrNotExist
109
    } else if self.t != V_ERROR {
110
        return nil
111
    } else {
112
        return self
113
    }
114
}
115

116
// IsRaw returns true if node's underlying value is raw json
117
func (self Node) IsRaw() bool {
118
    return self.t&_V_RAW != 0
119
}
120

121
func (self *Node) isLazy() bool {
122
    return self != nil && self.t&_V_LAZY != 0
123
}
124

125
func (self *Node) isAny() bool {
126
    return self != nil && self.t == _V_ANY
127
}
128

129
/** Simple Value Methods **/
130

131
// Raw returns json representation of the node,
132
func (self *Node) Raw() (string, error) {
133
    if self == nil {
134
        return "", ErrNotExist
135
    }
136
    if !self.IsRaw() {
137
        buf, err := self.MarshalJSON()
138
        return rt.Mem2Str(buf), err
139
    }
140
    return self.toString(), nil
141
}
142

143
func (self *Node) checkRaw() error {
144
    if err := self.Check(); err != nil {
145
        return err
146
    }
147
    if self.IsRaw() {
148
        self.parseRaw(false)
149
    }
150
    return self.Check()
151
}
152

153
// Bool returns bool value represented by this node, 
154
// including types.V_TRUE|V_FALSE|V_NUMBER|V_STRING|V_ANY|V_NULL, 
155
// V_NONE will return error
156
func (self *Node) Bool() (bool, error) {
157
    if err := self.checkRaw(); err != nil {
158
        return false, err
159
    }
160
    switch self.t {
161
        case types.V_TRUE  : return true , nil
162
        case types.V_FALSE : return false, nil
163
        case types.V_NULL  : return false, nil
164
        case _V_NUMBER     : 
165
            if i, err := self.toInt64(); err == nil {
166
                return i != 0, nil
167
            } else if f, err := self.toFloat64(); err == nil {
168
                return f != 0, nil
169
            } else {
170
                return false, err
171
            }
172
        case types.V_STRING: return strconv.ParseBool(self.toString())
173
        case _V_ANY        :   
174
            any := self.packAny()     
175
            switch v := any.(type) {
176
                case bool   : return v, nil
177
                case int    : return v != 0, nil
178
                case int8   : return v != 0, nil
179
                case int16  : return v != 0, nil
180
                case int32  : return v != 0, nil
181
                case int64  : return v != 0, nil
182
                case uint   : return v != 0, nil
183
                case uint8  : return v != 0, nil
184
                case uint16 : return v != 0, nil
185
                case uint32 : return v != 0, nil
186
                case uint64 : return v != 0, nil
187
                case float32: return v != 0, nil
188
                case float64: return v != 0, nil
189
                case string : return strconv.ParseBool(v)
190
                case json.Number: 
191
                    if i, err := v.Int64(); err == nil {
192
                        return i != 0, nil
193
                    } else if f, err := v.Float64(); err == nil {
194
                        return f != 0, nil
195
                    } else {
196
                        return false, err
197
                    }
198
                default: return false, ErrUnsupportType
199
            }
200
        default            : return false, ErrUnsupportType
201
    }
202
}
203

204
// Int64 casts the node to int64 value, 
205
// including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING
206
// V_NONE it will return error
207
func (self *Node) Int64() (int64, error) {
208
    if err := self.checkRaw(); err != nil {
209
        return 0, err
210
    }
211
    switch self.t {
212
        case _V_NUMBER, types.V_STRING :
213
            if i, err := self.toInt64(); err == nil {
214
                return i, nil
215
            } else if f, err := self.toFloat64(); err == nil {
216
                return int64(f), nil
217
            } else {
218
                return 0, err
219
            }
220
        case types.V_TRUE     : return 1, nil
221
        case types.V_FALSE    : return 0, nil
222
        case types.V_NULL     : return 0, nil
223
        case _V_ANY           :  
224
            any := self.packAny()
225
            switch v := any.(type) {
226
                case bool   : if v { return 1, nil } else { return 0, nil }
227
                case int    : return int64(v), nil
228
                case int8   : return int64(v), nil
229
                case int16  : return int64(v), nil
230
                case int32  : return int64(v), nil
231
                case int64  : return int64(v), nil
232
                case uint   : return int64(v), nil
233
                case uint8  : return int64(v), nil
234
                case uint16 : return int64(v), nil
235
                case uint32 : return int64(v), nil
236
                case uint64 : return int64(v), nil
237
                case float32: return int64(v), nil
238
                case float64: return int64(v), nil
239
                case string : 
240
                    if i, err := strconv.ParseInt(v, 10, 64); err == nil {
241
                        return i, nil
242
                    } else if f, err := strconv.ParseFloat(v, 64); err == nil {
243
                        return int64(f), nil
244
                    } else {
245
                        return 0, err
246
                    }
247
                case json.Number: 
248
                    if i, err := v.Int64(); err == nil {
249
                        return i, nil
250
                    } else if f, err := v.Float64(); err == nil {
251
                        return int64(f), nil
252
                    } else {
253
                        return 0, err
254
                    }
255
                default: return 0, ErrUnsupportType
256
            }
257
        default               : return 0, ErrUnsupportType
258
    }
259
}
260

261
// StrictInt64 exports underlying int64 value, including V_NUMBER, V_ANY
262
func (self *Node) StrictInt64() (int64, error) {
263
    if err := self.checkRaw(); err != nil {
264
        return 0, err
265
    }
266
    switch self.t {
267
        case _V_NUMBER        : return self.toInt64()
268
        case _V_ANY           :  
269
            any := self.packAny()
270
            switch v := any.(type) {
271
                case int   : return int64(v), nil
272
                case int8  : return int64(v), nil
273
                case int16 : return int64(v), nil
274
                case int32 : return int64(v), nil
275
                case int64 : return int64(v), nil
276
                case uint  : return int64(v), nil
277
                case uint8 : return int64(v), nil
278
                case uint16: return int64(v), nil
279
                case uint32: return int64(v), nil
280
                case uint64: return int64(v), nil
281
                case json.Number: 
282
                    if i, err := v.Int64(); err == nil {
283
                        return i, nil
284
                    } else {
285
                        return 0, err
286
                    }
287
                default: return 0, ErrUnsupportType
288
            }
289
        default               : return 0, ErrUnsupportType
290
    }
291
}
292

293
func castNumber(v bool) json.Number {
294
    if v {
295
        return json.Number("1")
296
    } else {
297
        return json.Number("0")
298
    }
299
}
300

301
// Number casts node to float64, 
302
// including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING|V_NULL,
303
// V_NONE it will return error
304
func (self *Node) Number() (json.Number, error) {
305
    if err := self.checkRaw(); err != nil {
306
        return json.Number(""), err
307
    }
308
    switch self.t {
309
        case _V_NUMBER        : return self.toNumber(), nil
310
        case types.V_STRING : 
311
            if _, err := self.toInt64(); err == nil {
312
                return self.toNumber(), nil
313
            } else if _, err := self.toFloat64(); err == nil {
314
                return self.toNumber(), nil
315
            } else {
316
                return json.Number(""), err
317
            }
318
        case types.V_TRUE     : return json.Number("1"), nil
319
        case types.V_FALSE    : return json.Number("0"), nil
320
        case types.V_NULL     : return json.Number("0"), nil
321
        case _V_ANY           :        
322
            any := self.packAny()
323
            switch v := any.(type) {
324
                case bool   : return castNumber(v), nil
325
                case int    : return castNumber(v != 0), nil
326
                case int8   : return castNumber(v != 0), nil
327
                case int16  : return castNumber(v != 0), nil
328
                case int32  : return castNumber(v != 0), nil
329
                case int64  : return castNumber(v != 0), nil
330
                case uint   : return castNumber(v != 0), nil
331
                case uint8  : return castNumber(v != 0), nil
332
                case uint16 : return castNumber(v != 0), nil
333
                case uint32 : return castNumber(v != 0), nil
334
                case uint64 : return castNumber(v != 0), nil
335
                case float32: return castNumber(v != 0), nil
336
                case float64: return castNumber(v != 0), nil
337
                case string : 
338
                    if _, err := strconv.ParseFloat(v, 64); err == nil {
339
                        return json.Number(v), nil
340
                    } else {
341
                        return json.Number(""), err
342
                    }
343
                case json.Number: return v, nil
344
                default: return json.Number(""), ErrUnsupportType
345
            }
346
        default               : return json.Number(""), ErrUnsupportType
347
    }
348
}
349

350
// Number exports underlying float64 value, including V_NUMBER, V_ANY of json.Number
351
func (self *Node) StrictNumber() (json.Number, error) {
352
    if err := self.checkRaw(); err != nil {
353
        return json.Number(""), err
354
    }
355
    switch self.t {
356
        case _V_NUMBER        : return self.toNumber()  , nil
357
        case _V_ANY        :        
358
            if v, ok := self.packAny().(json.Number); ok {
359
                return v, nil
360
            } else {
361
                return json.Number(""), ErrUnsupportType
362
            }
363
        default               : return json.Number(""), ErrUnsupportType
364
    }
365
}
366

367
// String cast node to string, 
368
// including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING|V_NULL,
369
// V_NONE it will return error
370
func (self *Node) String() (string, error) {
371
    if err := self.checkRaw(); err != nil {
372
        return "", err
373
    }
374
    switch self.t {
375
        case types.V_NULL    : return "" , nil
376
        case types.V_TRUE    : return "true" , nil
377
        case types.V_FALSE   : return "false", nil
378
        case types.V_STRING, _V_NUMBER  : return self.toString(), nil
379
        case _V_ANY          :        
380
        any := self.packAny()
381
        switch v := any.(type) {
382
            case bool   : return strconv.FormatBool(v), nil
383
            case int    : return strconv.Itoa(v), nil
384
            case int8   : return strconv.Itoa(int(v)), nil
385
            case int16  : return strconv.Itoa(int(v)), nil
386
            case int32  : return strconv.Itoa(int(v)), nil
387
            case int64  : return strconv.Itoa(int(v)), nil
388
            case uint   : return strconv.Itoa(int(v)), nil
389
            case uint8  : return strconv.Itoa(int(v)), nil
390
            case uint16 : return strconv.Itoa(int(v)), nil
391
            case uint32 : return strconv.Itoa(int(v)), nil
392
            case uint64 : return strconv.Itoa(int(v)), nil
393
            case float32: return strconv.FormatFloat(float64(v), 'g', -1, 64), nil
394
            case float64: return strconv.FormatFloat(float64(v), 'g', -1, 64), nil
395
            case string : return v, nil 
396
            case json.Number: return v.String(), nil
397
            default: return "", ErrUnsupportType
398
        }
399
        default              : return ""     , ErrUnsupportType
400
    }
401
}
402

403
// StrictString returns string value (unescaped), includeing V_STRING, V_ANY of string.
404
// In other cases, it will return empty string.
405
func (self *Node) StrictString() (string, error) {
406
    if err := self.checkRaw(); err != nil {
407
        return "", err
408
    }
409
    switch self.t {
410
        case types.V_STRING  : return self.toString(), nil
411
        case _V_ANY          :        
412
            if v, ok := self.packAny().(string); ok {
413
                return v, nil
414
            } else {
415
                return "", ErrUnsupportType
416
            }
417
        default              : return "", ErrUnsupportType
418
    }
419
}
420

421
// Float64 cast node to float64, 
422
// including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING|V_NULL,
423
// V_NONE it will return error
424
func (self *Node) Float64() (float64, error) {
425
    if err := self.checkRaw(); err != nil {
426
        return 0.0, err
427
    }
428
    switch self.t {
429
        case _V_NUMBER, types.V_STRING : return self.toFloat64()
430
        case types.V_TRUE    : return 1.0, nil
431
        case types.V_FALSE   : return 0.0, nil
432
        case types.V_NULL    : return 0.0, nil
433
        case _V_ANY          :        
434
            any := self.packAny()
435
            switch v := any.(type) {
436
                case bool    : 
437
                    if v {
438
                        return 1.0, nil
439
                    } else {
440
                        return 0.0, nil
441
                    }
442
                case int    : return float64(v), nil
443
                case int8   : return float64(v), nil
444
                case int16  : return float64(v), nil
445
                case int32  : return float64(v), nil
446
                case int64  : return float64(v), nil
447
                case uint   : return float64(v), nil
448
                case uint8  : return float64(v), nil
449
                case uint16 : return float64(v), nil
450
                case uint32 : return float64(v), nil
451
                case uint64 : return float64(v), nil
452
                case float32: return float64(v), nil
453
                case float64: return float64(v), nil
454
                case string : 
455
                    if f, err := strconv.ParseFloat(v, 64); err == nil {
456
                        return float64(f), nil
457
                    } else {
458
                        return 0, err
459
                    }
460
                case json.Number: 
461
                    if f, err := v.Float64(); err == nil {
462
                        return float64(f), nil
463
                    } else {
464
                        return 0, err
465
                    }
466
                default     : return 0, ErrUnsupportType
467
            }
468
        default             : return 0.0, ErrUnsupportType
469
    }
470
}
471

472
// Float64 exports underlying float64 value, includeing V_NUMBER, V_ANY 
473
func (self *Node) StrictFloat64() (float64, error) {
474
    if err := self.checkRaw(); err != nil {
475
        return 0.0, err
476
    }
477
    switch self.t {
478
        case _V_NUMBER       : return self.toFloat64()
479
        case _V_ANY        :        
480
            any := self.packAny()
481
            switch v := any.(type) {
482
                case float32 : return float64(v), nil
483
                case float64 : return float64(v), nil
484
                default      : return 0, ErrUnsupportType
485
            }
486
        default              : return 0.0, ErrUnsupportType
487
    }
488
}
489

490
/** Sequencial Value Methods **/
491

492
// Len returns children count of a array|object|string node
493
// WARN: For partially loaded node, it also works but only counts the parsed children
494
// WARN: For ARRAY|OBJECT nodes which has been conducted `UnsetXX()`, its length WON'T change
495
func (self *Node) Len() (int, error) {
496
    if err := self.checkRaw(); err != nil {
497
        return 0, err
498
    }
499
    if self.t == types.V_ARRAY || self.t == types.V_OBJECT || self.t == _V_ARRAY_LAZY || self.t == _V_OBJECT_LAZY || self.t == types.V_STRING {
500
        return int(self.l), nil
501
    } else if self.t == _V_NONE || self.t == types.V_NULL {
502
        return 0, nil
503
    } else {
504
        return 0, ErrUnsupportType
505
    }
506
}
507

508
func (self Node) len() int {
509
    return int(self.l)
510
}
511

512
// Cap returns malloc capacity of a array|object node for children
513
func (self *Node) Cap() (int, error) {
514
    if err := self.checkRaw(); err != nil {
515
        return 0, err
516
    }
517
    switch self.t {
518
    case types.V_ARRAY: return (*linkedNodes)(self.p).Cap(), nil
519
    case types.V_OBJECT: return (*linkedPairs)(self.p).Cap(), nil
520
    case _V_ARRAY_LAZY: return (*parseArrayStack)(self.p).v.Cap(), nil
521
    case _V_OBJECT_LAZY: return (*parseObjectStack)(self.p).v.Cap(), nil
522
    case _V_NONE, types.V_NULL: return 0, nil
523
    default: return 0, ErrUnsupportType
524
    }
525
}
526

527
// Set sets the node of given key under self, and reports if the key has existed.
528
//
529
// If self is V_NONE or V_NULL, it becomes V_OBJECT and sets the node at the key.
530
func (self *Node) Set(key string, node Node) (bool, error) {
531
    if err := self.Check(); err != nil {
532
        return false, err
533
    }
534
    if err := node.Check(); err != nil {
535
        return false, err 
536
    }
537

538
    if self.t == _V_NONE || self.t == types.V_NULL {
539
        *self = NewObject([]Pair{{key, node}})
540
        return false, nil
541
    }
542

543
    p := self.Get(key)
544

545
    if !p.Exists() {
546
        // self must be fully-loaded here
547
        if self.len() == 0 {
548
            *self = newObject(new(linkedPairs))
549
        }
550
        s := (*linkedPairs)(self.p)
551
        s.Add(Pair{key, node})
552
        self.l++
553
        return false, nil
554

555
    } else if err := p.Check(); err != nil {
556
        return false, err
557
    } 
558

559
    *p = node
560
    return true, nil
561
}
562

563
// SetAny wraps val with V_ANY node, and Set() the node.
564
func (self *Node) SetAny(key string, val interface{}) (bool, error) {
565
    return self.Set(key, NewAny(val))
566
}
567

568
// Unset RESET the node of given key under object parent, and reports if the key has existed.
569
// WARN: After conducting `UnsetXX()`, the node's length WON'T change
570
func (self *Node) Unset(key string) (bool, error) {
571
    if err := self.should(types.V_OBJECT, "an object"); err != nil {
572
        return false, err
573
    }
574
    p, i := self.skipKey(key)
575
    if !p.Exists() {
576
        return false, nil
577
    } else if err := p.Check(); err != nil {
578
        return false, err
579
    }
580
    
581
    self.removePair(i)
582
    return true, nil
583
}
584

585
// SetByIndex sets the node of given index, and reports if the key has existed.
586
//
587
// The index must be within self's children.
588
func (self *Node) SetByIndex(index int, node Node) (bool, error) {
589
    if err := self.Check(); err != nil {
590
        return false, err 
591
    }
592
    if err := node.Check(); err != nil {
593
        return false, err 
594
    }
595

596
    if index == 0 && (self.t == _V_NONE || self.t == types.V_NULL) {
597
        *self = NewArray([]Node{node})
598
        return false, nil
599
    }
600

601
    p := self.Index(index)
602
    if !p.Exists() {
603
        return false, ErrNotExist
604
    } else if err := p.Check(); err != nil {
605
        return false, err
606
    }
607

608
    *p = node
609
    return true, nil
610
}
611

612
// SetAny wraps val with V_ANY node, and SetByIndex() the node.
613
func (self *Node) SetAnyByIndex(index int, val interface{}) (bool, error) {
614
    return self.SetByIndex(index, NewAny(val))
615
}
616

617
// UnsetByIndex remove the node of given index
618
// WARN: After conducting `UnsetXX()`, the node's length WON'T change
619
func (self *Node) UnsetByIndex(index int) (bool, error) {
620
    if err := self.Check(); err != nil {
621
        return false, err
622
    }
623

624
    var p *Node
625
    it := self.itype()
626
    if it == types.V_ARRAY {
627
        p = self.Index(index)
628
    }else if it == types.V_OBJECT {
629
        if err := self.checkRaw(); err != nil {
630
            return false, err
631
        }
632
        pr := self.skipIndexPair(index)
633
        if pr == nil {
634
           return false, ErrNotExist
635
        }
636
        p = &pr.Value
637
    } else {
638
        return false, ErrUnsupportType
639
    }
640

641
    if !p.Exists() {
642
        return false, ErrNotExist
643
    }
644

645
    if it == types.V_ARRAY {
646
        self.removeNode(index)
647
    }else if it == types.V_OBJECT {
648
        self.removePair(index)
649
    }
650
    return true, nil
651
}
652

653
// Add appends the given node under self.
654
//
655
// If self is V_NONE or V_NULL, it becomes V_ARRAY and sets the node at index 0.
656
func (self *Node) Add(node Node) error {
657
    if err := self.Check(); err != nil {
658
        return err
659
    }
660

661
    if self != nil && (self.t == _V_NONE || self.t == types.V_NULL) {
662
        *self = NewArray([]Node{node})
663
        return nil
664
    }
665
    if err := self.should(types.V_ARRAY, "an array"); err != nil {
666
        return err
667
    }
668
    s, err := self.unsafeArray()
669
    if err != nil {
670
        return err
671
    }
672

673
    s.Add(node)
674
    self.l++
675
    return nil
676
}
677

678

679
// SetAny wraps val with V_ANY node, and Add() the node.
680
func (self *Node) AddAny(val interface{}) error {
681
    return self.Add(NewAny(val))
682
}
683

684
// GetByPath load given path on demands,
685
// which only ensure nodes before this path got parsed.
686
//
687
// Note, the api expects the json is well-formed at least,
688
// otherwise it may return unexpected result.
689
func (self *Node) GetByPath(path ...interface{}) *Node {
690
    if !self.Valid() {
691
        return self
692
    }
693
    var s = self
694
    for _, p := range path {
695
        switch p := p.(type) {
696
        case int:
697
            s = s.Index(p)
698
            if !s.Valid() {
699
                return s
700
            }
701
        case string:
702
            s = s.Get(p)
703
            if !s.Valid() {
704
                return s
705
            }
706
        default:
707
            panic("path must be either int or string")
708
        }
709
    }
710
    return s
711
}
712

713
// Get loads given key of an object node on demands
714
func (self *Node) Get(key string) *Node {
715
    if err := self.should(types.V_OBJECT, "an object"); err != nil {
716
        return unwrapError(err)
717
    }
718
    n, _ := self.skipKey(key)
719
    return n
720
}
721

722
// Index indexies node at given idx,
723
// node type CAN be either V_OBJECT or V_ARRAY
724
// WARN: After conducting `UnsetXX()`, the node's length WON'T change,
725
// thus its children's indexing WON'T change too
726
func (self *Node) Index(idx int) *Node {
727
    if err := self.checkRaw(); err != nil {
728
        return unwrapError(err)
729
    }
730

731
    it := self.itype()
732
    if it == types.V_ARRAY {
733
        return self.skipIndex(idx)
734

735
    }else if it == types.V_OBJECT {
736
        pr := self.skipIndexPair(idx)
737
        if pr == nil {
738
           return newError(_ERR_NOT_FOUND, "value not exists")
739
        }
740
        return &pr.Value
741

742
    } else {
743
        return newError(_ERR_UNSUPPORT_TYPE, fmt.Sprintf("unsupported type: %v", self.itype()))
744
    }
745
}
746

747
// IndexPair indexies pair at given idx,
748
// node type MUST be either V_OBJECT
749
// WARN: After conducting `UnsetXX()`, the node's length WON'T change,
750
// thus its children's indexing WON'T change too
751
func (self *Node) IndexPair(idx int) *Pair {
752
    if err := self.should(types.V_OBJECT, "an object"); err != nil {
753
        return nil
754
    }
755
    return self.skipIndexPair(idx)
756
}
757

758
// IndexOrGet firstly use idx to index a value and check if its key matches
759
// If not, then use the key to search value
760
func (self *Node) IndexOrGet(idx int, key string) *Node {
761
    if err := self.should(types.V_OBJECT, "an object"); err != nil {
762
        return unwrapError(err)
763
    }
764

765
    pr := self.skipIndexPair(idx)
766
    if pr != nil && pr.Key == key {
767
        return &pr.Value
768
    }
769
    n, _ := self.skipKey(key)
770
    return n
771
}
772

773
/** Generic Value Converters **/
774

775
// Map loads all keys of an object node
776
func (self *Node) Map() (map[string]interface{}, error) {
777
    if self.isAny() {
778
        any := self.packAny()
779
        if v, ok := any.(map[string]interface{}); ok {
780
            return v, nil
781
        } else {
782
            return nil, ErrUnsupportType
783
        }
784
    }
785
    if err := self.should(types.V_OBJECT, "an object"); err != nil {
786
        return nil, err
787
    }
788
    if err := self.loadAllKey(); err != nil {
789
        return nil, err
790
    }
791
    return self.toGenericObject()
792
}
793

794
// MapUseNumber loads all keys of an object node, with numeric nodes casted to json.Number
795
func (self *Node) MapUseNumber() (map[string]interface{}, error) {
796
    if self.isAny() {
797
        any := self.packAny()
798
        if v, ok := any.(map[string]interface{}); ok {
799
            return v, nil
800
        } else {
801
            return nil, ErrUnsupportType
802
        }
803
    }
804
    if err := self.should(types.V_OBJECT, "an object"); err != nil {
805
        return nil, err
806
    }
807
    if err := self.loadAllKey(); err != nil {
808
        return nil, err
809
    }
810
    return self.toGenericObjectUseNumber()
811
}
812

813
// MapUseNode scans both parsed and non-parsed chidren nodes, 
814
// and map them by their keys
815
func (self *Node) MapUseNode() (map[string]Node, error) {
816
    if self.isAny() {
817
        any := self.packAny()
818
        if v, ok := any.(map[string]Node); ok {
819
            return v, nil
820
        } else {
821
            return nil, ErrUnsupportType
822
        }
823
    }
824
    if err := self.should(types.V_OBJECT, "an object"); err != nil {
825
        return nil, err
826
    }
827
    if err := self.skipAllKey(); err != nil {
828
        return nil, err
829
    }
830
    return self.toGenericObjectUseNode()
831
}
832

833
// MapUnsafe exports the underlying pointer to its children map
834
// WARN: don't use it unless you know what you are doing
835
//
836
// Deprecated:  this API now returns copied nodes instead of directly reference, 
837
// func (self *Node) UnsafeMap() ([]Pair, error) {
838
//     if err := self.should(types.V_OBJECT, "an object"); err != nil {
839
//         return nil, err
840
//     }
841
//     if err := self.skipAllKey(); err != nil {
842
//         return nil, err
843
//     }
844
//     return self.toGenericObjectUsePair()
845
// }
846

847
//go:nocheckptr
848
func (self *Node) unsafeMap() (*linkedPairs, error) {
849
    if err := self.skipAllKey(); err != nil {
850
        return nil, err
851
    }
852
    if self.p == nil {
853
        *self = newObject(new(linkedPairs))
854
    }
855
    return (*linkedPairs)(self.p), nil
856
}
857

858
// SortKeys sorts children of a V_OBJECT node in ascending key-order.
859
// If recurse is true, it recursively sorts children's children as long as a V_OBJECT node is found.
860
func (self *Node) SortKeys(recurse bool) error {
861
    // check raw node first
862
    if err := self.checkRaw(); err != nil {
863
        return err
864
    }
865
    if self.itype() == types.V_OBJECT {
866
        return self.sortKeys(recurse)
867
    } else {
868
        var err error
869
        err2 := self.ForEach(func(path Sequence, node *Node) bool {
870
            it := node.itype()
871
            if it == types.V_ARRAY || it == types.V_OBJECT {
872
                err = node.SortKeys(recurse)
873
                if err != nil {
874
                    return false
875
                }
876
            }
877
            return true
878
        })
879
        if err != nil {
880
            return err
881
        }
882
        return err2
883
    }
884
}
885

886
func (self *Node) sortKeys(recurse bool) (err error) {
887
    ps, err := self.unsafeMap()
888
    if err != nil {
889
        return err
890
    }
891
    ps.Sort()
892
    if recurse {
893
        var sc Scanner
894
        sc = func(path Sequence, node *Node) bool {
895
            if node.itype() == types.V_OBJECT {
896
                if err := node.sortKeys(recurse); err != nil {
897
                    return false
898
                }
899
            }
900
            if node.itype() == types.V_ARRAY {
901
                if err := node.ForEach(sc); err != nil {
902
                    return false
903
                }
904
            }
905
            return true
906
        }
907
        if err := self.ForEach(sc); err != nil {
908
            return err
909
        }
910
    }
911
    return nil
912
}
913

914
// Array loads all indexes of an array node
915
func (self *Node) Array() ([]interface{}, error) {
916
    if self.isAny() {
917
        any := self.packAny()
918
        if v, ok := any.([]interface{}); ok {
919
            return v, nil
920
        } else {
921
            return nil, ErrUnsupportType
922
        }
923
    }
924
    if err := self.should(types.V_ARRAY, "an array"); err != nil {
925
        return nil, err
926
    }
927
    if err := self.loadAllIndex(); err != nil {
928
        return nil, err
929
    }
930
    return self.toGenericArray()
931
}
932

933
// ArrayUseNumber loads all indexes of an array node, with numeric nodes casted to json.Number
934
func (self *Node) ArrayUseNumber() ([]interface{}, error) {
935
    if self.isAny() {
936
        any := self.packAny()
937
        if v, ok := any.([]interface{}); ok {
938
            return v, nil
939
        } else {
940
            return nil, ErrUnsupportType
941
        }
942
    }
943
    if err := self.should(types.V_ARRAY, "an array"); err != nil {
944
        return nil, err
945
    }
946
    if err := self.loadAllIndex(); err != nil {
947
        return nil, err
948
    }
949
    return self.toGenericArrayUseNumber()
950
}
951

952
// ArrayUseNode copys both parsed and non-parsed chidren nodes, 
953
// and indexes them by original order
954
func (self *Node) ArrayUseNode() ([]Node, error) {
955
    if self.isAny() {
956
        any := self.packAny()
957
        if v, ok := any.([]Node); ok {
958
            return v, nil
959
        } else {
960
            return nil, ErrUnsupportType
961
        }
962
    }
963
    if err := self.should(types.V_ARRAY, "an array"); err != nil {
964
        return nil, err
965
    }
966
    if err := self.skipAllIndex(); err != nil {
967
        return nil, err
968
    }
969
    return self.toGenericArrayUseNode()
970
}
971

972
// ArrayUnsafe exports the underlying pointer to its children array
973
// WARN: don't use it unless you know what you are doing
974
//
975
// Deprecated:  this API now returns copied nodes instead of directly reference, 
976
// which has no difference with ArrayUseNode
977
// func (self *Node) UnsafeArray() ([]Node, error) {
978
//     if err := self.should(types.V_ARRAY, "an array"); err != nil {
979
//         return nil, err
980
//     }
981
//     if err := self.skipAllIndex(); err != nil {
982
//         return nil, err
983
//     }
984
//     return self.toGenericArrayUseNode()
985
// }
986

987
func (self *Node) unsafeArray() (*linkedNodes, error) {
988
    if err := self.skipAllIndex(); err != nil {
989
        return nil, err
990
    }
991
    if self.p == nil {
992
        *self = newArray(new(linkedNodes))
993
    }
994
    return (*linkedNodes)(self.p), nil
995
}
996

997
// Interface loads all children under all pathes from this node,
998
// and converts itself as generic type.
999
// WARN: all numberic nodes are casted to float64
1000
func (self *Node) Interface() (interface{}, error) {
1001
    if err := self.checkRaw(); err != nil {
1002
        return nil, err
1003
    }
1004
    switch self.t {
1005
        case V_ERROR         : return nil, self.Check()
1006
        case types.V_NULL    : return nil, nil
1007
        case types.V_TRUE    : return true, nil
1008
        case types.V_FALSE   : return false, nil
1009
        case types.V_ARRAY   : return self.toGenericArray()
1010
        case types.V_OBJECT  : return self.toGenericObject()
1011
        case types.V_STRING  : return self.toString(), nil
1012
        case _V_NUMBER       : 
1013
            v, err := self.toFloat64()
1014
            if err != nil {
1015
                return nil, err
1016
            }
1017
            return v, nil
1018
        case _V_ARRAY_LAZY   :
1019
            if err := self.loadAllIndex(); err != nil {
1020
                return nil, err
1021
            }
1022
            return self.toGenericArray()
1023
        case _V_OBJECT_LAZY  :
1024
            if err := self.loadAllKey(); err != nil {
1025
                return nil, err
1026
            }
1027
            return self.toGenericObject()
1028
        case _V_ANY:
1029
            switch v := self.packAny().(type) {
1030
                case Node : return v.Interface()
1031
                case *Node: return v.Interface()
1032
                default   : return v, nil
1033
            }
1034
        default              : return nil,  ErrUnsupportType
1035
    }
1036
}
1037

1038
func (self *Node) packAny() interface{} {
1039
    return *(*interface{})(self.p)
1040
}
1041

1042
// InterfaceUseNumber works same with Interface()
1043
// except numberic nodes  are casted to json.Number
1044
func (self *Node) InterfaceUseNumber() (interface{}, error) {
1045
    if err := self.checkRaw(); err != nil {
1046
        return nil, err
1047
    }
1048
    switch self.t {
1049
        case V_ERROR         : return nil, self.Check()
1050
        case types.V_NULL    : return nil, nil
1051
        case types.V_TRUE    : return true, nil
1052
        case types.V_FALSE   : return false, nil
1053
        case types.V_ARRAY   : return self.toGenericArrayUseNumber()
1054
        case types.V_OBJECT  : return self.toGenericObjectUseNumber()
1055
        case types.V_STRING  : return self.toString(), nil
1056
        case _V_NUMBER       : return self.toNumber(), nil
1057
        case _V_ARRAY_LAZY   :
1058
            if err := self.loadAllIndex(); err != nil {
1059
                return nil, err
1060
            }
1061
            return self.toGenericArrayUseNumber()
1062
        case _V_OBJECT_LAZY  :
1063
            if err := self.loadAllKey(); err != nil {
1064
                return nil, err
1065
            }
1066
            return self.toGenericObjectUseNumber()
1067
        case _V_ANY          : return self.packAny(), nil
1068
        default              : return nil, ErrUnsupportType
1069
    }
1070
}
1071

1072
// InterfaceUseNode clone itself as a new node, 
1073
// or its children as map[string]Node (or []Node)
1074
func (self *Node) InterfaceUseNode() (interface{}, error) {
1075
    if err := self.checkRaw(); err != nil {
1076
        return nil, err
1077
    }
1078
    switch self.t {
1079
        case types.V_ARRAY   : return self.toGenericArrayUseNode()
1080
        case types.V_OBJECT  : return self.toGenericObjectUseNode()
1081
        case _V_ARRAY_LAZY   :
1082
            if err := self.skipAllIndex(); err != nil {
1083
                return nil, err
1084
            }
1085
            return self.toGenericArrayUseNode()
1086
        case _V_OBJECT_LAZY  :
1087
            if err := self.skipAllKey(); err != nil {
1088
                return nil, err
1089
            }
1090
            return self.toGenericObjectUseNode()
1091
        default              : return *self, self.Check()
1092
    }
1093
}
1094

1095
// LoadAll loads all the node's children and children's children as parsed.
1096
// After calling it, the node can be safely used on concurrency
1097
func (self *Node) LoadAll() error {
1098
    if self.IsRaw() {
1099
        self.parseRaw(true)
1100
        return self.Check()
1101
    }
1102

1103
    switch self.itype() {
1104
    case types.V_ARRAY:
1105
        e := self.len()
1106
        if err := self.loadAllIndex(); err != nil {
1107
            return err
1108
        }
1109
        for i := 0; i < e; i++ {
1110
            n := self.nodeAt(i)
1111
            if n.IsRaw() {
1112
                n.parseRaw(true)
1113
            }
1114
            if err := n.Check(); err != nil {
1115
                return err
1116
            }
1117
        }
1118
        return nil
1119
    case types.V_OBJECT:
1120
        e := self.len()
1121
        if err := self.loadAllKey(); err != nil {
1122
            return err
1123
        }
1124
        for i := 0; i < e; i++ {
1125
            n := self.pairAt(i)
1126
            if n.Value.IsRaw() {
1127
                n.Value.parseRaw(true)
1128
            }
1129
            if err := n.Value.Check(); err != nil {
1130
                return err
1131
            }
1132
        }
1133
        return nil
1134
    default:
1135
        return self.Check()
1136
    }
1137
}
1138

1139
// Load loads the node's children as parsed.
1140
// After calling it, only the node itself can be used on concurrency (not include its children)
1141
func (self *Node) Load() error {
1142
    if err := self.checkRaw(); err != nil {
1143
        return err
1144
    }
1145

1146
    switch self.t {
1147
    case _V_ARRAY_LAZY:
1148
        return self.skipAllIndex()
1149
    case _V_OBJECT_LAZY:
1150
        return self.skipAllKey()
1151
    default:
1152
        return self.Check()
1153
    }
1154
}
1155

1156
/**---------------------------------- Internal Helper Methods ----------------------------------**/
1157

1158
func (self *Node) should(t types.ValueType, s string) error {
1159
    if err := self.checkRaw(); err != nil {
1160
        return err
1161
    }
1162
    if  self.itype() != t {
1163
        return ErrUnsupportType
1164
    }
1165
    return nil
1166
}
1167

1168
func (self *Node) nodeAt(i int) *Node {
1169
    var p *linkedNodes
1170
    if self.isLazy() {
1171
        _, stack := self.getParserAndArrayStack()
1172
        p = &stack.v
1173
    } else {
1174
        p = (*linkedNodes)(self.p)
1175
    }
1176
    return p.At(i)
1177
}
1178

1179
func (self *Node) pairAt(i int) *Pair {
1180
    var p *linkedPairs
1181
    if self.isLazy() {
1182
        _, stack := self.getParserAndObjectStack()
1183
        p = &stack.v
1184
    } else {
1185
        p = (*linkedPairs)(self.p)
1186
    }
1187
    return p.At(i)
1188
}
1189

1190
func (self *Node) skipAllIndex() error {
1191
    if !self.isLazy() {
1192
        return nil
1193
    }
1194
    var err types.ParsingError
1195
    parser, stack := self.getParserAndArrayStack()
1196
    parser.skipValue = true
1197
    parser.noLazy = true
1198
    *self, err = parser.decodeArray(&stack.v)
1199
    if err != 0 {
1200
        return parser.ExportError(err)
1201
    }
1202
    return nil
1203
}
1204

1205
func (self *Node) skipAllKey() error {
1206
    if !self.isLazy() {
1207
        return nil
1208
    }
1209
    var err types.ParsingError
1210
    parser, stack := self.getParserAndObjectStack()
1211
    parser.skipValue = true
1212
    parser.noLazy = true
1213
    *self, err = parser.decodeObject(&stack.v)
1214
    if err != 0 {
1215
        return parser.ExportError(err)
1216
    }
1217
    return nil
1218
}
1219

1220
func (self *Node) skipKey(key string) (*Node, int) {
1221
    nb := self.len()
1222
    lazy := self.isLazy()
1223

1224
    if nb > 0 {
1225
        /* linear search */
1226
        var p *Pair
1227
        var i int
1228
        if lazy {
1229
            s := (*parseObjectStack)(self.p)
1230
            p, i = s.v.Get(key)
1231
        } else {
1232
            p, i = (*linkedPairs)(self.p).Get(key)
1233
        }
1234

1235
        if p != nil {
1236
            return &p.Value, i
1237
        }
1238
    }
1239

1240
    /* not found */
1241
    if !lazy {
1242
        return nil, -1
1243
    }
1244

1245
    // lazy load
1246
    for last, i := self.skipNextPair(), nb; last != nil; last, i = self.skipNextPair(), i+1 {
1247
        if last.Value.Check() != nil {
1248
            return &last.Value, -1
1249
        }
1250
        if last.Key == key {
1251
            return &last.Value, i
1252
        }
1253
    }
1254

1255
    return nil, -1
1256
}
1257

1258
func (self *Node) skipIndex(index int) *Node {
1259
    nb := self.len()
1260
    if nb > index {
1261
        v := self.nodeAt(index)
1262
        return v
1263
    }
1264
    if !self.isLazy() {
1265
        return nil
1266
    }
1267

1268
    // lazy load
1269
    for last := self.skipNextNode(); last != nil; last = self.skipNextNode(){
1270
        if last.Check() != nil {
1271
            return last
1272
        }
1273
        if self.len() > index {
1274
            return last
1275
        }
1276
    }
1277

1278
    return nil
1279
}
1280

1281
func (self *Node) skipIndexPair(index int) *Pair {
1282
    nb := self.len()
1283
    if nb > index {
1284
        return self.pairAt(index)
1285
    }
1286
    if !self.isLazy() {
1287
        return nil
1288
    }
1289

1290
    // lazy load
1291
    for last := self.skipNextPair(); last != nil; last = self.skipNextPair(){
1292
        if last.Value.Check() != nil {
1293
            return last
1294
        }
1295
        if self.len() > index {
1296
            return last
1297
        }
1298
    }
1299

1300
    return nil
1301
}
1302

1303
func (self *Node) loadAllIndex() error {
1304
    if !self.isLazy() {
1305
        return nil
1306
    }
1307
    var err types.ParsingError
1308
    parser, stack := self.getParserAndArrayStack()
1309
    parser.noLazy = true
1310
    *self, err = parser.decodeArray(&stack.v)
1311
    if err != 0 {
1312
        return parser.ExportError(err)
1313
    }
1314
    return nil
1315
}
1316

1317
func (self *Node) loadAllKey() error {
1318
    if !self.isLazy() {
1319
        return nil
1320
    }
1321
    var err types.ParsingError
1322
    parser, stack := self.getParserAndObjectStack()
1323
    parser.noLazy = true
1324
    *self, err = parser.decodeObject(&stack.v)
1325
    if err != 0 {
1326
        return parser.ExportError(err)
1327
    }
1328
    return nil
1329
}
1330

1331
func (self *Node) removeNode(i int) {
1332
    node := self.nodeAt(i)
1333
    if node == nil {
1334
        return
1335
    }
1336
    *node = Node{}
1337
    // NOTICE: for consistency with linkedNodes, we DOSEN'T reduce size here
1338
    // self.l--
1339
}
1340

1341
func (self *Node) removePair(i int) {
1342
    last := self.pairAt(i)
1343
    if last == nil {
1344
        return
1345
    }
1346
    *last = Pair{}
1347
    // NOTICE: for consistency with linkedNodes, we DOSEN'T reduce size here
1348
    // self.l--
1349
}
1350

1351
func (self *Node) toGenericArray() ([]interface{}, error) {
1352
    nb := self.len()
1353
    if nb == 0 {
1354
        return []interface{}{}, nil
1355
    }
1356
    ret := make([]interface{}, nb)
1357
    
1358
    /* convert each item */
1359
    var s = (*linkedNodes)(self.p)
1360
    for i := 0; i < nb; i++ {
1361
        p := s.At(i)
1362
        x, err := p.Interface()
1363
        if err != nil {
1364
            return nil, err
1365
        }
1366
        ret[i] = x
1367
    }
1368

1369
    /* all done */
1370
    return ret, nil
1371
}
1372

1373
func (self *Node) toGenericArrayUseNumber() ([]interface{}, error) {
1374
    nb := self.len()
1375
    if nb == 0 {
1376
        return []interface{}{}, nil
1377
    }
1378
    ret := make([]interface{}, nb)
1379

1380
    /* convert each item */
1381
    var s = (*linkedNodes)(self.p)
1382
    for i := 0; i < nb; i++ {
1383
        p := s.At(i)
1384
        x, err := p.InterfaceUseNumber()
1385
        if err != nil {
1386
            return nil, err
1387
        }
1388
        ret[i] = x
1389
    }
1390

1391
    /* all done */
1392
    return ret, nil
1393
}
1394

1395
func (self *Node) toGenericArrayUseNode() ([]Node, error) {
1396
    var nb = self.len()
1397
    if nb == 0 {
1398
        return []Node{}, nil
1399
    }
1400

1401
    var s = (*linkedNodes)(self.p)
1402
    var out = make([]Node, nb)
1403
    s.ToSlice(out)
1404

1405
    return out, nil
1406
}
1407

1408
func (self *Node) toGenericObject() (map[string]interface{}, error) {
1409
    nb := self.len()
1410
    if nb == 0 {
1411
        return map[string]interface{}{}, nil
1412
    }
1413
    ret := make(map[string]interface{}, nb)
1414

1415
    /* convert each item */
1416
    var s = (*linkedPairs)(self.p)
1417
    for i := 0; i < nb; i++ {
1418
        p := s.At(i)
1419
        x, err := p.Value.Interface()
1420
        if err != nil {
1421
            return nil, err
1422
        }
1423
        ret[p.Key] = x
1424
    }
1425

1426
    /* all done */
1427
    return ret, nil
1428
}
1429

1430

1431
func (self *Node) toGenericObjectUseNumber() (map[string]interface{}, error) {
1432
    nb := self.len()
1433
    if nb == 0 {
1434
        return map[string]interface{}{}, nil
1435
    }
1436
    ret := make(map[string]interface{}, nb)
1437

1438
    /* convert each item */
1439
    var s = (*linkedPairs)(self.p)
1440
    for i := 0; i < nb; i++ {
1441
        p := s.At(i)
1442
        x, err := p.Value.InterfaceUseNumber()
1443
        if err != nil {
1444
            return nil, err
1445
        }
1446
        ret[p.Key] = x
1447
    }
1448

1449
    /* all done */
1450
    return ret, nil
1451
}
1452

1453
func (self *Node) toGenericObjectUseNode() (map[string]Node, error) {
1454
    var nb = self.len()
1455
    if nb == 0 {
1456
        return map[string]Node{}, nil
1457
    }
1458

1459
    var s = (*linkedPairs)(self.p)
1460
    var out = make(map[string]Node, nb)
1461
    s.ToMap(out)
1462

1463
    /* all done */
1464
    return out, nil
1465
}
1466

1467
/**------------------------------------ Factory Methods ------------------------------------**/
1468

1469
var (
1470
    nullNode  = Node{t: types.V_NULL}
1471
    trueNode  = Node{t: types.V_TRUE}
1472
    falseNode = Node{t: types.V_FALSE}
1473
)
1474

1475
// NewRaw creates a node of raw json.
1476
// If the input json is invalid, NewRaw returns a error Node.
1477
func NewRaw(json string) Node {
1478
    parser := NewParserObj(json)
1479
    start, err := parser.skip()
1480
    if err != 0 {
1481
        return *newError(err, err.Message()) 
1482
    }
1483
    it := switchRawType(parser.s[start])
1484
    if it == _V_NONE {
1485
        return Node{}
1486
    }
1487
    return newRawNode(parser.s[start:parser.p], it)
1488
}
1489

1490
// NewAny creates a node of type V_ANY if any's type isn't Node or *Node, 
1491
// which stores interface{} and can be only used for `.Interface()`\`.MarshalJSON()`.
1492
func NewAny(any interface{}) Node {
1493
    switch n := any.(type) {
1494
    case Node:
1495
        return n
1496
    case *Node:
1497
        return *n
1498
    default:
1499
        return Node{
1500
            t: _V_ANY,
1501
            p: unsafe.Pointer(&any),
1502
        }
1503
    }
1504
}
1505

1506
// NewBytes encodes given src with Base64 (RFC 4648), and creates a node of type V_STRING.
1507
func NewBytes(src []byte) Node {
1508
    if len(src) == 0 {
1509
        panic("empty src bytes")
1510
    }
1511
    out := encodeBase64(src)
1512
    return NewString(out)
1513
}
1514

1515
// NewNull creates a node of type V_NULL
1516
func NewNull() Node {
1517
    return Node{
1518
        p: nil,
1519
        t: types.V_NULL,
1520
    }
1521
}
1522

1523
// NewBool creates a node of type bool:
1524
//  If v is true, returns V_TRUE node
1525
//  If v is false, returns V_FALSE node
1526
func NewBool(v bool) Node {
1527
    var t = types.V_FALSE
1528
    if v {
1529
        t = types.V_TRUE
1530
    }
1531
    return Node{
1532
        p: nil,
1533
        t: t,
1534
    }
1535
}
1536

1537
// NewNumber creates a json.Number node
1538
// v must be a decimal string complying with RFC8259
1539
func NewNumber(v string) Node {
1540
    return Node{
1541
        l: uint(len(v)),
1542
        p: rt.StrPtr(v),
1543
        t: _V_NUMBER,
1544
    }
1545
}
1546

1547
func (node Node) toNumber() json.Number {
1548
    return json.Number(rt.StrFrom(node.p, int64(node.l)))
1549
}
1550

1551
func (self Node) toString() string {
1552
    return rt.StrFrom(self.p, int64(self.l))
1553
}
1554

1555
func (node Node) toFloat64() (float64, error) {
1556
    ret, err := node.toNumber().Float64()
1557
    if err != nil {
1558
        return 0, err
1559
    }
1560
    return ret, nil
1561
}
1562

1563
func (node Node) toInt64() (int64, error) {
1564
    ret,err := node.toNumber().Int64()
1565
    if err != nil {
1566
        return 0, err
1567
    }
1568
    return ret, nil
1569
}
1570

1571
func newBytes(v []byte) Node {
1572
    return Node{
1573
        t: types.V_STRING,
1574
        p: mem2ptr(v),
1575
        l: uint(len(v)),
1576
    }
1577
}
1578

1579
// NewString creates a node of type V_STRING. 
1580
// v is considered to be a valid UTF-8 string,
1581
// which means it won't be validated and unescaped.
1582
// when the node is encoded to json, v will be escaped.
1583
func NewString(v string) Node {
1584
    return Node{
1585
        t: types.V_STRING,
1586
        p: rt.StrPtr(v),
1587
        l: uint(len(v)),
1588
    }
1589
}
1590

1591
// NewArray creates a node of type V_ARRAY,
1592
// using v as its underlying children
1593
func NewArray(v []Node) Node {
1594
    s := new(linkedNodes)
1595
    s.FromSlice(v)
1596
    return newArray(s)
1597
}
1598

1599
func newArray(v *linkedNodes) Node {
1600
    return Node{
1601
        t: types.V_ARRAY,
1602
        l: uint(v.Len()),
1603
        p: unsafe.Pointer(v),
1604
    }
1605
}
1606

1607
func (self *Node) setArray(v *linkedNodes) {
1608
    self.t = types.V_ARRAY
1609
    self.l = uint(v.Len())
1610
    self.p = unsafe.Pointer(v)
1611
}
1612

1613
// NewObject creates a node of type V_OBJECT,
1614
// using v as its underlying children
1615
func NewObject(v []Pair) Node {
1616
    s := new(linkedPairs)
1617
    s.FromSlice(v)
1618
    return newObject(s)
1619
}
1620

1621
func newObject(v *linkedPairs) Node {
1622
    return Node{
1623
        t: types.V_OBJECT,
1624
        l: uint(v.Len()),
1625
        p: unsafe.Pointer(v),
1626
    }
1627
}
1628

1629
func (self *Node) setObject(v *linkedPairs) {
1630
    self.t = types.V_OBJECT
1631
    self.l = uint(v.Len())
1632
    self.p = unsafe.Pointer(v)
1633
}
1634

1635
func newRawNode(str string, typ types.ValueType) Node {
1636
    return Node{
1637
        t: _V_RAW | typ,
1638
        p: rt.StrPtr(str),
1639
        l: uint(len(str)),
1640
    }
1641
}
1642

1643
func (self *Node) parseRaw(full bool) {
1644
    raw := self.toString()
1645
    parser := NewParserObj(raw)
1646
    if full {
1647
        parser.noLazy = true
1648
        parser.skipValue = false
1649
    }
1650
    var e types.ParsingError
1651
    *self, e = parser.Parse()
1652
    if e != 0 {
1653
        *self = *newSyntaxError(parser.syntaxError(e))
1654
    }
1655
}
1656

1657
var typeJumpTable = [256]types.ValueType{
1658
    '"' : types.V_STRING,
1659
    '-' : _V_NUMBER,
1660
    '0' : _V_NUMBER,
1661
    '1' : _V_NUMBER,
1662
    '2' : _V_NUMBER,
1663
    '3' : _V_NUMBER,
1664
    '4' : _V_NUMBER,
1665
    '5' : _V_NUMBER,
1666
    '6' : _V_NUMBER,
1667
    '7' : _V_NUMBER,
1668
    '8' : _V_NUMBER,
1669
    '9' : _V_NUMBER,
1670
    '[' : types.V_ARRAY,
1671
    'f' : types.V_FALSE,
1672
    'n' : types.V_NULL,
1673
    't' : types.V_TRUE,
1674
    '{' : types.V_OBJECT,
1675
}
1676

1677
func switchRawType(c byte) types.ValueType {
1678
    return typeJumpTable[c]
1679
}
1680