1
2
3
4
5 package gob
6
7 import (
8 "errors"
9 "io"
10 "reflect"
11 "sync"
12 )
13
14
15
16 type Encoder struct {
17 mutex sync.Mutex
18 w []io.Writer
19 sent map[reflect.Type]typeId
20 countState *encoderState
21 freeList *encoderState
22 byteBuf encBuffer
23 err error
24 }
25
26
27
28
29 const maxLength = 9
30 var spaceForLength = make([]byte, maxLength)
31
32
33 func NewEncoder(w io.Writer) *Encoder {
34 enc := new(Encoder)
35 enc.w = []io.Writer{w}
36 enc.sent = make(map[reflect.Type]typeId)
37 enc.countState = enc.newEncoderState(new(encBuffer))
38 return enc
39 }
40
41
42 func (enc *Encoder) writer() io.Writer {
43 return enc.w[len(enc.w)-1]
44 }
45
46
47 func (enc *Encoder) pushWriter(w io.Writer) {
48 enc.w = append(enc.w, w)
49 }
50
51
52 func (enc *Encoder) popWriter() {
53 enc.w = enc.w[0 : len(enc.w)-1]
54 }
55
56 func (enc *Encoder) setError(err error) {
57 if enc.err == nil {
58 enc.err = err
59 }
60 }
61
62
63 func (enc *Encoder) writeMessage(w io.Writer, b *encBuffer) {
64
65
66
67 message := b.Bytes()
68 messageLen := len(message) - maxLength
69
70 if messageLen >= tooBig {
71 enc.setError(errors.New("gob: encoder: message too big"))
72 return
73 }
74
75 enc.countState.b.Reset()
76 enc.countState.encodeUint(uint64(messageLen))
77
78 offset := maxLength - enc.countState.b.Len()
79 copy(message[offset:], enc.countState.b.Bytes())
80
81 _, err := w.Write(message[offset:])
82
83 b.Reset()
84 b.Write(spaceForLength)
85 if err != nil {
86 enc.setError(err)
87 }
88 }
89
90
91
92 func (enc *Encoder) sendActualType(w io.Writer, state *encoderState, ut *userTypeInfo, actual reflect.Type) (sent bool) {
93 if _, alreadySent := enc.sent[actual]; alreadySent {
94 return false
95 }
96 info, err := getTypeInfo(ut)
97 if err != nil {
98 enc.setError(err)
99 return
100 }
101
102
103 state.encodeInt(-int64(info.id))
104
105 enc.encode(state.b, reflect.ValueOf(info.wire), wireTypeUserInfo)
106 enc.writeMessage(w, state.b)
107 if enc.err != nil {
108 return
109 }
110
111
112 enc.sent[ut.base] = info.id
113 if ut.user != ut.base {
114 enc.sent[ut.user] = info.id
115 }
116
117 switch st := actual; st.Kind() {
118 case reflect.Struct:
119 for i := 0; i < st.NumField(); i++ {
120 if isExported(st.Field(i).Name) {
121 enc.sendType(w, state, st.Field(i).Type)
122 }
123 }
124 case reflect.Array, reflect.Slice:
125 enc.sendType(w, state, st.Elem())
126 case reflect.Map:
127 enc.sendType(w, state, st.Key())
128 enc.sendType(w, state, st.Elem())
129 }
130 return true
131 }
132
133
134 func (enc *Encoder) sendType(w io.Writer, state *encoderState, origt reflect.Type) (sent bool) {
135 ut := userType(origt)
136 if ut.externalEnc != 0 {
137
138
139 return enc.sendActualType(w, state, ut, ut.base)
140 }
141
142
143 switch rt := ut.base; rt.Kind() {
144 default:
145
146 return
147 case reflect.Slice:
148
149 if rt.Elem().Kind() == reflect.Uint8 {
150 return
151 }
152
153 break
154 case reflect.Array:
155
156 break
157 case reflect.Map:
158
159 break
160 case reflect.Struct:
161
162 break
163 case reflect.Chan, reflect.Func:
164
165 return
166 }
167
168 return enc.sendActualType(w, state, ut, ut.base)
169 }
170
171
172
173
174 func (enc *Encoder) Encode(e interface{}) error {
175 return enc.EncodeValue(reflect.ValueOf(e))
176 }
177
178
179
180
181 func (enc *Encoder) sendTypeDescriptor(w io.Writer, state *encoderState, ut *userTypeInfo) {
182
183
184 rt := ut.base
185 if ut.externalEnc != 0 {
186 rt = ut.user
187 }
188 if _, alreadySent := enc.sent[rt]; !alreadySent {
189
190 sent := enc.sendType(w, state, rt)
191 if enc.err != nil {
192 return
193 }
194
195
196
197 if !sent {
198 info, err := getTypeInfo(ut)
199 if err != nil {
200 enc.setError(err)
201 return
202 }
203 enc.sent[rt] = info.id
204 }
205 }
206 }
207
208
209 func (enc *Encoder) sendTypeId(state *encoderState, ut *userTypeInfo) {
210
211 state.encodeInt(int64(enc.sent[ut.base]))
212 }
213
214
215
216
217 func (enc *Encoder) EncodeValue(value reflect.Value) error {
218 if value.Kind() == reflect.Invalid {
219 return errors.New("gob: cannot encode nil value")
220 }
221 if value.Kind() == reflect.Ptr && value.IsNil() {
222 panic("gob: cannot encode nil pointer of type " + value.Type().String())
223 }
224
225
226
227 enc.mutex.Lock()
228 defer enc.mutex.Unlock()
229
230
231 enc.w = enc.w[0:1]
232
233 ut, err := validUserType(value.Type())
234 if err != nil {
235 return err
236 }
237
238 enc.err = nil
239 enc.byteBuf.Reset()
240 enc.byteBuf.Write(spaceForLength)
241 state := enc.newEncoderState(&enc.byteBuf)
242
243 enc.sendTypeDescriptor(enc.writer(), state, ut)
244 enc.sendTypeId(state, ut)
245 if enc.err != nil {
246 return enc.err
247 }
248
249
250 enc.encode(state.b, value, ut)
251 if enc.err == nil {
252 enc.writeMessage(enc.writer(), state.b)
253 }
254
255 enc.freeEncoderState(state)
256 return enc.err
257 }
258
View as plain text