]>
Commit | Line | Data |
---|---|---|
107c1cdb ND |
1 | package msgpack |
2 | ||
3 | import ( | |
4 | "reflect" | |
5 | ||
6 | "github.com/vmihailenco/msgpack/codes" | |
7 | ) | |
8 | ||
9 | func encodeStringValue(e *Encoder, v reflect.Value) error { | |
10 | return e.EncodeString(v.String()) | |
11 | } | |
12 | ||
13 | func encodeByteSliceValue(e *Encoder, v reflect.Value) error { | |
14 | return e.EncodeBytes(v.Bytes()) | |
15 | } | |
16 | ||
17 | func encodeByteArrayValue(e *Encoder, v reflect.Value) error { | |
18 | if err := e.EncodeBytesLen(v.Len()); err != nil { | |
19 | return err | |
20 | } | |
21 | ||
22 | if v.CanAddr() { | |
23 | b := v.Slice(0, v.Len()).Bytes() | |
24 | return e.write(b) | |
25 | } | |
26 | ||
27 | e.buf = grow(e.buf, v.Len()) | |
28 | reflect.Copy(reflect.ValueOf(e.buf), v) | |
29 | return e.write(e.buf) | |
30 | } | |
31 | ||
32 | func grow(b []byte, n int) []byte { | |
33 | if cap(b) >= n { | |
34 | return b[:n] | |
35 | } | |
36 | b = b[:cap(b)] | |
37 | b = append(b, make([]byte, n-len(b))...) | |
38 | return b | |
39 | } | |
40 | ||
41 | func (e *Encoder) EncodeBytesLen(l int) error { | |
42 | if l < 256 { | |
43 | return e.write1(codes.Bin8, uint8(l)) | |
44 | } | |
45 | if l < 65536 { | |
46 | return e.write2(codes.Bin16, uint16(l)) | |
47 | } | |
48 | return e.write4(codes.Bin32, uint32(l)) | |
49 | } | |
50 | ||
51 | func (e *Encoder) encodeStrLen(l int) error { | |
52 | if l < 32 { | |
53 | return e.writeCode(codes.FixedStrLow | codes.Code(l)) | |
54 | } | |
55 | if l < 256 { | |
56 | return e.write1(codes.Str8, uint8(l)) | |
57 | } | |
58 | if l < 65536 { | |
59 | return e.write2(codes.Str16, uint16(l)) | |
60 | } | |
61 | return e.write4(codes.Str32, uint32(l)) | |
62 | } | |
63 | ||
64 | func (e *Encoder) EncodeString(v string) error { | |
65 | if err := e.encodeStrLen(len(v)); err != nil { | |
66 | return err | |
67 | } | |
68 | return e.writeString(v) | |
69 | } | |
70 | ||
71 | func (e *Encoder) EncodeBytes(v []byte) error { | |
72 | if v == nil { | |
73 | return e.EncodeNil() | |
74 | } | |
75 | if err := e.EncodeBytesLen(len(v)); err != nil { | |
76 | return err | |
77 | } | |
78 | return e.write(v) | |
79 | } | |
80 | ||
81 | func (e *Encoder) EncodeArrayLen(l int) error { | |
82 | if l < 16 { | |
83 | return e.writeCode(codes.FixedArrayLow | codes.Code(l)) | |
84 | } | |
85 | if l < 65536 { | |
86 | return e.write2(codes.Array16, uint16(l)) | |
87 | } | |
88 | return e.write4(codes.Array32, uint32(l)) | |
89 | } | |
90 | ||
91 | func (e *Encoder) encodeStringSlice(s []string) error { | |
92 | if s == nil { | |
93 | return e.EncodeNil() | |
94 | } | |
95 | if err := e.EncodeArrayLen(len(s)); err != nil { | |
96 | return err | |
97 | } | |
98 | for _, v := range s { | |
99 | if err := e.EncodeString(v); err != nil { | |
100 | return err | |
101 | } | |
102 | } | |
103 | return nil | |
104 | } | |
105 | ||
106 | func encodeSliceValue(e *Encoder, v reflect.Value) error { | |
107 | if v.IsNil() { | |
108 | return e.EncodeNil() | |
109 | } | |
110 | return encodeArrayValue(e, v) | |
111 | } | |
112 | ||
113 | func encodeArrayValue(e *Encoder, v reflect.Value) error { | |
114 | l := v.Len() | |
115 | if err := e.EncodeArrayLen(l); err != nil { | |
116 | return err | |
117 | } | |
118 | for i := 0; i < l; i++ { | |
119 | if err := e.EncodeValue(v.Index(i)); err != nil { | |
120 | return err | |
121 | } | |
122 | } | |
123 | return nil | |
124 | } |