]>
Commit | Line | Data |
---|---|---|
107c1cdb ND |
1 | package msgpack |
2 | ||
3 | import ( | |
4 | "reflect" | |
5 | "sort" | |
6 | ||
7 | "github.com/vmihailenco/msgpack/codes" | |
8 | ) | |
9 | ||
10 | func encodeMapValue(e *Encoder, v reflect.Value) error { | |
11 | if v.IsNil() { | |
12 | return e.EncodeNil() | |
13 | } | |
14 | ||
15 | if err := e.EncodeMapLen(v.Len()); err != nil { | |
16 | return err | |
17 | } | |
18 | ||
19 | for _, key := range v.MapKeys() { | |
20 | if err := e.EncodeValue(key); err != nil { | |
21 | return err | |
22 | } | |
23 | if err := e.EncodeValue(v.MapIndex(key)); err != nil { | |
24 | return err | |
25 | } | |
26 | } | |
27 | ||
28 | return nil | |
29 | } | |
30 | ||
31 | func encodeMapStringStringValue(e *Encoder, v reflect.Value) error { | |
32 | if v.IsNil() { | |
33 | return e.EncodeNil() | |
34 | } | |
35 | ||
36 | if err := e.EncodeMapLen(v.Len()); err != nil { | |
37 | return err | |
38 | } | |
39 | ||
40 | m := v.Convert(mapStringStringType).Interface().(map[string]string) | |
41 | if e.sortMapKeys { | |
42 | return e.encodeSortedMapStringString(m) | |
43 | } | |
44 | ||
45 | for mk, mv := range m { | |
46 | if err := e.EncodeString(mk); err != nil { | |
47 | return err | |
48 | } | |
49 | if err := e.EncodeString(mv); err != nil { | |
50 | return err | |
51 | } | |
52 | } | |
53 | ||
54 | return nil | |
55 | } | |
56 | ||
57 | func encodeMapStringInterfaceValue(e *Encoder, v reflect.Value) error { | |
58 | if v.IsNil() { | |
59 | return e.EncodeNil() | |
60 | } | |
61 | ||
62 | if err := e.EncodeMapLen(v.Len()); err != nil { | |
63 | return err | |
64 | } | |
65 | ||
66 | m := v.Convert(mapStringInterfaceType).Interface().(map[string]interface{}) | |
67 | if e.sortMapKeys { | |
68 | return e.encodeSortedMapStringInterface(m) | |
69 | } | |
70 | ||
71 | for mk, mv := range m { | |
72 | if err := e.EncodeString(mk); err != nil { | |
73 | return err | |
74 | } | |
75 | if err := e.Encode(mv); err != nil { | |
76 | return err | |
77 | } | |
78 | } | |
79 | ||
80 | return nil | |
81 | } | |
82 | ||
83 | func (e *Encoder) encodeSortedMapStringString(m map[string]string) error { | |
84 | keys := make([]string, 0, len(m)) | |
85 | for k, _ := range m { | |
86 | keys = append(keys, k) | |
87 | } | |
88 | sort.Strings(keys) | |
89 | ||
90 | for _, k := range keys { | |
91 | err := e.EncodeString(k) | |
92 | if err != nil { | |
93 | return err | |
94 | } | |
95 | if err = e.EncodeString(m[k]); err != nil { | |
96 | return err | |
97 | } | |
98 | } | |
99 | ||
100 | return nil | |
101 | } | |
102 | ||
103 | func (e *Encoder) encodeSortedMapStringInterface(m map[string]interface{}) error { | |
104 | keys := make([]string, 0, len(m)) | |
105 | for k, _ := range m { | |
106 | keys = append(keys, k) | |
107 | } | |
108 | sort.Strings(keys) | |
109 | ||
110 | for _, k := range keys { | |
111 | err := e.EncodeString(k) | |
112 | if err != nil { | |
113 | return err | |
114 | } | |
115 | if err = e.Encode(m[k]); err != nil { | |
116 | return err | |
117 | } | |
118 | } | |
119 | ||
120 | return nil | |
121 | } | |
122 | ||
123 | func (e *Encoder) EncodeMapLen(l int) error { | |
124 | if l < 16 { | |
125 | return e.writeCode(codes.FixedMapLow | codes.Code(l)) | |
126 | } | |
127 | if l < 65536 { | |
128 | return e.write2(codes.Map16, uint16(l)) | |
129 | } | |
130 | return e.write4(codes.Map32, uint32(l)) | |
131 | } | |
132 | ||
133 | func encodeStructValue(e *Encoder, strct reflect.Value) error { | |
134 | var structFields *fields | |
135 | if e.useJSONTag { | |
136 | structFields = jsonStructs.Fields(strct.Type()) | |
137 | } else { | |
138 | structFields = structs.Fields(strct.Type()) | |
139 | } | |
140 | ||
141 | if e.structAsArray || structFields.AsArray { | |
142 | return encodeStructValueAsArray(e, strct, structFields.List) | |
143 | } | |
144 | fields := structFields.OmitEmpty(strct) | |
145 | ||
146 | if err := e.EncodeMapLen(len(fields)); err != nil { | |
147 | return err | |
148 | } | |
149 | ||
150 | for _, f := range fields { | |
151 | if err := e.EncodeString(f.name); err != nil { | |
152 | return err | |
153 | } | |
154 | if err := f.EncodeValue(e, strct); err != nil { | |
155 | return err | |
156 | } | |
157 | } | |
158 | ||
159 | return nil | |
160 | } | |
161 | ||
162 | func encodeStructValueAsArray(e *Encoder, strct reflect.Value, fields []*field) error { | |
163 | if err := e.EncodeArrayLen(len(fields)); err != nil { | |
164 | return err | |
165 | } | |
166 | for _, f := range fields { | |
167 | if err := f.EncodeValue(e, strct); err != nil { | |
168 | return err | |
169 | } | |
170 | } | |
171 | return nil | |
172 | } |