// 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.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 usingfunc (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.func (enc *Encoder) Encode(e interface{}) 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.func (enc *Encoder) EncodeValue(value reflect.Value) error {	// Gobs contain values. They cannot represent nil pointers, which	// have no value to encode.	if value.Kind() == reflect.Ptr && 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}