node.go raw
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 "sync"
24 "sync/atomic"
25 "unsafe"
26
27 "github.com/bytedance/sonic/internal/native/types"
28 "github.com/bytedance/sonic/internal/rt"
29 )
30
31 const (
32 _V_NONE types.ValueType = 0
33 _V_NODE_BASE types.ValueType = 1 << 5
34 _V_LAZY types.ValueType = 1 << 7
35 _V_RAW types.ValueType = 1 << 8
36 _V_NUMBER = _V_NODE_BASE + 1
37 _V_ANY = _V_NODE_BASE + 2
38 _V_ARRAY_LAZY = _V_LAZY | types.V_ARRAY
39 _V_OBJECT_LAZY = _V_LAZY | types.V_OBJECT
40 _MASK_LAZY = _V_LAZY - 1
41 _MASK_RAW = _V_RAW - 1
42 )
43
44 const (
45 V_NONE = 0
46 V_ERROR = 1
47 V_NULL = int(types.V_NULL)
48 V_TRUE = int(types.V_TRUE)
49 V_FALSE = int(types.V_FALSE)
50 V_ARRAY = int(types.V_ARRAY)
51 V_OBJECT = int(types.V_OBJECT)
52 V_STRING = int(types.V_STRING)
53 V_NUMBER = int(_V_NUMBER)
54 V_ANY = int(_V_ANY)
55 )
56
57 type Node struct {
58 t types.ValueType
59 l uint
60 p unsafe.Pointer
61 m *sync.RWMutex
62 }
63
64 // UnmarshalJSON is just an adapter to json.Unmarshaler.
65 // If you want better performance, use Searcher.GetByPath() directly
66 func (self *Node) UnmarshalJSON(data []byte) (err error) {
67 *self = NewRaw(string(data))
68 return self.Check()
69 }
70
71 /** Node Type Accessor **/
72
73 // Type returns json type represented by the node
74 // It will be one of bellows:
75 // V_NONE = 0 (empty node, key not exists)
76 // V_ERROR = 1 (error node)
77 // V_NULL = 2 (json value `null`, key exists)
78 // V_TRUE = 3 (json value `true`)
79 // V_FALSE = 4 (json value `false`)
80 // V_ARRAY = 5 (json value array)
81 // V_OBJECT = 6 (json value object)
82 // V_STRING = 7 (json value string)
83 // V_NUMBER = 33 (json value number )
84 // V_ANY = 34 (golang interface{})
85 //
86 // Deprecated: not concurrent safe. Use TypeSafe instead
87 func (self Node) Type() int {
88 return int(self.t & _MASK_LAZY & _MASK_RAW)
89 }
90
91 // Type concurrently-safe returns json type represented by the node
92 // It will be one of bellows:
93 // V_NONE = 0 (empty node, key not exists)
94 // V_ERROR = 1 (error node)
95 // V_NULL = 2 (json value `null`, key exists)
96 // V_TRUE = 3 (json value `true`)
97 // V_FALSE = 4 (json value `false`)
98 // V_ARRAY = 5 (json value array)
99 // V_OBJECT = 6 (json value object)
100 // V_STRING = 7 (json value string)
101 // V_NUMBER = 33 (json value number )
102 // V_ANY = 34 (golang interface{})
103 func (self *Node) TypeSafe() int {
104 return int(self.loadt() & _MASK_LAZY & _MASK_RAW)
105 }
106
107 func (self *Node) itype() types.ValueType {
108 return self.t & _MASK_LAZY & _MASK_RAW
109 }
110
111 // Exists returns false only if the self is nil or empty node V_NONE
112 func (self *Node) Exists() bool {
113 if self == nil {
114 return false
115 }
116 t := self.loadt()
117 return t != V_ERROR && t != _V_NONE
118 }
119
120 // Valid reports if self is NOT V_ERROR or nil
121 func (self *Node) Valid() bool {
122 if self == nil {
123 return false
124 }
125 return self.loadt() != V_ERROR
126 }
127
128 // Check checks if the node itself is valid, and return:
129 // - ErrNotExist If the node is nil
130 // - Its underlying error If the node is V_ERROR
131 func (self *Node) Check() error {
132 if self == nil {
133 return ErrNotExist
134 } else if self.loadt() != V_ERROR {
135 return nil
136 } else {
137 return self
138 }
139 }
140
141 // isRaw returns true if node's underlying value is raw json
142 //
143 // Deprecated: not concurrent safe
144 func (self Node) IsRaw() bool {
145 return self.t & _V_RAW != 0
146 }
147
148 // IsRaw returns true if node's underlying value is raw json
149 func (self *Node) isRaw() bool {
150 return self.loadt() & _V_RAW != 0
151 }
152
153 func (self *Node) isLazy() bool {
154 return self != nil && self.t & _V_LAZY != 0
155 }
156
157 func (self *Node) isAny() bool {
158 return self != nil && self.loadt() == _V_ANY
159 }
160
161 /** Simple Value Methods **/
162
163 // Raw returns json representation of the node,
164 func (self *Node) Raw() (string, error) {
165 if self == nil {
166 return "", ErrNotExist
167 }
168 lock := self.rlock()
169 if !self.isRaw() {
170 if lock {
171 self.runlock()
172 }
173 buf, err := self.MarshalJSON()
174 return rt.Mem2Str(buf), err
175 }
176 ret := self.toString()
177 if lock {
178 self.runlock()
179 }
180 return ret, nil
181 }
182
183 func (self *Node) checkRaw() error {
184 if err := self.Check(); err != nil {
185 return err
186 }
187 if self.isRaw() {
188 self.parseRaw(false)
189 }
190 return self.Check()
191 }
192
193 // Bool returns bool value represented by this node,
194 // including types.V_TRUE|V_FALSE|V_NUMBER|V_STRING|V_ANY|V_NULL,
195 // V_NONE will return error
196 func (self *Node) Bool() (bool, error) {
197 if err := self.checkRaw(); err != nil {
198 return false, err
199 }
200 switch self.t {
201 case types.V_TRUE : return true , nil
202 case types.V_FALSE : return false, nil
203 case types.V_NULL : return false, nil
204 case _V_NUMBER :
205 if i, err := self.toInt64(); err == nil {
206 return i != 0, nil
207 } else if f, err := self.toFloat64(); err == nil {
208 return f != 0, nil
209 } else {
210 return false, err
211 }
212 case types.V_STRING: return strconv.ParseBool(self.toString())
213 case _V_ANY :
214 any := self.packAny()
215 switch v := any.(type) {
216 case bool : return v, nil
217 case int : return v != 0, nil
218 case int8 : return v != 0, nil
219 case int16 : return v != 0, nil
220 case int32 : return v != 0, nil
221 case int64 : return v != 0, nil
222 case uint : return v != 0, nil
223 case uint8 : return v != 0, nil
224 case uint16 : return v != 0, nil
225 case uint32 : return v != 0, nil
226 case uint64 : return v != 0, nil
227 case float32: return v != 0, nil
228 case float64: return v != 0, nil
229 case string : return strconv.ParseBool(v)
230 case json.Number:
231 if i, err := v.Int64(); err == nil {
232 return i != 0, nil
233 } else if f, err := v.Float64(); err == nil {
234 return f != 0, nil
235 } else {
236 return false, err
237 }
238 default: return false, ErrUnsupportType
239 }
240 default : return false, ErrUnsupportType
241 }
242 }
243
244 // Int64 casts the node to int64 value,
245 // including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING
246 // V_NONE it will return error
247 func (self *Node) Int64() (int64, error) {
248 if err := self.checkRaw(); err != nil {
249 return 0, err
250 }
251 switch self.t {
252 case _V_NUMBER, types.V_STRING :
253 if i, err := self.toInt64(); err == nil {
254 return i, nil
255 } else if f, err := self.toFloat64(); err == nil {
256 return int64(f), nil
257 } else {
258 return 0, err
259 }
260 case types.V_TRUE : return 1, nil
261 case types.V_FALSE : return 0, nil
262 case types.V_NULL : return 0, nil
263 case _V_ANY :
264 any := self.packAny()
265 switch v := any.(type) {
266 case bool : if v { return 1, nil } else { return 0, nil }
267 case int : return int64(v), nil
268 case int8 : return int64(v), nil
269 case int16 : return int64(v), nil
270 case int32 : return int64(v), nil
271 case int64 : return int64(v), nil
272 case uint : return int64(v), nil
273 case uint8 : return int64(v), nil
274 case uint16 : return int64(v), nil
275 case uint32 : return int64(v), nil
276 case uint64 : return int64(v), nil
277 case float32: return int64(v), nil
278 case float64: return int64(v), nil
279 case string :
280 if i, err := strconv.ParseInt(v, 10, 64); err == nil {
281 return i, nil
282 } else if f, err := strconv.ParseFloat(v, 64); err == nil {
283 return int64(f), nil
284 } else {
285 return 0, err
286 }
287 case json.Number:
288 if i, err := v.Int64(); err == nil {
289 return i, nil
290 } else if f, err := v.Float64(); err == nil {
291 return int64(f), nil
292 } else {
293 return 0, err
294 }
295 default: return 0, ErrUnsupportType
296 }
297 default : return 0, ErrUnsupportType
298 }
299 }
300
301 // StrictInt64 exports underlying int64 value, including V_NUMBER, V_ANY
302 func (self *Node) StrictInt64() (int64, error) {
303 if err := self.checkRaw(); err != nil {
304 return 0, err
305 }
306 switch self.t {
307 case _V_NUMBER : return self.toInt64()
308 case _V_ANY :
309 any := self.packAny()
310 switch v := any.(type) {
311 case int : return int64(v), nil
312 case int8 : return int64(v), nil
313 case int16 : return int64(v), nil
314 case int32 : return int64(v), nil
315 case int64 : return int64(v), nil
316 case uint : return int64(v), nil
317 case uint8 : return int64(v), nil
318 case uint16: return int64(v), nil
319 case uint32: return int64(v), nil
320 case uint64: return int64(v), nil
321 case json.Number:
322 if i, err := v.Int64(); err == nil {
323 return i, nil
324 } else {
325 return 0, err
326 }
327 default: return 0, ErrUnsupportType
328 }
329 default : return 0, ErrUnsupportType
330 }
331 }
332
333 func castNumber(v bool) json.Number {
334 if v {
335 return json.Number("1")
336 } else {
337 return json.Number("0")
338 }
339 }
340
341 // Number casts node to float64,
342 // including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING|V_NULL,
343 // V_NONE it will return error
344 func (self *Node) Number() (json.Number, error) {
345 if err := self.checkRaw(); err != nil {
346 return json.Number(""), err
347 }
348 switch self.t {
349 case _V_NUMBER : return self.toNumber(), nil
350 case types.V_STRING :
351 if _, err := self.toInt64(); err == nil {
352 return self.toNumber(), nil
353 } else if _, err := self.toFloat64(); err == nil {
354 return self.toNumber(), nil
355 } else {
356 return json.Number(""), err
357 }
358 case types.V_TRUE : return json.Number("1"), nil
359 case types.V_FALSE : return json.Number("0"), nil
360 case types.V_NULL : return json.Number("0"), nil
361 case _V_ANY :
362 any := self.packAny()
363 switch v := any.(type) {
364 case bool : return castNumber(v), nil
365 case int : return castNumber(v != 0), nil
366 case int8 : return castNumber(v != 0), nil
367 case int16 : return castNumber(v != 0), nil
368 case int32 : return castNumber(v != 0), nil
369 case int64 : return castNumber(v != 0), nil
370 case uint : return castNumber(v != 0), nil
371 case uint8 : return castNumber(v != 0), nil
372 case uint16 : return castNumber(v != 0), nil
373 case uint32 : return castNumber(v != 0), nil
374 case uint64 : return castNumber(v != 0), nil
375 case float32: return castNumber(v != 0), nil
376 case float64: return castNumber(v != 0), nil
377 case string :
378 if _, err := strconv.ParseFloat(v, 64); err == nil {
379 return json.Number(v), nil
380 } else {
381 return json.Number(""), err
382 }
383 case json.Number: return v, nil
384 default: return json.Number(""), ErrUnsupportType
385 }
386 default : return json.Number(""), ErrUnsupportType
387 }
388 }
389
390 // Number exports underlying float64 value, including V_NUMBER, V_ANY of json.Number
391 func (self *Node) StrictNumber() (json.Number, error) {
392 if err := self.checkRaw(); err != nil {
393 return json.Number(""), err
394 }
395 switch self.t {
396 case _V_NUMBER : return self.toNumber() , nil
397 case _V_ANY :
398 if v, ok := self.packAny().(json.Number); ok {
399 return v, nil
400 } else {
401 return json.Number(""), ErrUnsupportType
402 }
403 default : return json.Number(""), ErrUnsupportType
404 }
405 }
406
407 // String cast node to string,
408 // including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING|V_NULL,
409 // V_NONE it will return error
410 func (self *Node) String() (string, error) {
411 if err := self.checkRaw(); err != nil {
412 return "", err
413 }
414 switch self.t {
415 case types.V_NULL : return "" , nil
416 case types.V_TRUE : return "true" , nil
417 case types.V_FALSE : return "false", nil
418 case types.V_STRING, _V_NUMBER : return self.toString(), nil
419 case _V_ANY :
420 any := self.packAny()
421 switch v := any.(type) {
422 case bool : return strconv.FormatBool(v), nil
423 case int : return strconv.Itoa(v), nil
424 case int8 : return strconv.Itoa(int(v)), nil
425 case int16 : return strconv.Itoa(int(v)), nil
426 case int32 : return strconv.Itoa(int(v)), nil
427 case int64 : return strconv.Itoa(int(v)), nil
428 case uint : return strconv.Itoa(int(v)), nil
429 case uint8 : return strconv.Itoa(int(v)), nil
430 case uint16 : return strconv.Itoa(int(v)), nil
431 case uint32 : return strconv.Itoa(int(v)), nil
432 case uint64 : return strconv.Itoa(int(v)), nil
433 case float32: return strconv.FormatFloat(float64(v), 'g', -1, 64), nil
434 case float64: return strconv.FormatFloat(float64(v), 'g', -1, 64), nil
435 case string : return v, nil
436 case json.Number: return v.String(), nil
437 default: return "", ErrUnsupportType
438 }
439 default : return "" , ErrUnsupportType
440 }
441 }
442
443 // StrictString returns string value (unescaped), including V_STRING, V_ANY of string.
444 // In other cases, it will return empty string.
445 func (self *Node) StrictString() (string, error) {
446 if err := self.checkRaw(); err != nil {
447 return "", err
448 }
449 switch self.t {
450 case types.V_STRING : return self.toString(), nil
451 case _V_ANY :
452 if v, ok := self.packAny().(string); ok {
453 return v, nil
454 } else {
455 return "", ErrUnsupportType
456 }
457 default : return "", ErrUnsupportType
458 }
459 }
460
461 // Float64 cast node to float64,
462 // including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING|V_NULL,
463 // V_NONE it will return error
464 func (self *Node) Float64() (float64, error) {
465 if err := self.checkRaw(); err != nil {
466 return 0.0, err
467 }
468 switch self.t {
469 case _V_NUMBER, types.V_STRING : return self.toFloat64()
470 case types.V_TRUE : return 1.0, nil
471 case types.V_FALSE : return 0.0, nil
472 case types.V_NULL : return 0.0, nil
473 case _V_ANY :
474 any := self.packAny()
475 switch v := any.(type) {
476 case bool :
477 if v {
478 return 1.0, nil
479 } else {
480 return 0.0, nil
481 }
482 case int : return float64(v), nil
483 case int8 : return float64(v), nil
484 case int16 : return float64(v), nil
485 case int32 : return float64(v), nil
486 case int64 : return float64(v), nil
487 case uint : return float64(v), nil
488 case uint8 : return float64(v), nil
489 case uint16 : return float64(v), nil
490 case uint32 : return float64(v), nil
491 case uint64 : return float64(v), nil
492 case float32: return float64(v), nil
493 case float64: return float64(v), nil
494 case string :
495 if f, err := strconv.ParseFloat(v, 64); err == nil {
496 return float64(f), nil
497 } else {
498 return 0, err
499 }
500 case json.Number:
501 if f, err := v.Float64(); err == nil {
502 return float64(f), nil
503 } else {
504 return 0, err
505 }
506 default : return 0, ErrUnsupportType
507 }
508 default : return 0.0, ErrUnsupportType
509 }
510 }
511
512 // Float64 exports underlying float64 value, including V_NUMBER, V_ANY
513 func (self *Node) StrictFloat64() (float64, error) {
514 if err := self.checkRaw(); err != nil {
515 return 0.0, err
516 }
517 switch self.t {
518 case _V_NUMBER : return self.toFloat64()
519 case _V_ANY :
520 any := self.packAny()
521 switch v := any.(type) {
522 case float32 : return float64(v), nil
523 case float64 : return float64(v), nil
524 default : return 0, ErrUnsupportType
525 }
526 default : return 0.0, ErrUnsupportType
527 }
528 }
529
530 /** Sequential Value Methods **/
531
532 // Len returns children count of a array|object|string node
533 // WARN: For partially loaded node, it also works but only counts the parsed children
534 func (self *Node) Len() (int, error) {
535 if err := self.checkRaw(); err != nil {
536 return 0, err
537 }
538 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 {
539 return int(self.l), nil
540 } else if self.t == _V_NONE || self.t == types.V_NULL {
541 return 0, nil
542 } else {
543 return 0, ErrUnsupportType
544 }
545 }
546
547 func (self *Node) len() int {
548 return int(self.l)
549 }
550
551 // Cap returns malloc capacity of a array|object node for children
552 func (self *Node) Cap() (int, error) {
553 if err := self.checkRaw(); err != nil {
554 return 0, err
555 }
556 switch self.t {
557 case types.V_ARRAY: return (*linkedNodes)(self.p).Cap(), nil
558 case types.V_OBJECT: return (*linkedPairs)(self.p).Cap(), nil
559 case _V_ARRAY_LAZY: return (*parseArrayStack)(self.p).v.Cap(), nil
560 case _V_OBJECT_LAZY: return (*parseObjectStack)(self.p).v.Cap(), nil
561 case _V_NONE, types.V_NULL: return 0, nil
562 default: return 0, ErrUnsupportType
563 }
564 }
565
566 // Set sets the node of given key under self, and reports if the key has existed.
567 //
568 // If self is V_NONE or V_NULL, it becomes V_OBJECT and sets the node at the key.
569 func (self *Node) Set(key string, node Node) (bool, error) {
570 if err := self.checkRaw(); err != nil {
571 return false, err
572 }
573 if err := node.Check(); err != nil {
574 return false, err
575 }
576
577 if self.t == _V_NONE || self.t == types.V_NULL {
578 *self = NewObject([]Pair{NewPair(key, node)})
579 return false, nil
580 } else if self.itype() != types.V_OBJECT {
581 return false, ErrUnsupportType
582 }
583
584 p := self.Get(key)
585
586 if !p.Exists() {
587 // self must be fully-loaded here
588 if self.len() == 0 {
589 *self = newObject(new(linkedPairs))
590 }
591 s := (*linkedPairs)(self.p)
592 s.Push(NewPair(key, node))
593 self.l++
594 return false, nil
595
596 } else if err := p.Check(); err != nil {
597 return false, err
598 }
599
600 *p = node
601 return true, nil
602 }
603
604 // SetAny wraps val with V_ANY node, and Set() the node.
605 func (self *Node) SetAny(key string, val interface{}) (bool, error) {
606 return self.Set(key, NewAny(val))
607 }
608
609 // Unset REMOVE (soft) the node of given key under object parent, and reports if the key has existed.
610 func (self *Node) Unset(key string) (bool, error) {
611 if err := self.should(types.V_OBJECT); err != nil {
612 return false, err
613 }
614 // NOTICE: must get accurate length before deduct
615 if err := self.skipAllKey(); err != nil {
616 return false, err
617 }
618 p, i := self.skipKey(key)
619 if !p.Exists() {
620 return false, nil
621 } else if err := p.Check(); err != nil {
622 return false, err
623 }
624 self.removePairAt(i)
625 return true, nil
626 }
627
628 // SetByIndex sets the node of given index, and reports if the key has existed.
629 //
630 // The index must be within self's children.
631 func (self *Node) SetByIndex(index int, node Node) (bool, error) {
632 if err := self.checkRaw(); err != nil {
633 return false, err
634 }
635 if err := node.Check(); err != nil {
636 return false, err
637 }
638
639 if index == 0 && (self.t == _V_NONE || self.t == types.V_NULL) {
640 *self = NewArray([]Node{node})
641 return false, nil
642 }
643
644 p := self.Index(index)
645 if !p.Exists() {
646 return false, ErrNotExist
647 } else if err := p.Check(); err != nil {
648 return false, err
649 }
650
651 *p = node
652 return true, nil
653 }
654
655 // SetAny wraps val with V_ANY node, and SetByIndex() the node.
656 func (self *Node) SetAnyByIndex(index int, val interface{}) (bool, error) {
657 return self.SetByIndex(index, NewAny(val))
658 }
659
660 // UnsetByIndex REMOVE (softly) the node of given index.
661 //
662 // WARN: this will change address of elements, which is a dangerous action.
663 // Use Unset() for object or Pop() for array instead.
664 func (self *Node) UnsetByIndex(index int) (bool, error) {
665 if err := self.checkRaw(); err != nil {
666 return false, err
667 }
668
669 var p *Node
670 it := self.itype()
671
672 if it == types.V_ARRAY {
673 if err := self.skipAllIndex(); err != nil {
674 return false, err
675 }
676 p = self.nodeAt(index)
677 } else if it == types.V_OBJECT {
678 if err := self.skipAllKey(); err != nil {
679 return false, err
680 }
681 pr := self.pairAt(index)
682 if pr == nil {
683 return false, ErrNotExist
684 }
685 p = &pr.Value
686 } else {
687 return false, ErrUnsupportType
688 }
689
690 if !p.Exists() {
691 return false, ErrNotExist
692 }
693
694 // last elem
695 if index == self.len() - 1 {
696 return true, self.Pop()
697 }
698
699 // not last elem, self.len() change but linked-chunk not change
700 if it == types.V_ARRAY {
701 self.removeNode(index)
702 }else if it == types.V_OBJECT {
703 self.removePair(index)
704 }
705 return true, nil
706 }
707
708 // Add appends the given node under self.
709 //
710 // If self is V_NONE or V_NULL, it becomes V_ARRAY and sets the node at index 0.
711 func (self *Node) Add(node Node) error {
712 if err := self.checkRaw(); err != nil {
713 return err
714 }
715
716 if self != nil && (self.t == _V_NONE || self.t == types.V_NULL) {
717 *self = NewArray([]Node{node})
718 return nil
719 }
720 if err := self.should(types.V_ARRAY); err != nil {
721 return err
722 }
723
724 s, err := self.unsafeArray()
725 if err != nil {
726 return err
727 }
728
729 // Notice: array won't have unset node in tail
730 s.Push(node)
731 self.l++
732 return nil
733 }
734
735 // Pop remove the last child of the V_Array or V_Object node.
736 func (self *Node) Pop() error {
737 if err := self.checkRaw(); err != nil {
738 return err
739 }
740
741 if it := self.itype(); it == types.V_ARRAY {
742 s, err := self.unsafeArray()
743 if err != nil {
744 return err
745 }
746 // remove tail unset nodes
747 for i := s.Len()-1; i >= 0; i-- {
748 if s.At(i).Exists() {
749 s.Pop()
750 self.l--
751 break
752 }
753 s.Pop()
754 }
755
756 } else if it == types.V_OBJECT {
757 s, err := self.unsafeMap()
758 if err != nil {
759 return err
760 }
761 // remove tail unset nodes
762 for i := s.Len()-1; i >= 0; i-- {
763 if p := s.At(i); p != nil && p.Value.Exists() {
764 s.Pop()
765 self.l--
766 break
767 }
768 s.Pop()
769 }
770
771 } else {
772 return ErrUnsupportType
773 }
774
775 return nil
776 }
777
778 // Move moves the child at src index to dst index,
779 // meanwhile slides sliblings from src+1 to dst.
780 //
781 // WARN: this will change address of elements, which is a dangerous action.
782 func (self *Node) Move(dst, src int) error {
783 if err := self.should(types.V_ARRAY); err != nil {
784 return err
785 }
786
787 s, err := self.unsafeArray()
788 if err != nil {
789 return err
790 }
791
792 // check if any unset node exists
793 if l := s.Len(); self.len() != l {
794 di, si := dst, src
795 // find real pos of src and dst
796 for i := 0; i < l; i++ {
797 if s.At(i).Exists() {
798 di--
799 si--
800 }
801 if di == -1 {
802 dst = i
803 di--
804 }
805 if si == -1 {
806 src = i
807 si--
808 }
809 if di == -2 && si == -2 {
810 break
811 }
812 }
813 }
814
815 s.MoveOne(src, dst)
816 return nil
817 }
818
819 // SetAny wraps val with V_ANY node, and Add() the node.
820 func (self *Node) AddAny(val interface{}) error {
821 return self.Add(NewAny(val))
822 }
823
824 // GetByPath load given path on demands,
825 // which only ensure nodes before this path got parsed.
826 //
827 // Note, the api expects the json is well-formed at least,
828 // otherwise it may return unexpected result.
829 func (self *Node) GetByPath(path ...interface{}) *Node {
830 if !self.Valid() {
831 return self
832 }
833 var s = self
834 for _, p := range path {
835 switch p := p.(type) {
836 case int:
837 s = s.Index(p)
838 if !s.Valid() {
839 return s
840 }
841 case string:
842 s = s.Get(p)
843 if !s.Valid() {
844 return s
845 }
846 default:
847 panic("path must be either int or string")
848 }
849 }
850 return s
851 }
852
853 // Get loads given key of an object node on demands
854 func (self *Node) Get(key string) *Node {
855 if err := self.should(types.V_OBJECT); err != nil {
856 return unwrapError(err)
857 }
858 n, _ := self.skipKey(key)
859 return n
860 }
861
862 // Index indexies node at given idx,
863 // node type CAN be either V_OBJECT or V_ARRAY
864 func (self *Node) Index(idx int) *Node {
865 if err := self.checkRaw(); err != nil {
866 return unwrapError(err)
867 }
868
869 it := self.itype()
870 if it == types.V_ARRAY {
871 return self.skipIndex(idx)
872
873 }else if it == types.V_OBJECT {
874 pr := self.skipIndexPair(idx)
875 if pr == nil {
876 return newError(_ERR_NOT_FOUND, "value not exists")
877 }
878 return &pr.Value
879
880 } else {
881 return newError(_ERR_UNSUPPORT_TYPE, fmt.Sprintf("unsupported type: %v", self.itype()))
882 }
883 }
884
885 // IndexPair indexies pair at given idx,
886 // node type MUST be either V_OBJECT
887 func (self *Node) IndexPair(idx int) *Pair {
888 if err := self.should(types.V_OBJECT); err != nil {
889 return nil
890 }
891 return self.skipIndexPair(idx)
892 }
893
894 func (self *Node) indexOrGet(idx int, key string) (*Node, int) {
895 if err := self.should(types.V_OBJECT); err != nil {
896 return unwrapError(err), idx
897 }
898
899 pr := self.skipIndexPair(idx)
900 if pr != nil && pr.Key == key {
901 return &pr.Value, idx
902 }
903
904 return self.skipKey(key)
905 }
906
907 // IndexOrGet firstly use idx to index a value and check if its key matches
908 // If not, then use the key to search value
909 func (self *Node) IndexOrGet(idx int, key string) *Node {
910 node, _ := self.indexOrGet(idx, key)
911 return node
912 }
913
914 // IndexOrGetWithIdx attempts to retrieve a node by index and key, returning the node and its correct index.
915 // If the key does not match at the given index, it searches by key and returns the node with its updated index.
916 func (self *Node) IndexOrGetWithIdx(idx int, key string) (*Node, int) {
917 return self.indexOrGet(idx, key)
918 }
919
920 /** Generic Value Converters **/
921
922 // Map loads all keys of an object node
923 func (self *Node) Map() (map[string]interface{}, error) {
924 if self.isAny() {
925 any := self.packAny()
926 if v, ok := any.(map[string]interface{}); ok {
927 return v, nil
928 } else {
929 return nil, ErrUnsupportType
930 }
931 }
932 if err := self.should(types.V_OBJECT); err != nil {
933 return nil, err
934 }
935 if err := self.loadAllKey(false); err != nil {
936 return nil, err
937 }
938 return self.toGenericObject()
939 }
940
941 // MapUseNumber loads all keys of an object node, with numeric nodes casted to json.Number
942 func (self *Node) MapUseNumber() (map[string]interface{}, error) {
943 if self.isAny() {
944 any := self.packAny()
945 if v, ok := any.(map[string]interface{}); ok {
946 return v, nil
947 } else {
948 return nil, ErrUnsupportType
949 }
950 }
951 if err := self.should(types.V_OBJECT); err != nil {
952 return nil, err
953 }
954 if err := self.loadAllKey(false); err != nil {
955 return nil, err
956 }
957 return self.toGenericObjectUseNumber()
958 }
959
960 // MapUseNode scans both parsed and non-parsed children nodes,
961 // and map them by their keys
962 func (self *Node) MapUseNode() (map[string]Node, error) {
963 if self.isAny() {
964 any := self.packAny()
965 if v, ok := any.(map[string]Node); ok {
966 return v, nil
967 } else {
968 return nil, ErrUnsupportType
969 }
970 }
971 if err := self.should(types.V_OBJECT); err != nil {
972 return nil, err
973 }
974 if err := self.skipAllKey(); err != nil {
975 return nil, err
976 }
977 return self.toGenericObjectUseNode()
978 }
979
980 // MapUnsafe exports the underlying pointer to its children map
981 // WARN: don't use it unless you know what you are doing
982 //
983 // Deprecated: this API now returns copied nodes instead of directly reference,
984 // func (self *Node) UnsafeMap() ([]Pair, error) {
985 // if err := self.should(types.V_OBJECT, "an object"); err != nil {
986 // return nil, err
987 // }
988 // if err := self.skipAllKey(); err != nil {
989 // return nil, err
990 // }
991 // return self.toGenericObjectUsePair()
992 // }
993
994 //go:nocheckptr
995 func (self *Node) unsafeMap() (*linkedPairs, error) {
996 if err := self.skipAllKey(); err != nil {
997 return nil, err
998 }
999 if self.p == nil {
1000 *self = newObject(new(linkedPairs))
1001 }
1002 return (*linkedPairs)(self.p), nil
1003 }
1004
1005 // SortKeys sorts children of a V_OBJECT node in ascending key-order.
1006 // If recurse is true, it recursively sorts children's children as long as a V_OBJECT node is found.
1007 func (self *Node) SortKeys(recurse bool) error {
1008 // check raw node first
1009 if err := self.checkRaw(); err != nil {
1010 return err
1011 }
1012 if self.itype() == types.V_OBJECT {
1013 return self.sortKeys(recurse)
1014 } else if self.itype() == types.V_ARRAY {
1015 var err error
1016 err2 := self.ForEach(func(path Sequence, node *Node) bool {
1017 it := node.itype()
1018 if it == types.V_ARRAY || it == types.V_OBJECT {
1019 err = node.SortKeys(recurse)
1020 if err != nil {
1021 return false
1022 }
1023 }
1024 return true
1025 })
1026 if err != nil {
1027 return err
1028 }
1029 return err2
1030 } else {
1031 return nil
1032 }
1033 }
1034
1035 func (self *Node) sortKeys(recurse bool) (err error) {
1036 // check raw node first
1037 if err := self.checkRaw(); err != nil {
1038 return err
1039 }
1040 ps, err := self.unsafeMap()
1041 if err != nil {
1042 return err
1043 }
1044 ps.Sort()
1045 if recurse {
1046 var sc Scanner
1047 sc = func(path Sequence, node *Node) bool {
1048 if node.itype() == types.V_OBJECT {
1049 if err := node.sortKeys(recurse); err != nil {
1050 return false
1051 }
1052 }
1053 if node.itype() == types.V_ARRAY {
1054 if err := node.ForEach(sc); err != nil {
1055 return false
1056 }
1057 }
1058 return true
1059 }
1060 if err := self.ForEach(sc); err != nil {
1061 return err
1062 }
1063 }
1064 return nil
1065 }
1066
1067 // Array loads all indexes of an array node
1068 func (self *Node) Array() ([]interface{}, error) {
1069 if self.isAny() {
1070 any := self.packAny()
1071 if v, ok := any.([]interface{}); ok {
1072 return v, nil
1073 } else {
1074 return nil, ErrUnsupportType
1075 }
1076 }
1077 if err := self.should(types.V_ARRAY); err != nil {
1078 return nil, err
1079 }
1080 if err := self.loadAllIndex(false); err != nil {
1081 return nil, err
1082 }
1083 return self.toGenericArray()
1084 }
1085
1086 // ArrayUseNumber loads all indexes of an array node, with numeric nodes casted to json.Number
1087 func (self *Node) ArrayUseNumber() ([]interface{}, error) {
1088 if self.isAny() {
1089 any := self.packAny()
1090 if v, ok := any.([]interface{}); ok {
1091 return v, nil
1092 } else {
1093 return nil, ErrUnsupportType
1094 }
1095 }
1096 if err := self.should(types.V_ARRAY); err != nil {
1097 return nil, err
1098 }
1099 if err := self.loadAllIndex(false); err != nil {
1100 return nil, err
1101 }
1102 return self.toGenericArrayUseNumber()
1103 }
1104
1105 // ArrayUseNode copies both parsed and non-parsed children nodes,
1106 // and indexes them by original order
1107 func (self *Node) ArrayUseNode() ([]Node, error) {
1108 if self.isAny() {
1109 any := self.packAny()
1110 if v, ok := any.([]Node); ok {
1111 return v, nil
1112 } else {
1113 return nil, ErrUnsupportType
1114 }
1115 }
1116 if err := self.should(types.V_ARRAY); err != nil {
1117 return nil, err
1118 }
1119 if err := self.skipAllIndex(); err != nil {
1120 return nil, err
1121 }
1122 return self.toGenericArrayUseNode()
1123 }
1124
1125 // ArrayUnsafe exports the underlying pointer to its children array
1126 // WARN: don't use it unless you know what you are doing
1127 //
1128 // Deprecated: this API now returns copied nodes instead of directly reference,
1129 // which has no difference with ArrayUseNode
1130 // func (self *Node) UnsafeArray() ([]Node, error) {
1131 // if err := self.should(types.V_ARRAY, "an array"); err != nil {
1132 // return nil, err
1133 // }
1134 // if err := self.skipAllIndex(); err != nil {
1135 // return nil, err
1136 // }
1137 // return self.toGenericArrayUseNode()
1138 // }
1139
1140 func (self *Node) unsafeArray() (*linkedNodes, error) {
1141 if err := self.skipAllIndex(); err != nil {
1142 return nil, err
1143 }
1144 if self.p == nil {
1145 *self = newArray(new(linkedNodes))
1146 }
1147 return (*linkedNodes)(self.p), nil
1148 }
1149
1150 // Interface loads all children under all paths from this node,
1151 // and converts itself as generic type.
1152 // WARN: all numeric nodes are casted to float64
1153 func (self *Node) Interface() (interface{}, error) {
1154 if err := self.checkRaw(); err != nil {
1155 return nil, err
1156 }
1157 switch self.t {
1158 case V_ERROR : return nil, self.Check()
1159 case types.V_NULL : return nil, nil
1160 case types.V_TRUE : return true, nil
1161 case types.V_FALSE : return false, nil
1162 case types.V_ARRAY : return self.toGenericArray()
1163 case types.V_OBJECT : return self.toGenericObject()
1164 case types.V_STRING : return self.toString(), nil
1165 case _V_NUMBER :
1166 v, err := self.toFloat64()
1167 if err != nil {
1168 return nil, err
1169 }
1170 return v, nil
1171 case _V_ARRAY_LAZY :
1172 if err := self.loadAllIndex(false); err != nil {
1173 return nil, err
1174 }
1175 return self.toGenericArray()
1176 case _V_OBJECT_LAZY :
1177 if err := self.loadAllKey(false); err != nil {
1178 return nil, err
1179 }
1180 return self.toGenericObject()
1181 case _V_ANY:
1182 switch v := self.packAny().(type) {
1183 case Node : return v.Interface()
1184 case *Node: return v.Interface()
1185 default : return v, nil
1186 }
1187 default : return nil, ErrUnsupportType
1188 }
1189 }
1190
1191 func (self *Node) packAny() interface{} {
1192 return *(*interface{})(self.p)
1193 }
1194
1195 // InterfaceUseNumber works same with Interface()
1196 // except numeric nodes are casted to json.Number
1197 func (self *Node) InterfaceUseNumber() (interface{}, error) {
1198 if err := self.checkRaw(); err != nil {
1199 return nil, err
1200 }
1201 switch self.t {
1202 case V_ERROR : return nil, self.Check()
1203 case types.V_NULL : return nil, nil
1204 case types.V_TRUE : return true, nil
1205 case types.V_FALSE : return false, nil
1206 case types.V_ARRAY : return self.toGenericArrayUseNumber()
1207 case types.V_OBJECT : return self.toGenericObjectUseNumber()
1208 case types.V_STRING : return self.toString(), nil
1209 case _V_NUMBER : return self.toNumber(), nil
1210 case _V_ARRAY_LAZY :
1211 if err := self.loadAllIndex(false); err != nil {
1212 return nil, err
1213 }
1214 return self.toGenericArrayUseNumber()
1215 case _V_OBJECT_LAZY :
1216 if err := self.loadAllKey(false); err != nil {
1217 return nil, err
1218 }
1219 return self.toGenericObjectUseNumber()
1220 case _V_ANY : return self.packAny(), nil
1221 default : return nil, ErrUnsupportType
1222 }
1223 }
1224
1225 // InterfaceUseNode clone itself as a new node,
1226 // or its children as map[string]Node (or []Node)
1227 func (self *Node) InterfaceUseNode() (interface{}, error) {
1228 if err := self.checkRaw(); err != nil {
1229 return nil, err
1230 }
1231 switch self.t {
1232 case types.V_ARRAY : return self.toGenericArrayUseNode()
1233 case types.V_OBJECT : return self.toGenericObjectUseNode()
1234 case _V_ARRAY_LAZY :
1235 if err := self.skipAllIndex(); err != nil {
1236 return nil, err
1237 }
1238 return self.toGenericArrayUseNode()
1239 case _V_OBJECT_LAZY :
1240 if err := self.skipAllKey(); err != nil {
1241 return nil, err
1242 }
1243 return self.toGenericObjectUseNode()
1244 default : return *self, self.Check()
1245 }
1246 }
1247
1248 // LoadAll loads the node's children
1249 // and ensure all its children can be READ concurrently (include its children's children)
1250 func (self *Node) LoadAll() error {
1251 return self.Load()
1252 }
1253
1254 // Load loads the node's children as parsed.
1255 // and ensure all its children can be READ concurrently (include its children's children)
1256 func (self *Node) Load() error {
1257 switch self.t {
1258 case _V_ARRAY_LAZY: self.loadAllIndex(true)
1259 case _V_OBJECT_LAZY: self.loadAllKey(true)
1260 case V_ERROR: return self
1261 case V_NONE: return nil
1262 }
1263 if self.m == nil {
1264 self.m = new(sync.RWMutex)
1265 }
1266 return self.checkRaw()
1267 }
1268
1269 /**---------------------------------- Internal Helper Methods ----------------------------------**/
1270
1271 func (self *Node) should(t types.ValueType) error {
1272 if err := self.checkRaw(); err != nil {
1273 return err
1274 }
1275 if self.itype() != t {
1276 return ErrUnsupportType
1277 }
1278 return nil
1279 }
1280
1281 func (self *Node) nodeAt(i int) *Node {
1282 var p *linkedNodes
1283 if self.isLazy() {
1284 _, stack := self.getParserAndArrayStack()
1285 p = &stack.v
1286 } else {
1287 p = (*linkedNodes)(self.p)
1288 if l := p.Len(); l != self.len() {
1289 // some nodes got unset, iterate to skip them
1290 for j:=0; j<l; j++ {
1291 v := p.At(j)
1292 if v.Exists() {
1293 i--
1294 }
1295 if i < 0 {
1296 return v
1297 }
1298 }
1299 return nil
1300 }
1301 }
1302 return p.At(i)
1303 }
1304
1305 func (self *Node) pairAt(i int) *Pair {
1306 var p *linkedPairs
1307 if self.isLazy() {
1308 _, stack := self.getParserAndObjectStack()
1309 p = &stack.v
1310 } else {
1311 p = (*linkedPairs)(self.p)
1312 if l := p.Len(); l != self.len() {
1313 // some nodes got unset, iterate to skip them
1314 for j:=0; j<l; j++ {
1315 v := p.At(j)
1316 if v != nil && v.Value.Exists() {
1317 i--
1318 }
1319 if i < 0 {
1320 return v
1321 }
1322 }
1323 return nil
1324 }
1325 }
1326 return p.At(i)
1327 }
1328
1329 func (self *Node) skipAllIndex() error {
1330 if !self.isLazy() {
1331 return nil
1332 }
1333 var err types.ParsingError
1334 parser, stack := self.getParserAndArrayStack()
1335 parser.skipValue = true
1336 parser.noLazy = true
1337 *self, err = parser.decodeArray(&stack.v)
1338 if err != 0 {
1339 return parser.ExportError(err)
1340 }
1341 return nil
1342 }
1343
1344 func (self *Node) skipAllKey() error {
1345 if !self.isLazy() {
1346 return nil
1347 }
1348 var err types.ParsingError
1349 parser, stack := self.getParserAndObjectStack()
1350 parser.skipValue = true
1351 parser.noLazy = true
1352 *self, err = parser.decodeObject(&stack.v)
1353 if err != 0 {
1354 return parser.ExportError(err)
1355 }
1356 return nil
1357 }
1358
1359 func (self *Node) skipKey(key string) (*Node, int) {
1360 nb := self.len()
1361 lazy := self.isLazy()
1362
1363 if nb > 0 {
1364 /* linear search */
1365 var p *Pair
1366 var i int
1367 if lazy {
1368 s := (*parseObjectStack)(self.p)
1369 p, i = s.v.Get(key)
1370 } else {
1371 p, i = (*linkedPairs)(self.p).Get(key)
1372 }
1373
1374 if p != nil {
1375 return &p.Value, i
1376 }
1377 }
1378
1379 /* not found */
1380 if !lazy {
1381 return nil, -1
1382 }
1383
1384 // lazy load
1385 for last, i := self.skipNextPair(), nb; last != nil; last, i = self.skipNextPair(), i+1 {
1386 if last.Value.Check() != nil {
1387 return &last.Value, -1
1388 }
1389 if last.Key == key {
1390 return &last.Value, i
1391 }
1392 }
1393
1394 return nil, -1
1395 }
1396
1397 func (self *Node) skipIndex(index int) *Node {
1398 nb := self.len()
1399 if nb > index {
1400 v := self.nodeAt(index)
1401 return v
1402 }
1403 if !self.isLazy() {
1404 return nil
1405 }
1406
1407 // lazy load
1408 for last := self.skipNextNode(); last != nil; last = self.skipNextNode(){
1409 if last.Check() != nil {
1410 return last
1411 }
1412 if self.len() > index {
1413 return last
1414 }
1415 }
1416
1417 return nil
1418 }
1419
1420 func (self *Node) skipIndexPair(index int) *Pair {
1421 nb := self.len()
1422 if nb > index {
1423 return self.pairAt(index)
1424 }
1425 if !self.isLazy() {
1426 return nil
1427 }
1428
1429 // lazy load
1430 for last := self.skipNextPair(); last != nil; last = self.skipNextPair(){
1431 if last.Value.Check() != nil {
1432 return last
1433 }
1434 if self.len() > index {
1435 return last
1436 }
1437 }
1438
1439 return nil
1440 }
1441
1442 func (self *Node) loadAllIndex(loadOnce bool) error {
1443 if !self.isLazy() {
1444 return nil
1445 }
1446 var err types.ParsingError
1447 parser, stack := self.getParserAndArrayStack()
1448 if !loadOnce {
1449 parser.noLazy = true
1450 } else {
1451 parser.loadOnce = true
1452 }
1453 *self, err = parser.decodeArray(&stack.v)
1454 if err != 0 {
1455 return parser.ExportError(err)
1456 }
1457 return nil
1458 }
1459
1460 func (self *Node) loadAllKey(loadOnce bool) error {
1461 if !self.isLazy() {
1462 return nil
1463 }
1464 var err types.ParsingError
1465 parser, stack := self.getParserAndObjectStack()
1466 if !loadOnce {
1467 parser.noLazy = true
1468 *self, err = parser.decodeObject(&stack.v)
1469 } else {
1470 parser.loadOnce = true
1471 *self, err = parser.decodeObject(&stack.v)
1472 }
1473 if err != 0 {
1474 return parser.ExportError(err)
1475 }
1476 return nil
1477 }
1478
1479 func (self *Node) removeNode(i int) {
1480 node := self.nodeAt(i)
1481 if node == nil {
1482 return
1483 }
1484 *node = Node{}
1485 // NOTICE: not be consistent with linkedNode.Len()
1486 self.l--
1487 }
1488
1489 func (self *Node) removePair(i int) {
1490 last := self.pairAt(i)
1491 if last == nil {
1492 return
1493 }
1494 *last = Pair{}
1495 // NOTICE: should be consistent with linkedPair.Len()
1496 self.l--
1497 }
1498
1499 func (self *Node) removePairAt(i int) {
1500 p := (*linkedPairs)(self.p).At(i)
1501 if p == nil {
1502 return
1503 }
1504 *p = Pair{}
1505 // NOTICE: should be consistent with linkedPair.Len()
1506 self.l--
1507 }
1508
1509 func (self *Node) toGenericArray() ([]interface{}, error) {
1510 nb := self.len()
1511 if nb == 0 {
1512 return []interface{}{}, nil
1513 }
1514 ret := make([]interface{}, 0, nb)
1515
1516 /* convert each item */
1517 it := self.values()
1518 for v := it.next(); v != nil; v = it.next() {
1519 vv, err := v.Interface()
1520 if err != nil {
1521 return nil, err
1522 }
1523 ret = append(ret, vv)
1524 }
1525
1526 /* all done */
1527 return ret, nil
1528 }
1529
1530 func (self *Node) toGenericArrayUseNumber() ([]interface{}, error) {
1531 nb := self.len()
1532 if nb == 0 {
1533 return []interface{}{}, nil
1534 }
1535 ret := make([]interface{}, 0, nb)
1536
1537 /* convert each item */
1538 it := self.values()
1539 for v := it.next(); v != nil; v = it.next() {
1540 vv, err := v.InterfaceUseNumber()
1541 if err != nil {
1542 return nil, err
1543 }
1544 ret = append(ret, vv)
1545 }
1546
1547 /* all done */
1548 return ret, nil
1549 }
1550
1551 func (self *Node) toGenericArrayUseNode() ([]Node, error) {
1552 var nb = self.len()
1553 if nb == 0 {
1554 return []Node{}, nil
1555 }
1556
1557 var s = (*linkedNodes)(self.p)
1558 var out = make([]Node, nb)
1559 s.ToSlice(out)
1560
1561 return out, nil
1562 }
1563
1564 func (self *Node) toGenericObject() (map[string]interface{}, error) {
1565 nb := self.len()
1566 if nb == 0 {
1567 return map[string]interface{}{}, nil
1568 }
1569 ret := make(map[string]interface{}, nb)
1570
1571 /* convert each item */
1572 it := self.properties()
1573 for v := it.next(); v != nil; v = it.next() {
1574 vv, err := v.Value.Interface()
1575 if err != nil {
1576 return nil, err
1577 }
1578 ret[v.Key] = vv
1579 }
1580
1581 /* all done */
1582 return ret, nil
1583 }
1584
1585
1586 func (self *Node) toGenericObjectUseNumber() (map[string]interface{}, error) {
1587 nb := self.len()
1588 if nb == 0 {
1589 return map[string]interface{}{}, nil
1590 }
1591 ret := make(map[string]interface{}, nb)
1592
1593 /* convert each item */
1594 it := self.properties()
1595 for v := it.next(); v != nil; v = it.next() {
1596 vv, err := v.Value.InterfaceUseNumber()
1597 if err != nil {
1598 return nil, err
1599 }
1600 ret[v.Key] = vv
1601 }
1602
1603 /* all done */
1604 return ret, nil
1605 }
1606
1607 func (self *Node) toGenericObjectUseNode() (map[string]Node, error) {
1608 var nb = self.len()
1609 if nb == 0 {
1610 return map[string]Node{}, nil
1611 }
1612
1613 var s = (*linkedPairs)(self.p)
1614 var out = make(map[string]Node, nb)
1615 s.ToMap(out)
1616
1617 /* all done */
1618 return out, nil
1619 }
1620
1621 /**------------------------------------ Factory Methods ------------------------------------**/
1622
1623 var (
1624 nullNode = Node{t: types.V_NULL}
1625 trueNode = Node{t: types.V_TRUE}
1626 falseNode = Node{t: types.V_FALSE}
1627 )
1628
1629 // NewRaw creates a node of raw json.
1630 // If the input json is invalid, NewRaw returns a error Node.
1631 func NewRaw(json string) Node {
1632 parser := NewParserObj(json)
1633 start, err := parser.skip()
1634 if err != 0 {
1635 return *newError(err, err.Message())
1636 }
1637 it := switchRawType(parser.s[start])
1638 if it == _V_NONE {
1639 return Node{}
1640 }
1641 return newRawNode(parser.s[start:parser.p], it, false)
1642 }
1643
1644 // NewRawConcurrentRead creates a node of raw json, which can be READ
1645 // (GetByPath/Get/Index/GetOrIndex/Int64/Bool/Float64/String/Number/Interface/Array/Map/Raw/MarshalJSON) concurrently.
1646 // If the input json is invalid, NewRaw returns a error Node.
1647 func NewRawConcurrentRead(json string) Node {
1648 parser := NewParserObj(json)
1649 start, err := parser.skip()
1650 if err != 0 {
1651 return *newError(err, err.Message())
1652 }
1653 it := switchRawType(parser.s[start])
1654 if it == _V_NONE {
1655 return Node{}
1656 }
1657 return newRawNode(parser.s[start:parser.p], it, true)
1658 }
1659
1660 // NewAny creates a node of type V_ANY if any's type isn't Node or *Node,
1661 // which stores interface{} and can be only used for `.Interface()`\`.MarshalJSON()`.
1662 func NewAny(any interface{}) Node {
1663 switch n := any.(type) {
1664 case Node:
1665 return n
1666 case *Node:
1667 return *n
1668 default:
1669 return Node{
1670 t: _V_ANY,
1671 p: unsafe.Pointer(&any),
1672 }
1673 }
1674 }
1675
1676 // NewBytes encodes given src with Base64 (RFC 4648), and creates a node of type V_STRING.
1677 func NewBytes(src []byte) Node {
1678 if len(src) == 0 {
1679 panic("empty src bytes")
1680 }
1681 out := rt.EncodeBase64ToString(src)
1682 return NewString(out)
1683 }
1684
1685 // NewNull creates a node of type V_NULL
1686 func NewNull() Node {
1687 return Node{
1688 p: nil,
1689 t: types.V_NULL,
1690 }
1691 }
1692
1693 // NewBool creates a node of type bool:
1694 // If v is true, returns V_TRUE node
1695 // If v is false, returns V_FALSE node
1696 func NewBool(v bool) Node {
1697 var t = types.V_FALSE
1698 if v {
1699 t = types.V_TRUE
1700 }
1701 return Node{
1702 p: nil,
1703 t: t,
1704 }
1705 }
1706
1707 // NewNumber creates a json.Number node
1708 // v must be a decimal string complying with RFC8259
1709 func NewNumber(v string) Node {
1710 return Node{
1711 l: uint(len(v)),
1712 p: rt.StrPtr(v),
1713 t: _V_NUMBER,
1714 }
1715 }
1716
1717 func (node *Node) toNumber() json.Number {
1718 return json.Number(rt.StrFrom(node.p, int64(node.l)))
1719 }
1720
1721 func (self *Node) toString() string {
1722 return rt.StrFrom(self.p, int64(self.l))
1723 }
1724
1725 func (node *Node) toFloat64() (float64, error) {
1726 ret, err := node.toNumber().Float64()
1727 if err != nil {
1728 return 0, err
1729 }
1730 return ret, nil
1731 }
1732
1733 func (node *Node) toInt64() (int64, error) {
1734 ret,err := node.toNumber().Int64()
1735 if err != nil {
1736 return 0, err
1737 }
1738 return ret, nil
1739 }
1740
1741 func newBytes(v []byte) Node {
1742 return Node{
1743 t: types.V_STRING,
1744 p: mem2ptr(v),
1745 l: uint(len(v)),
1746 }
1747 }
1748
1749 // NewString creates a node of type V_STRING.
1750 // v is considered to be a valid UTF-8 string,
1751 // which means it won't be validated and unescaped.
1752 // when the node is encoded to json, v will be escaped.
1753 func NewString(v string) Node {
1754 return Node{
1755 t: types.V_STRING,
1756 p: rt.StrPtr(v),
1757 l: uint(len(v)),
1758 }
1759 }
1760
1761 // NewArray creates a node of type V_ARRAY,
1762 // using v as its underlying children
1763 func NewArray(v []Node) Node {
1764 s := new(linkedNodes)
1765 s.FromSlice(v)
1766 return newArray(s)
1767 }
1768
1769 const _Threshold_Index = 16
1770
1771 func newArray(v *linkedNodes) Node {
1772 return Node{
1773 t: types.V_ARRAY,
1774 l: uint(v.Len()),
1775 p: unsafe.Pointer(v),
1776 }
1777 }
1778
1779 func (self *Node) setArray(v *linkedNodes) {
1780 self.t = types.V_ARRAY
1781 self.l = uint(v.Len())
1782 self.p = unsafe.Pointer(v)
1783 }
1784
1785 // NewObject creates a node of type V_OBJECT,
1786 // using v as its underlying children
1787 func NewObject(v []Pair) Node {
1788 s := new(linkedPairs)
1789 s.FromSlice(v)
1790 return newObject(s)
1791 }
1792
1793 func newObject(v *linkedPairs) Node {
1794 if v.size > _Threshold_Index {
1795 v.BuildIndex()
1796 }
1797 return Node{
1798 t: types.V_OBJECT,
1799 l: uint(v.Len()),
1800 p: unsafe.Pointer(v),
1801 }
1802 }
1803
1804 func (self *Node) setObject(v *linkedPairs) {
1805 if v.size > _Threshold_Index {
1806 v.BuildIndex()
1807 }
1808 self.t = types.V_OBJECT
1809 self.l = uint(v.Len())
1810 self.p = unsafe.Pointer(v)
1811 }
1812
1813 func (self *Node) parseRaw(full bool) {
1814 lock := self.lock()
1815 defer self.unlock()
1816 if !self.isRaw() {
1817 return
1818 }
1819 raw := self.toString()
1820 parser := NewParserObj(raw)
1821 var e types.ParsingError
1822 if full {
1823 parser.noLazy = true
1824 *self, e = parser.Parse()
1825 } else if lock {
1826 var n Node
1827 parser.noLazy = true
1828 parser.loadOnce = true
1829 n, e = parser.Parse()
1830 self.assign(n)
1831 } else {
1832 *self, e = parser.Parse()
1833 }
1834 if e != 0 {
1835 *self = *newSyntaxError(parser.syntaxError(e))
1836 }
1837 }
1838
1839 func (self *Node) assign(n Node) {
1840 self.l = n.l
1841 self.p = n.p
1842 atomic.StoreInt64(&self.t, n.t)
1843 }
1844