123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258 |
- // Copyright 2009 The Go Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style
- // license that can be found in the LICENSE file.
- package gob
- import (
- "errors"
- "io"
- "reflect"
- "sync"
- )
- // An Encoder manages the transmission of type and data information to the
- // other side of a connection. It is safe for concurrent use by multiple
- // goroutines.
- type Encoder struct {
- mutex sync.Mutex // each item must be sent atomically
- w []io.Writer // where to send the data
- sent map[reflect.Type]typeId // which types we've already sent
- countState *encoderState // stage for writing counts
- freeList *encoderState // list of free encoderStates; avoids reallocation
- byteBuf encBuffer // buffer for top-level encoderState
- err error
- }
- // Before we encode a message, we reserve space at the head of the
- // buffer in which to encode its length. This means we can use the
- // buffer to assemble the message without another allocation.
- const maxLength = 9 // Maximum size of an encoded length.
- var spaceForLength = make([]byte, maxLength)
- // NewEncoder returns a new encoder that will transmit on the io.Writer.
- func NewEncoder(w io.Writer) *Encoder {
- enc := new(Encoder)
- enc.w = []io.Writer{w}
- enc.sent = make(map[reflect.Type]typeId)
- enc.countState = enc.newEncoderState(new(encBuffer))
- return enc
- }
- // writer() returns the innermost writer the encoder is using
- func (enc *Encoder) writer() io.Writer {
- return enc.w[len(enc.w)-1]
- }
- // pushWriter adds a writer to the encoder.
- func (enc *Encoder) pushWriter(w io.Writer) {
- enc.w = append(enc.w, w)
- }
- // popWriter pops the innermost writer.
- func (enc *Encoder) popWriter() {
- enc.w = enc.w[0 : len(enc.w)-1]
- }
- func (enc *Encoder) setError(err error) {
- if enc.err == nil { // remember the first.
- enc.err = err
- }
- }
- // writeMessage sends the data item preceded by a unsigned count of its length.
- func (enc *Encoder) writeMessage(w io.Writer, b *encBuffer) {
- // Space has been reserved for the length at the head of the message.
- // This is a little dirty: we grab the slice from the bytes.Buffer and massage
- // it by hand.
- message := b.Bytes()
- messageLen := len(message) - maxLength
- // Length cannot be bigger than the decoder can handle.
- if messageLen >= tooBig {
- enc.setError(errors.New("gob: encoder: message too big"))
- return
- }
- // Encode the length.
- enc.countState.b.Reset()
- enc.countState.encodeUint(uint64(messageLen))
- // Copy the length to be a prefix of the message.
- offset := maxLength - enc.countState.b.Len()
- copy(message[offset:], enc.countState.b.Bytes())
- // Write the data.
- _, err := w.Write(message[offset:])
- // Drain the buffer and restore the space at the front for the count of the next message.
- b.Reset()
- b.Write(spaceForLength)
- if err != nil {
- enc.setError(err)
- }
- }
- // sendActualType sends the requested type, without further investigation, unless
- // it's been sent before.
- func (enc *Encoder) sendActualType(w io.Writer, state *encoderState, ut *userTypeInfo, actual reflect.Type) (sent bool) {
- if _, alreadySent := enc.sent[actual]; alreadySent {
- return false
- }
- info, err := getTypeInfo(ut)
- if err != nil {
- enc.setError(err)
- return
- }
- // Send the pair (-id, type)
- // Id:
- state.encodeInt(-int64(info.id))
- // Type:
- enc.encode(state.b, reflect.ValueOf(info.wire), wireTypeUserInfo)
- enc.writeMessage(w, state.b)
- if enc.err != nil {
- return
- }
- // Remember we've sent this type, both what the user gave us and the base type.
- enc.sent[ut.base] = info.id
- if ut.user != ut.base {
- enc.sent[ut.user] = info.id
- }
- // Now send the inner types
- switch st := actual; st.Kind() {
- case reflect.Struct:
- for i := 0; i < st.NumField(); i++ {
- if isExported(st.Field(i).Name) {
- enc.sendType(w, state, st.Field(i).Type)
- }
- }
- case reflect.Array, reflect.Slice:
- enc.sendType(w, state, st.Elem())
- case reflect.Map:
- enc.sendType(w, state, st.Key())
- enc.sendType(w, state, st.Elem())
- }
- return true
- }
- // sendType sends the type info to the other side, if necessary.
- func (enc *Encoder) sendType(w io.Writer, state *encoderState, origt reflect.Type) (sent bool) {
- ut := userType(origt)
- if ut.externalEnc != 0 {
- // The rules are different: regardless of the underlying type's representation,
- // we need to tell the other side that the base type is a GobEncoder.
- return enc.sendActualType(w, state, ut, ut.base)
- }
- // It's a concrete value, so drill down to the base type.
- switch rt := ut.base; rt.Kind() {
- default:
- // Basic types and interfaces do not need to be described.
- return
- case reflect.Slice:
- // If it's []uint8, don't send; it's considered basic.
- if rt.Elem().Kind() == reflect.Uint8 {
- return
- }
- // Otherwise we do send.
- break
- case reflect.Array:
- // arrays must be sent so we know their lengths and element types.
- break
- case reflect.Map:
- // maps must be sent so we know their lengths and key/value types.
- break
- case reflect.Struct:
- // structs must be sent so we know their fields.
- break
- case reflect.Chan, reflect.Func:
- // If we get here, it's a field of a struct; ignore it.
- return
- }
- return enc.sendActualType(w, state, ut, ut.base)
- }
- // Encode transmits the data item represented by the empty interface value,
- // guaranteeing that all necessary type information has been transmitted first.
- // Passing a nil pointer to Encoder will panic, as they cannot be transmitted by gob.
- func (enc *Encoder) Encode(e any) error {
- return enc.EncodeValue(reflect.ValueOf(e))
- }
- // sendTypeDescriptor makes sure the remote side knows about this type.
- // It will send a descriptor if this is the first time the type has been
- // sent.
- func (enc *Encoder) sendTypeDescriptor(w io.Writer, state *encoderState, ut *userTypeInfo) {
- // Make sure the type is known to the other side.
- // First, have we already sent this type?
- rt := ut.base
- if ut.externalEnc != 0 {
- rt = ut.user
- }
- if _, alreadySent := enc.sent[rt]; !alreadySent {
- // No, so send it.
- sent := enc.sendType(w, state, rt)
- if enc.err != nil {
- return
- }
- // If the type info has still not been transmitted, it means we have
- // a singleton basic type (int, []byte etc.) at top level. We don't
- // need to send the type info but we do need to update enc.sent.
- if !sent {
- info, err := getTypeInfo(ut)
- if err != nil {
- enc.setError(err)
- return
- }
- enc.sent[rt] = info.id
- }
- }
- }
- // sendTypeId sends the id, which must have already been defined.
- func (enc *Encoder) sendTypeId(state *encoderState, ut *userTypeInfo) {
- // Identify the type of this top-level value.
- state.encodeInt(int64(enc.sent[ut.base]))
- }
- // EncodeValue transmits the data item represented by the reflection value,
- // guaranteeing that all necessary type information has been transmitted first.
- // Passing a nil pointer to EncodeValue will panic, as they cannot be transmitted by gob.
- func (enc *Encoder) EncodeValue(value reflect.Value) error {
- if value.Kind() == reflect.Invalid {
- return errors.New("gob: cannot encode nil value")
- }
- if value.Kind() == reflect.Pointer && value.IsNil() {
- panic("gob: cannot encode nil pointer of type " + value.Type().String())
- }
- // Make sure we're single-threaded through here, so multiple
- // goroutines can share an encoder.
- enc.mutex.Lock()
- defer enc.mutex.Unlock()
- // Remove any nested writers remaining due to previous errors.
- enc.w = enc.w[0:1]
- ut, err := validUserType(value.Type())
- if err != nil {
- return err
- }
- enc.err = nil
- enc.byteBuf.Reset()
- enc.byteBuf.Write(spaceForLength)
- state := enc.newEncoderState(&enc.byteBuf)
- enc.sendTypeDescriptor(enc.writer(), state, ut)
- enc.sendTypeId(state, ut)
- if enc.err != nil {
- return enc.err
- }
- // Encode the object.
- enc.encode(state.b, value, ut)
- if enc.err == nil {
- enc.writeMessage(enc.writer(), state.b)
- }
- enc.freeEncoderState(state)
- return enc.err
- }
|