libgo/go/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                         enc.sendType(w, state, st.Field(i).Type)
 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 // sendType sends the type info to the other side, if necessary.
 134 func (enc *Encoder) sendType(w io.Writer, state *encoderState, origt reflect.Type) (sent bool) {
 135         ut := userType(origt)
 136         if ut.isGobEncoder {
 137                 // The rules are different: regardless of the underlying type's representation,
 138                 // we need to tell the other side that this exact type is a GobEncoder.
 139                 return enc.sendActualType(w, state, ut, ut.user)
 140         }
 141
 142         // It's a concrete value, so drill down to the base type.
 143         switch rt := ut.base; rt.Kind() {
 144         default:
 145                 // Basic types and interfaces do not need to be described.
 146                 return
 147         case reflect.Slice:
 148                 // If it's []uint8, don't send; it's considered basic.
 149                 if rt.Elem().Kind() == reflect.Uint8 {
 150                         return
 151                 }
 152                 // Otherwise we do send.
 153                 break
 154         case reflect.Array:
 155                 // arrays must be sent so we know their lengths and element types.
 156                 break
 157         case reflect.Map:
 158                 // maps must be sent so we know their lengths and key/value types.
 159                 break
 160         case reflect.Struct:
 161                 // structs must be sent so we know their fields.
 162                 break
 163         case reflect.Chan, reflect.Func:
 164                 // Probably a bad field in a struct.
 165                 enc.badType(rt)
 166                 return
 167         }
 168
 169         return enc.sendActualType(w, state, ut, ut.base)
 170 }
 171
 172 // Encode transmits the data item represented by the empty interface value,
 173 // guaranteeing that all necessary type information has been transmitted first.
 174 func (enc *Encoder) Encode(e interface{}) error {
 175         return enc.EncodeValue(reflect.ValueOf(e))
 176 }
 177
 178 // sendTypeDescriptor makes sure the remote side knows about this type.
 179 // It will send a descriptor if this is the first time the type has been
 180 // sent.
 181 func (enc *Encoder) sendTypeDescriptor(w io.Writer, state *encoderState, ut *userTypeInfo) {
 182         // Make sure the type is known to the other side.
 183         // First, have we already sent this type?
 184         rt := ut.base
 185         if ut.isGobEncoder {
 186                 rt = ut.user
 187         }
 188         if _, alreadySent := enc.sent[rt]; !alreadySent {
 189                 // No, so send it.
 190                 sent := enc.sendType(w, state, rt)
 191                 if enc.err != nil {
 192                         return
 193                 }
 194                 // If the type info has still not been transmitted, it means we have
 195                 // a singleton basic type (int, []byte etc.) at top level.  We don't
 196                 // need to send the type info but we do need to update enc.sent.
 197                 if !sent {
 198                         typeLock.Lock()
 199                         info, err := getTypeInfo(ut)
 200                         typeLock.Unlock()
 201                         if err != nil {
 202                                 enc.setError(err)
 203                                 return
 204                         }
 205                         enc.sent[rt] = info.id
 206                 }
 207         }
 208 }
 209
 210 // sendTypeId sends the id, which must have already been defined.
 211 func (enc *Encoder) sendTypeId(state *encoderState, ut *userTypeInfo) {
 212         // Identify the type of this top-level value.
 213         state.encodeInt(int64(enc.sent[ut.base]))
 214 }
 215
 216 // EncodeValue transmits the data item represented by the reflection value,
 217 // guaranteeing that all necessary type information has been transmitted first.
 218 func (enc *Encoder) EncodeValue(value reflect.Value) error {
 219         // Make sure we're single-threaded through here, so multiple
 220         // goroutines can share an encoder.
 221         enc.mutex.Lock()
 222         defer enc.mutex.Unlock()
 223
 224         // Remove any nested writers remaining due to previous errors.
 225         enc.w = enc.w[0:1]
 226
 227         ut, err := validUserType(value.Type())
 228         if err != nil {
 229                 return err
 230         }
 231
 232         enc.err = nil
 233         enc.byteBuf.Reset()
 234         enc.byteBuf.Write(spaceForLength)
 235         state := enc.newEncoderState(&enc.byteBuf)
 236
 237         enc.sendTypeDescriptor(enc.writer(), state, ut)
 238         enc.sendTypeId(state, ut)
 239         if enc.err != nil {
 240                 return enc.err
 241         }
 242
 243         // Encode the object.
 244         enc.encode(state.b, value, ut)
 245         if enc.err == nil {
 246                 enc.writeMessage(enc.writer(), state.b)
 247         }
 248
 249         enc.freeEncoderState(state)
 250         return enc.err
 251 }