diff options
Diffstat (limited to 'vendor/github.com/vmihailenco/msgpack/decode.go')
-rw-r--r-- | vendor/github.com/vmihailenco/msgpack/decode.go | 546 |
1 files changed, 546 insertions, 0 deletions
diff --git a/vendor/github.com/vmihailenco/msgpack/decode.go b/vendor/github.com/vmihailenco/msgpack/decode.go new file mode 100644 index 0000000..7414100 --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/decode.go | |||
@@ -0,0 +1,546 @@ | |||
1 | package msgpack | ||
2 | |||
3 | import ( | ||
4 | "bufio" | ||
5 | "bytes" | ||
6 | "errors" | ||
7 | "fmt" | ||
8 | "io" | ||
9 | "reflect" | ||
10 | "time" | ||
11 | |||
12 | "github.com/vmihailenco/msgpack/codes" | ||
13 | ) | ||
14 | |||
15 | const bytesAllocLimit = 1024 * 1024 // 1mb | ||
16 | |||
17 | type bufReader interface { | ||
18 | io.Reader | ||
19 | io.ByteScanner | ||
20 | } | ||
21 | |||
22 | func newBufReader(r io.Reader) bufReader { | ||
23 | if br, ok := r.(bufReader); ok { | ||
24 | return br | ||
25 | } | ||
26 | return bufio.NewReader(r) | ||
27 | } | ||
28 | |||
29 | func makeBuffer() []byte { | ||
30 | return make([]byte, 0, 64) | ||
31 | } | ||
32 | |||
33 | // Unmarshal decodes the MessagePack-encoded data and stores the result | ||
34 | // in the value pointed to by v. | ||
35 | func Unmarshal(data []byte, v interface{}) error { | ||
36 | return NewDecoder(bytes.NewReader(data)).Decode(v) | ||
37 | } | ||
38 | |||
39 | type Decoder struct { | ||
40 | r io.Reader | ||
41 | s io.ByteScanner | ||
42 | buf []byte | ||
43 | |||
44 | extLen int | ||
45 | rec []byte // accumulates read data if not nil | ||
46 | |||
47 | useLoose bool | ||
48 | useJSONTag bool | ||
49 | |||
50 | decodeMapFunc func(*Decoder) (interface{}, error) | ||
51 | } | ||
52 | |||
53 | // NewDecoder returns a new decoder that reads from r. | ||
54 | // | ||
55 | // The decoder introduces its own buffering and may read data from r | ||
56 | // beyond the MessagePack values requested. Buffering can be disabled | ||
57 | // by passing a reader that implements io.ByteScanner interface. | ||
58 | func NewDecoder(r io.Reader) *Decoder { | ||
59 | d := &Decoder{ | ||
60 | buf: makeBuffer(), | ||
61 | } | ||
62 | d.resetReader(r) | ||
63 | return d | ||
64 | } | ||
65 | |||
66 | func (d *Decoder) SetDecodeMapFunc(fn func(*Decoder) (interface{}, error)) { | ||
67 | d.decodeMapFunc = fn | ||
68 | } | ||
69 | |||
70 | // UseDecodeInterfaceLoose causes decoder to use DecodeInterfaceLoose | ||
71 | // to decode msgpack value into Go interface{}. | ||
72 | func (d *Decoder) UseDecodeInterfaceLoose(flag bool) { | ||
73 | d.useLoose = flag | ||
74 | } | ||
75 | |||
76 | // UseJSONTag causes the Decoder to use json struct tag as fallback option | ||
77 | // if there is no msgpack tag. | ||
78 | func (d *Decoder) UseJSONTag(v bool) *Decoder { | ||
79 | d.useJSONTag = v | ||
80 | return d | ||
81 | } | ||
82 | |||
83 | func (d *Decoder) Reset(r io.Reader) error { | ||
84 | d.resetReader(r) | ||
85 | return nil | ||
86 | } | ||
87 | |||
88 | func (d *Decoder) resetReader(r io.Reader) { | ||
89 | reader := newBufReader(r) | ||
90 | d.r = reader | ||
91 | d.s = reader | ||
92 | } | ||
93 | |||
94 | func (d *Decoder) Decode(v interface{}) error { | ||
95 | var err error | ||
96 | switch v := v.(type) { | ||
97 | case *string: | ||
98 | if v != nil { | ||
99 | *v, err = d.DecodeString() | ||
100 | return err | ||
101 | } | ||
102 | case *[]byte: | ||
103 | if v != nil { | ||
104 | return d.decodeBytesPtr(v) | ||
105 | } | ||
106 | case *int: | ||
107 | if v != nil { | ||
108 | *v, err = d.DecodeInt() | ||
109 | return err | ||
110 | } | ||
111 | case *int8: | ||
112 | if v != nil { | ||
113 | *v, err = d.DecodeInt8() | ||
114 | return err | ||
115 | } | ||
116 | case *int16: | ||
117 | if v != nil { | ||
118 | *v, err = d.DecodeInt16() | ||
119 | return err | ||
120 | } | ||
121 | case *int32: | ||
122 | if v != nil { | ||
123 | *v, err = d.DecodeInt32() | ||
124 | return err | ||
125 | } | ||
126 | case *int64: | ||
127 | if v != nil { | ||
128 | *v, err = d.DecodeInt64() | ||
129 | return err | ||
130 | } | ||
131 | case *uint: | ||
132 | if v != nil { | ||
133 | *v, err = d.DecodeUint() | ||
134 | return err | ||
135 | } | ||
136 | case *uint8: | ||
137 | if v != nil { | ||
138 | *v, err = d.DecodeUint8() | ||
139 | return err | ||
140 | } | ||
141 | case *uint16: | ||
142 | if v != nil { | ||
143 | *v, err = d.DecodeUint16() | ||
144 | return err | ||
145 | } | ||
146 | case *uint32: | ||
147 | if v != nil { | ||
148 | *v, err = d.DecodeUint32() | ||
149 | return err | ||
150 | } | ||
151 | case *uint64: | ||
152 | if v != nil { | ||
153 | *v, err = d.DecodeUint64() | ||
154 | return err | ||
155 | } | ||
156 | case *bool: | ||
157 | if v != nil { | ||
158 | *v, err = d.DecodeBool() | ||
159 | return err | ||
160 | } | ||
161 | case *float32: | ||
162 | if v != nil { | ||
163 | *v, err = d.DecodeFloat32() | ||
164 | return err | ||
165 | } | ||
166 | case *float64: | ||
167 | if v != nil { | ||
168 | *v, err = d.DecodeFloat64() | ||
169 | return err | ||
170 | } | ||
171 | case *[]string: | ||
172 | return d.decodeStringSlicePtr(v) | ||
173 | case *map[string]string: | ||
174 | return d.decodeMapStringStringPtr(v) | ||
175 | case *map[string]interface{}: | ||
176 | return d.decodeMapStringInterfacePtr(v) | ||
177 | case *time.Duration: | ||
178 | if v != nil { | ||
179 | vv, err := d.DecodeInt64() | ||
180 | *v = time.Duration(vv) | ||
181 | return err | ||
182 | } | ||
183 | case *time.Time: | ||
184 | if v != nil { | ||
185 | *v, err = d.DecodeTime() | ||
186 | return err | ||
187 | } | ||
188 | } | ||
189 | |||
190 | vv := reflect.ValueOf(v) | ||
191 | if !vv.IsValid() { | ||
192 | return errors.New("msgpack: Decode(nil)") | ||
193 | } | ||
194 | if vv.Kind() != reflect.Ptr { | ||
195 | return fmt.Errorf("msgpack: Decode(nonsettable %T)", v) | ||
196 | } | ||
197 | vv = vv.Elem() | ||
198 | if !vv.IsValid() { | ||
199 | return fmt.Errorf("msgpack: Decode(nonsettable %T)", v) | ||
200 | } | ||
201 | return d.DecodeValue(vv) | ||
202 | } | ||
203 | |||
204 | func (d *Decoder) DecodeMulti(v ...interface{}) error { | ||
205 | for _, vv := range v { | ||
206 | if err := d.Decode(vv); err != nil { | ||
207 | return err | ||
208 | } | ||
209 | } | ||
210 | return nil | ||
211 | } | ||
212 | |||
213 | func (d *Decoder) decodeInterfaceCond() (interface{}, error) { | ||
214 | if d.useLoose { | ||
215 | return d.DecodeInterfaceLoose() | ||
216 | } | ||
217 | return d.DecodeInterface() | ||
218 | } | ||
219 | |||
220 | func (d *Decoder) DecodeValue(v reflect.Value) error { | ||
221 | decode := getDecoder(v.Type()) | ||
222 | return decode(d, v) | ||
223 | } | ||
224 | |||
225 | func (d *Decoder) DecodeNil() error { | ||
226 | c, err := d.readCode() | ||
227 | if err != nil { | ||
228 | return err | ||
229 | } | ||
230 | if c != codes.Nil { | ||
231 | return fmt.Errorf("msgpack: invalid code=%x decoding nil", c) | ||
232 | } | ||
233 | return nil | ||
234 | } | ||
235 | |||
236 | func (d *Decoder) decodeNilValue(v reflect.Value) error { | ||
237 | err := d.DecodeNil() | ||
238 | if v.IsNil() { | ||
239 | return err | ||
240 | } | ||
241 | if v.Kind() == reflect.Ptr { | ||
242 | v = v.Elem() | ||
243 | } | ||
244 | v.Set(reflect.Zero(v.Type())) | ||
245 | return err | ||
246 | } | ||
247 | |||
248 | func (d *Decoder) DecodeBool() (bool, error) { | ||
249 | c, err := d.readCode() | ||
250 | if err != nil { | ||
251 | return false, err | ||
252 | } | ||
253 | return d.bool(c) | ||
254 | } | ||
255 | |||
256 | func (d *Decoder) bool(c codes.Code) (bool, error) { | ||
257 | if c == codes.False { | ||
258 | return false, nil | ||
259 | } | ||
260 | if c == codes.True { | ||
261 | return true, nil | ||
262 | } | ||
263 | return false, fmt.Errorf("msgpack: invalid code=%x decoding bool", c) | ||
264 | } | ||
265 | |||
266 | // DecodeInterface decodes value into interface. It returns following types: | ||
267 | // - nil, | ||
268 | // - bool, | ||
269 | // - int8, int16, int32, int64, | ||
270 | // - uint8, uint16, uint32, uint64, | ||
271 | // - float32 and float64, | ||
272 | // - string, | ||
273 | // - []byte, | ||
274 | // - slices of any of the above, | ||
275 | // - maps of any of the above. | ||
276 | // | ||
277 | // DecodeInterface should be used only when you don't know the type of value | ||
278 | // you are decoding. For example, if you are decoding number it is better to use | ||
279 | // DecodeInt64 for negative numbers and DecodeUint64 for positive numbers. | ||
280 | func (d *Decoder) DecodeInterface() (interface{}, error) { | ||
281 | c, err := d.readCode() | ||
282 | if err != nil { | ||
283 | return nil, err | ||
284 | } | ||
285 | |||
286 | if codes.IsFixedNum(c) { | ||
287 | return int8(c), nil | ||
288 | } | ||
289 | if codes.IsFixedMap(c) { | ||
290 | err = d.s.UnreadByte() | ||
291 | if err != nil { | ||
292 | return nil, err | ||
293 | } | ||
294 | return d.DecodeMap() | ||
295 | } | ||
296 | if codes.IsFixedArray(c) { | ||
297 | return d.decodeSlice(c) | ||
298 | } | ||
299 | if codes.IsFixedString(c) { | ||
300 | return d.string(c) | ||
301 | } | ||
302 | |||
303 | switch c { | ||
304 | case codes.Nil: | ||
305 | return nil, nil | ||
306 | case codes.False, codes.True: | ||
307 | return d.bool(c) | ||
308 | case codes.Float: | ||
309 | return d.float32(c) | ||
310 | case codes.Double: | ||
311 | return d.float64(c) | ||
312 | case codes.Uint8: | ||
313 | return d.uint8() | ||
314 | case codes.Uint16: | ||
315 | return d.uint16() | ||
316 | case codes.Uint32: | ||
317 | return d.uint32() | ||
318 | case codes.Uint64: | ||
319 | return d.uint64() | ||
320 | case codes.Int8: | ||
321 | return d.int8() | ||
322 | case codes.Int16: | ||
323 | return d.int16() | ||
324 | case codes.Int32: | ||
325 | return d.int32() | ||
326 | case codes.Int64: | ||
327 | return d.int64() | ||
328 | case codes.Bin8, codes.Bin16, codes.Bin32: | ||
329 | return d.bytes(c, nil) | ||
330 | case codes.Str8, codes.Str16, codes.Str32: | ||
331 | return d.string(c) | ||
332 | case codes.Array16, codes.Array32: | ||
333 | return d.decodeSlice(c) | ||
334 | case codes.Map16, codes.Map32: | ||
335 | err = d.s.UnreadByte() | ||
336 | if err != nil { | ||
337 | return nil, err | ||
338 | } | ||
339 | return d.DecodeMap() | ||
340 | case codes.FixExt1, codes.FixExt2, codes.FixExt4, codes.FixExt8, codes.FixExt16, | ||
341 | codes.Ext8, codes.Ext16, codes.Ext32: | ||
342 | return d.extInterface(c) | ||
343 | } | ||
344 | |||
345 | return 0, fmt.Errorf("msgpack: unknown code %x decoding interface{}", c) | ||
346 | } | ||
347 | |||
348 | // DecodeInterfaceLoose is like DecodeInterface except that: | ||
349 | // - int8, int16, and int32 are converted to int64, | ||
350 | // - uint8, uint16, and uint32 are converted to uint64, | ||
351 | // - float32 is converted to float64. | ||
352 | func (d *Decoder) DecodeInterfaceLoose() (interface{}, error) { | ||
353 | c, err := d.readCode() | ||
354 | if err != nil { | ||
355 | return nil, err | ||
356 | } | ||
357 | |||
358 | if codes.IsFixedNum(c) { | ||
359 | return int64(c), nil | ||
360 | } | ||
361 | if codes.IsFixedMap(c) { | ||
362 | err = d.s.UnreadByte() | ||
363 | if err != nil { | ||
364 | return nil, err | ||
365 | } | ||
366 | return d.DecodeMap() | ||
367 | } | ||
368 | if codes.IsFixedArray(c) { | ||
369 | return d.decodeSlice(c) | ||
370 | } | ||
371 | if codes.IsFixedString(c) { | ||
372 | return d.string(c) | ||
373 | } | ||
374 | |||
375 | switch c { | ||
376 | case codes.Nil: | ||
377 | return nil, nil | ||
378 | case codes.False, codes.True: | ||
379 | return d.bool(c) | ||
380 | case codes.Float, codes.Double: | ||
381 | return d.float64(c) | ||
382 | case codes.Uint8, codes.Uint16, codes.Uint32, codes.Uint64: | ||
383 | return d.uint(c) | ||
384 | case codes.Int8, codes.Int16, codes.Int32, codes.Int64: | ||
385 | return d.int(c) | ||
386 | case codes.Bin8, codes.Bin16, codes.Bin32: | ||
387 | return d.bytes(c, nil) | ||
388 | case codes.Str8, codes.Str16, codes.Str32: | ||
389 | return d.string(c) | ||
390 | case codes.Array16, codes.Array32: | ||
391 | return d.decodeSlice(c) | ||
392 | case codes.Map16, codes.Map32: | ||
393 | err = d.s.UnreadByte() | ||
394 | if err != nil { | ||
395 | return nil, err | ||
396 | } | ||
397 | return d.DecodeMap() | ||
398 | case codes.FixExt1, codes.FixExt2, codes.FixExt4, codes.FixExt8, codes.FixExt16, | ||
399 | codes.Ext8, codes.Ext16, codes.Ext32: | ||
400 | return d.extInterface(c) | ||
401 | } | ||
402 | |||
403 | return 0, fmt.Errorf("msgpack: unknown code %x decoding interface{}", c) | ||
404 | } | ||
405 | |||
406 | // Skip skips next value. | ||
407 | func (d *Decoder) Skip() error { | ||
408 | c, err := d.readCode() | ||
409 | if err != nil { | ||
410 | return err | ||
411 | } | ||
412 | |||
413 | if codes.IsFixedNum(c) { | ||
414 | return nil | ||
415 | } else if codes.IsFixedMap(c) { | ||
416 | return d.skipMap(c) | ||
417 | } else if codes.IsFixedArray(c) { | ||
418 | return d.skipSlice(c) | ||
419 | } else if codes.IsFixedString(c) { | ||
420 | return d.skipBytes(c) | ||
421 | } | ||
422 | |||
423 | switch c { | ||
424 | case codes.Nil, codes.False, codes.True: | ||
425 | return nil | ||
426 | case codes.Uint8, codes.Int8: | ||
427 | return d.skipN(1) | ||
428 | case codes.Uint16, codes.Int16: | ||
429 | return d.skipN(2) | ||
430 | case codes.Uint32, codes.Int32, codes.Float: | ||
431 | return d.skipN(4) | ||
432 | case codes.Uint64, codes.Int64, codes.Double: | ||
433 | return d.skipN(8) | ||
434 | case codes.Bin8, codes.Bin16, codes.Bin32: | ||
435 | return d.skipBytes(c) | ||
436 | case codes.Str8, codes.Str16, codes.Str32: | ||
437 | return d.skipBytes(c) | ||
438 | case codes.Array16, codes.Array32: | ||
439 | return d.skipSlice(c) | ||
440 | case codes.Map16, codes.Map32: | ||
441 | return d.skipMap(c) | ||
442 | case codes.FixExt1, codes.FixExt2, codes.FixExt4, codes.FixExt8, codes.FixExt16, | ||
443 | codes.Ext8, codes.Ext16, codes.Ext32: | ||
444 | return d.skipExt(c) | ||
445 | } | ||
446 | |||
447 | return fmt.Errorf("msgpack: unknown code %x", c) | ||
448 | } | ||
449 | |||
450 | // PeekCode returns the next MessagePack code without advancing the reader. | ||
451 | // Subpackage msgpack/codes contains list of available codes. | ||
452 | func (d *Decoder) PeekCode() (codes.Code, error) { | ||
453 | c, err := d.s.ReadByte() | ||
454 | if err != nil { | ||
455 | return 0, err | ||
456 | } | ||
457 | return codes.Code(c), d.s.UnreadByte() | ||
458 | } | ||
459 | |||
460 | func (d *Decoder) hasNilCode() bool { | ||
461 | code, err := d.PeekCode() | ||
462 | return err == nil && code == codes.Nil | ||
463 | } | ||
464 | |||
465 | func (d *Decoder) readCode() (codes.Code, error) { | ||
466 | d.extLen = 0 | ||
467 | c, err := d.s.ReadByte() | ||
468 | if err != nil { | ||
469 | return 0, err | ||
470 | } | ||
471 | if d.rec != nil { | ||
472 | d.rec = append(d.rec, c) | ||
473 | } | ||
474 | return codes.Code(c), nil | ||
475 | } | ||
476 | |||
477 | func (d *Decoder) readFull(b []byte) error { | ||
478 | _, err := io.ReadFull(d.r, b) | ||
479 | if err != nil { | ||
480 | return err | ||
481 | } | ||
482 | if d.rec != nil { | ||
483 | d.rec = append(d.rec, b...) | ||
484 | } | ||
485 | return nil | ||
486 | } | ||
487 | |||
488 | func (d *Decoder) readN(n int) ([]byte, error) { | ||
489 | buf, err := readN(d.r, d.buf, n) | ||
490 | if err != nil { | ||
491 | return nil, err | ||
492 | } | ||
493 | d.buf = buf | ||
494 | if d.rec != nil { | ||
495 | d.rec = append(d.rec, buf...) | ||
496 | } | ||
497 | return buf, nil | ||
498 | } | ||
499 | |||
500 | func readN(r io.Reader, b []byte, n int) ([]byte, error) { | ||
501 | if b == nil { | ||
502 | if n == 0 { | ||
503 | return make([]byte, 0), nil | ||
504 | } | ||
505 | if n <= bytesAllocLimit { | ||
506 | b = make([]byte, n) | ||
507 | } else { | ||
508 | b = make([]byte, bytesAllocLimit) | ||
509 | } | ||
510 | } | ||
511 | |||
512 | if n <= cap(b) { | ||
513 | b = b[:n] | ||
514 | _, err := io.ReadFull(r, b) | ||
515 | return b, err | ||
516 | } | ||
517 | b = b[:cap(b)] | ||
518 | |||
519 | var pos int | ||
520 | for { | ||
521 | alloc := n - len(b) | ||
522 | if alloc > bytesAllocLimit { | ||
523 | alloc = bytesAllocLimit | ||
524 | } | ||
525 | b = append(b, make([]byte, alloc)...) | ||
526 | |||
527 | _, err := io.ReadFull(r, b[pos:]) | ||
528 | if err != nil { | ||
529 | return nil, err | ||
530 | } | ||
531 | |||
532 | if len(b) == n { | ||
533 | break | ||
534 | } | ||
535 | pos = len(b) | ||
536 | } | ||
537 | |||
538 | return b, nil | ||
539 | } | ||
540 | |||
541 | func min(a, b int) int { | ||
542 | if a <= b { | ||
543 | return a | ||
544 | } | ||
545 | return b | ||
546 | } | ||