1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
package model
import (
"bytes"
"fmt"
"strconv"
)
// Node of JSON tree
type Node struct {
Type NodeType
stringValue string
numberValue float64
objectValue NodeObjectValue
arrayValue NodeArrayValue
booleanValue bool
}
// NewNode creates new node from value
func NewNode(value any) *Node {
n := new(Node)
n.SetValue(value)
return n
}
// Value returns value of node
func (n *Node) Value() any {
switch n.Type {
case StringNode:
return n.stringValue
case NumberNode:
return n.numberValue
case ObjectNode:
return n.objectValue
case ArrayNode:
return n.arrayValue
case BooleanNode:
return n.booleanValue
default:
return nil
}
}
// SetValue to node
func (n *Node) SetValue(value any) {
switch value := value.(type) {
case string:
n.Type = StringNode
n.stringValue = value
case float64:
n.Type = NumberNode
n.numberValue = value
case int:
n.Type = NumberNode
n.numberValue = float64(value)
case NodeObjectValue:
n.Type = ObjectNode
n.objectValue = value
case NodeArrayValue:
n.Type = ArrayNode
n.arrayValue = value
case bool:
n.Type = BooleanNode
n.booleanValue = value
default:
n.Type = NullNode
}
}
// MarshalJSON to []byte
func (n *Node) MarshalJSON() ([]byte, error) {
switch n.Type {
case StringNode:
return []byte(`"` + n.stringValue + `"`), nil
case NumberNode:
return []byte(strconv.FormatFloat(n.numberValue, 'g', -1, 64)), nil
case ObjectNode:
result := make([][]byte, 0, len(n.objectValue))
for k, v := range n.objectValue {
b, err := v.MarshalJSON()
if err != nil {
return nil, err
}
result = append(result, []byte(fmt.Sprintf("\"%s\": %s", k, b)))
}
return bytes.Join(
[][]byte{
[]byte("{"),
bytes.Join(result, []byte(", ")),
[]byte("}"),
}, []byte("")), nil
case ArrayNode:
result := make([][]byte, 0, len(n.arrayValue))
for _, v := range n.arrayValue {
b, err := v.MarshalJSON()
if err != nil {
return nil, err
}
result = append(result, b)
}
return bytes.Join(
[][]byte{
[]byte("["),
bytes.Join(result, []byte(", ")),
[]byte("]"),
}, []byte("")), nil
case BooleanNode:
if n.booleanValue {
return []byte("true"), nil
}
return []byte("false"), nil
default:
return []byte("null"), nil
}
}
|
