src/pkg/gob/encoder.go - go - Git at Google

 // 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 (
 	"bytes"
 	"io"
 	"os"
 	"reflect"
 	"sync"
 )

 // An Encoder manages the transmission of type and data information to the
 // other side of a connection.
 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
 	buf        []byte                  // for collecting the output.
 	byteBuf    bytes.Buffer            // buffer for top-level encoderState
 	err        os.Error
 }

 // 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(bytes.Buffer))
 	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) badType(rt reflect.Type) {
 	enc.setError(os.NewError("gob: can't encode type " + rt.String()))
 }

 func (enc *Encoder) setError(err os.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 *bytes.Buffer) {
 	enc.countState.encodeUint(uint64(b.Len()))
 	// Build the buffer.
 	countLen := enc.countState.b.Len()
 	total := countLen + b.Len()
 	if total > len(enc.buf) {
 		enc.buf = make([]byte, total+1000) // extra for growth
 	}
 	// Place the length before the data.
 	// TODO(r): avoid the extra copy here.
 	enc.countState.b.Read(enc.buf[0:countLen])
 	// Now the data.
 	b.Read(enc.buf[countLen:total])
 	// Write the data.
 	_, err := w.Write(enc.buf[0:total])
 	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
 	}
 	typeLock.Lock()
 	info, err := getTypeInfo(ut)
 	typeLock.Unlock()
 	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++ {
 			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.isGobEncoder {
 		// The rules are different: regardless of the underlying type's representation,
 		// we need to tell the other side that this exact type is a GobEncoder.
 		return enc.sendActualType(w, state, ut, ut.user)
 	}

 	// 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:
 		// Probably a bad field in a struct.
 		enc.badType(rt)
 		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.
 func (enc *Encoder) Encode(e interface{}) os.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.isGobEncoder {
 		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 {
 			typeLock.Lock()
 			info, err := getTypeInfo(ut)
 			typeLock.Unlock()
 			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.
 func (enc *Encoder) EncodeValue(value reflect.Value) os.Error {
 	// 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()
 	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
 }
	// 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 (
	"bytes"
	"io"
	"os"
	"reflect"
	"sync"
	)

	// An Encoder manages the transmission of type and data information to the
	// other side of a connection.
	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
	buf []byte // for collecting the output.
	byteBuf bytes.Buffer // buffer for top-level encoderState
	err os.Error
	}

	// 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(bytes.Buffer))
	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) badType(rt reflect.Type) {
	enc.setError(os.NewError("gob: can't encode type " + rt.String()))
	}

	func (enc *Encoder) setError(err os.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 bytes.Buffer) {
	enc.countState.encodeUint(uint64(b.Len()))
	// Build the buffer.
	countLen := enc.countState.b.Len()
	total := countLen + b.Len()
	if total > len(enc.buf) {
	enc.buf = make([]byte, total+1000) // extra for growth
	}
	// Place the length before the data.
	// TODO(r): avoid the extra copy here.
	enc.countState.b.Read(enc.buf[0:countLen])
	// Now the data.
	b.Read(enc.buf[countLen:total])
	// Write the data.
	_, err := w.Write(enc.buf[0:total])
	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
	}
	typeLock.Lock()
	info, err := getTypeInfo(ut)
	typeLock.Unlock()
	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++ {
	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.isGobEncoder {
	// The rules are different: regardless of the underlying type's representation,
	// we need to tell the other side that this exact type is a GobEncoder.
	return enc.sendActualType(w, state, ut, ut.user)
	}

	// 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:
	// Probably a bad field in a struct.
	enc.badType(rt)
	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.
	func (enc *Encoder) Encode(e interface{}) os.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.isGobEncoder {
	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 {
	typeLock.Lock()
	info, err := getTypeInfo(ut)
	typeLock.Unlock()
	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.
	func (enc *Encoder) EncodeValue(value reflect.Value) os.Error {
	// 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()
	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
	}