Source file src/pkg/encoding/gob/encoder.go
1 // Copyright 2009 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package gob 6 7 import ( 8 "bytes" 9 "errors" 10 "io" 11 "reflect" 12 "sync" 13 ) 14 15 // An Encoder manages the transmission of type and data information to the 16 // other side of a connection. 17 type Encoder struct { 18 mutex sync.Mutex // each item must be sent atomically 19 w []io.Writer // where to send the data 20 sent map[reflect.Type]typeId // which types we've already sent 21 countState *encoderState // stage for writing counts 22 freeList *encoderState // list of free encoderStates; avoids reallocation 23 byteBuf bytes.Buffer // buffer for top-level encoderState 24 err error 25 } 26 27 // Before we encode a message, we reserve space at the head of the 28 // buffer in which to encode its length. This means we can use the 29 // buffer to assemble the message without another allocation. 30 const maxLength = 9 // Maximum size of an encoded length. 31 var spaceForLength = make([]byte, maxLength) 32 33 // NewEncoder returns a new encoder that will transmit on the io.Writer. 34 func NewEncoder(w io.Writer) *Encoder { 35 enc := new(Encoder) 36 enc.w = []io.Writer{w} 37 enc.sent = make(map[reflect.Type]typeId) 38 enc.countState = enc.newEncoderState(new(bytes.Buffer)) 39 return enc 40 } 41 42 // writer() returns the innermost writer the encoder is using 43 func (enc *Encoder) writer() io.Writer { 44 return enc.w[len(enc.w)-1] 45 } 46 47 // pushWriter adds a writer to the encoder. 48 func (enc *Encoder) pushWriter(w io.Writer) { 49 enc.w = append(enc.w, w) 50 } 51 52 // popWriter pops the innermost writer. 53 func (enc *Encoder) popWriter() { 54 enc.w = enc.w[0 : len(enc.w)-1] 55 } 56 57 func (enc *Encoder) badType(rt reflect.Type) { 58 enc.setError(errors.New("gob: can't encode type " + rt.String())) 59 } 60 61 func (enc *Encoder) setError(err error) { 62 if enc.err == nil { // remember the first. 63 enc.err = err 64 } 65 } 66 67 // writeMessage sends the data item preceded by a unsigned count of its length. 68 func (enc *Encoder) writeMessage(w io.Writer, b *bytes.Buffer) { 69 // Space has been reserved for the length at the head of the message. 70 // This is a little dirty: we grab the slice from the bytes.Buffer and massage 71 // it by hand. 72 message := b.Bytes() 73 messageLen := len(message) - maxLength 74 // Encode the length. 75 enc.countState.b.Reset() 76 enc.countState.encodeUint(uint64(messageLen)) 77 // Copy the length to be a prefix of the message. 78 offset := maxLength - enc.countState.b.Len() 79 copy(message[offset:], enc.countState.b.Bytes()) 80 // Write the data. 81 _, err := w.Write(message[offset:]) 82 // Drain the buffer and restore the space at the front for the count of the next message. 83 b.Reset() 84 b.Write(spaceForLength) 85 if err != nil { 86 enc.setError(err) 87 } 88 } 89 90 // sendActualType sends the requested type, without further investigation, unless 91 // it's been sent before. 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 typeLock.Lock() 97 info, err := getTypeInfo(ut) 98 typeLock.Unlock() 99 if err != nil { 100 enc.setError(err) 101 return 102 } 103 // Send the pair (-id, type) 104 // Id: 105 state.encodeInt(-int64(info.id)) 106 // Type: 107 enc.encode(state.b, reflect.ValueOf(info.wire), wireTypeUserInfo) 108 enc.writeMessage(w, state.b) 109 if enc.err != nil { 110 return 111 } 112 113 // Remember we've sent this type, both what the user gave us and the base type. 114 enc.sent[ut.base] = info.id 115 if ut.user != ut.base { 116 enc.sent[ut.user] = info.id 117 } 118 // Now send the inner types 119 switch st := actual; st.Kind() { 120 case reflect.Struct: 121 for i := 0; i < st.NumField(); i++ { 122 if isExported(st.Field(i).Name) { 123 enc.sendType(w, state, st.Field(i).Type) 124 } 125 } 126 case reflect.Array, reflect.Slice: 127 enc.sendType(w, state, st.Elem()) 128 case reflect.Map: 129 enc.sendType(w, state, st.Key()) 130 enc.sendType(w, state, st.Elem()) 131 } 132 return true 133 } 134 135 // sendType sends the type info to the other side, if necessary. 136 func (enc *Encoder) sendType(w io.Writer, state *encoderState, origt reflect.Type) (sent bool) { 137 ut := userType(origt) 138 if ut.isGobEncoder { 139 // The rules are different: regardless of the underlying type's representation, 140 // we need to tell the other side that this exact type is a GobEncoder. 141 return enc.sendActualType(w, state, ut, ut.user) 142 } 143 144 // It's a concrete value, so drill down to the base type. 145 switch rt := ut.base; rt.Kind() { 146 default: 147 // Basic types and interfaces do not need to be described. 148 return 149 case reflect.Slice: 150 // If it's []uint8, don't send; it's considered basic. 151 if rt.Elem().Kind() == reflect.Uint8 { 152 return 153 } 154 // Otherwise we do send. 155 break 156 case reflect.Array: 157 // arrays must be sent so we know their lengths and element types. 158 break 159 case reflect.Map: 160 // maps must be sent so we know their lengths and key/value types. 161 break 162 case reflect.Struct: 163 // structs must be sent so we know their fields. 164 break 165 case reflect.Chan, reflect.Func: 166 // Probably a bad field in a struct. 167 enc.badType(rt) 168 return 169 } 170 171 return enc.sendActualType(w, state, ut, ut.base) 172 } 173 174 // Encode transmits the data item represented by the empty interface value, 175 // guaranteeing that all necessary type information has been transmitted first. 176 func (enc *Encoder) Encode(e interface{}) error { 177 return enc.EncodeValue(reflect.ValueOf(e)) 178 } 179 180 // sendTypeDescriptor makes sure the remote side knows about this type. 181 // It will send a descriptor if this is the first time the type has been 182 // sent. 183 func (enc *Encoder) sendTypeDescriptor(w io.Writer, state *encoderState, ut *userTypeInfo) { 184 // Make sure the type is known to the other side. 185 // First, have we already sent this type? 186 rt := ut.base 187 if ut.isGobEncoder { 188 rt = ut.user 189 } 190 if _, alreadySent := enc.sent[rt]; !alreadySent { 191 // No, so send it. 192 sent := enc.sendType(w, state, rt) 193 if enc.err != nil { 194 return 195 } 196 // If the type info has still not been transmitted, it means we have 197 // a singleton basic type (int, []byte etc.) at top level. We don't 198 // need to send the type info but we do need to update enc.sent. 199 if !sent { 200 typeLock.Lock() 201 info, err := getTypeInfo(ut) 202 typeLock.Unlock() 203 if err != nil { 204 enc.setError(err) 205 return 206 } 207 enc.sent[rt] = info.id 208 } 209 } 210 } 211 212 // sendTypeId sends the id, which must have already been defined. 213 func (enc *Encoder) sendTypeId(state *encoderState, ut *userTypeInfo) { 214 // Identify the type of this top-level value. 215 state.encodeInt(int64(enc.sent[ut.base])) 216 } 217 218 // EncodeValue transmits the data item represented by the reflection value, 219 // guaranteeing that all necessary type information has been transmitted first. 220 func (enc *Encoder) EncodeValue(value reflect.Value) error { 221 // Make sure we're single-threaded through here, so multiple 222 // goroutines can share an encoder. 223 enc.mutex.Lock() 224 defer enc.mutex.Unlock() 225 226 // Remove any nested writers remaining due to previous errors. 227 enc.w = enc.w[0:1] 228 229 ut, err := validUserType(value.Type()) 230 if err != nil { 231 return err 232 } 233 234 enc.err = nil 235 enc.byteBuf.Reset() 236 enc.byteBuf.Write(spaceForLength) 237 state := enc.newEncoderState(&enc.byteBuf) 238 239 enc.sendTypeDescriptor(enc.writer(), state, ut) 240 enc.sendTypeId(state, ut) 241 if enc.err != nil { 242 return enc.err 243 } 244 245 // Encode the object. 246 enc.encode(state.b, value, ut) 247 if enc.err == nil { 248 enc.writeMessage(enc.writer(), state.b) 249 } 250 251 enc.freeEncoderState(state) 252 return enc.err 253 }