/
encode.go
113 lines (97 loc) · 2.62 KB
/
encode.go
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
package xml
import (
"bytes"
"fmt"
"reflect"
"github.com/beevik/etree"
)
const valueType = "t"
const valueCount = "c"
const elemType = "e"
// Encoder implements a xml encoder
type Encoder struct{}
// Encode marshal a Go data into []byte, it use buf firstly.
func (e *Encoder) Encode(v interface{}, buf []byte, pretty bool) ([]byte, error) {
d := etree.NewDocument()
d.CreateProcInst("xml", `version="1.0" encoding="UTF-8"`)
e.value(&d.Element, "root", reflect.ValueOf(v))
if pretty {
d.WriteSettings.UseCRLF = true
d.Indent(2)
}
b := bytes.NewBuffer(buf)
_, err := d.WriteTo(b)
return b.Bytes(), err
}
// value encode a Go value recursively
func (e *Encoder) value(parent *etree.Element, name string, v reflect.Value) error {
switch k := v.Kind(); k {
case reflect.Int, reflect.Uint, reflect.Float32, reflect.Float64,
reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
reflect.String, reflect.Bool:
elem := parent.CreateElement(name)
elem.CreateAttr(valueType, typeName(k))
elem.SetText(fmt.Sprintf("%v", v.Interface()))
return nil
case reflect.Array, reflect.Slice:
l := v.Len()
elem := parent.CreateElement(name)
elem.CreateAttr(valueType, typeName(k))
elem.CreateAttr(elemType, elemName(v.Type().Elem().Kind()))
c := 0
for i := 0; i < l; i++ {
if err := e.value(elem, "e", v.Index(i)); err != nil {
return err
}
c++
}
elem.CreateAttr(valueCount, fmt.Sprintf("%d", c))
return nil
case reflect.Struct:
t := v.Type()
elem := parent.CreateElement(name)
elem.CreateAttr(valueType, typeName(k))
c := 0
for i, n := 0, t.NumField(); i < n; i++ {
f := t.Field(i)
fv := v.Field(i)
if err := e.value(elem, f.Name, fv); err != nil {
return err
}
c++
}
elem.CreateAttr(valueCount, fmt.Sprintf("%d", c))
return nil
case reflect.Map:
t := v.Type()
kt := t.Key()
vt := t.Elem()
if kt.Kind() != reflect.String {
return fmt.Errorf("unsupported map key %s", kt.String())
}
keys := v.MapKeys()
elem := parent.CreateElement(name)
elem.CreateAttr(valueType, typeName(k))
elem.CreateAttr(elemType, elemName(vt.Kind()))
c := 0
for _, key := range keys {
if err := e.value(elem, key.String(), v.MapIndex(key)); err != nil {
return err
}
c++
}
elem.CreateAttr(valueCount, fmt.Sprintf("%d", c))
return nil
case reflect.Ptr, reflect.Interface:
if !v.IsNil() {
return e.value(parent, name, v.Elem())
}
elem := parent.CreateElement(name)
elem.SetText("null")
return nil
default:
// do nothing
}
return fmt.Errorf("unsupported type %s", v.Type().String())
}