vdl/reflect_writer.go - release.go.v23 - Git at Google

 // Copyright 2016 The Vanadium 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 vdl

 import (
 	"errors"
 	"fmt"
 	"reflect"
 )

 var (
 	errWriteMustReflect = errors.New("vdl: write must be handled via reflection")
 )

 // Write uses enc to encode value v, calling VDLWrite methods and fast compiled
 // writers when available, and using reflection otherwise.  This is basically an
 // all-purpose VDLWrite implementation.
 func Write(enc Encoder, v interface{}) error {
 	if v == nil {
 		return enc.NilValue(AnyType)
 	}
 	rv := reflect.ValueOf(v)
 	// Fastpath check for non-reflect support.  Unfortunately we must use
 	// reflection to detect the case where v is a pointer, which is handled by the
 	// more complicated optional-checking logic in writeReflect.
 	//
 	// TODO(toddw): *vom.RawBytes is 50% faster if we could special-case it here,
 	// without breaking support for optional types.
 	if rv.Kind() != reflect.Ptr {
 		if err := writeNonReflect(enc, v); err != errWriteMustReflect {
 			return err
 		}
 	}
 	tt, err := TypeFromReflect(rv.Type())
 	if err != nil {
 		return err
 	}
 	return writeReflect(enc, rv, tt)
 }

 func writeNonReflect(enc Encoder, v interface{}) error {
 	switch x := v.(type) {
 	case Writer:
 		// Writer handles code-generated VDLWrite methods, and special-cases such as
 		// vdl.Value and vom.RawBytes.
 		return x.VDLWrite(enc)

 		// Cases after this point are purely performance optimizations.
 		// TODO(toddw): Handle other common cases.
 	case []byte:
 		return enc.WriteValueBytes(ttByteList, x)
 	}
 	return errWriteMustReflect
 }

 // WriteReflect is like Write, but takes a reflect.Value argument.
 func WriteReflect(enc Encoder, rv reflect.Value) error {
 	if !rv.IsValid() {
 		return enc.NilValue(AnyType)
 	}
 	tt, err := TypeFromReflect(rv.Type())
 	if err != nil {
 		return err
 	}
 	return writeReflect(enc, rv, tt)
 }

 func writeReflect(enc Encoder, rv reflect.Value, tt *Type) error {
 	// Fastpath check for non-reflect support.  Optional types are tricky, since
 	// they may be nil, and need SetNextStartValueIsOptional() to be set, so they
 	// can't use this fastpath.  This handles the non-nil *vom.RawBytes and
 	// *vdl.Value cases, and avoids an expensive copy of all their fields.
 	if tt.Kind() != Optional && (rv.Kind() != reflect.Ptr || !rv.IsNil()) {
 		if err := writeNonReflect(enc, rv.Interface()); err != errWriteMustReflect {
 			return err
 		}
 	}
 	// Walk pointers and interfaces in rv, and handle nil values.
 	for {
 		isPtr, isIface := rv.Kind() == reflect.Ptr, rv.Kind() == reflect.Interface
 		if !isPtr && !isIface {
 			break
 		}
 		if rv.IsNil() {
 			switch {
 			case tt.Kind() == TypeObject:
 				// Treat nil *Type as AnyType.
 				return AnyType.VDLWrite(enc)
 			case tt.Kind() == Union && isIface:
 				// Treat nil Union interface as the zero value of the type at index 0.
 				return ZeroValue(tt).VDLWrite(enc)
 			case tt.Kind() == Optional:
 				enc.SetNextStartValueIsOptional()
 				return enc.NilValue(tt)
 			case tt == AnyType:
 				return enc.NilValue(tt)
 			}
 			return fmt.Errorf("vdl: can't encode nil from non-any non-optional %v", tt)
 		}
 		rv = rv.Elem()
 		// Recompute tt as we pass interface boundaries.  There's no need to
 		// recompute as we traverse pointers, since tt won't change.
 		if isIface {
 			var err error
 			if tt, err = TypeFromReflect(rv.Type()); err != nil {
 				return err
 			}
 		}
 	}
 	if tt.Kind() == Optional {
 		enc.SetNextStartValueIsOptional()
 	}
 	// Check for faster non-reflect support, which also handles vdl.Value and
 	// vom.RawBytes, and any other special-cases.
 	if err := writeNonReflect(enc, rv.Interface()); err != errWriteMustReflect {
 		return err
 	}
 	if reflect.PtrTo(rv.Type()).Implements(rtVDLWriter) {
 		if rv.CanAddr() {
 			return writeNonReflect(enc, rv.Addr().Interface())
 		} else {
 			// This handles the case where rv implements VDLWrite with a pointer
 			// receiver, but we can't address rv to get a pointer.  E.g.
 			//    type Foo string
 			//    func (x *Foo) VDLWrite(enc vdl.Encoder) error {...}
 			//    rv := Foo{}
 			//
 			// TODO(toddw): Do we need to handle this case?
 			rvPtr := reflect.New(rv.Type())
 			rvPtr.Elem().Set(rv)
 			return writeNonReflect(enc, rvPtr.Interface())
 		}
 	}
 	// Handle marshaling from native type to wire type.
 	if ni := nativeInfoFromNative(rv.Type()); ni != nil {
 		rvWirePtr := reflect.New(ni.WireType)
 		if err := ni.FromNative(rvWirePtr, rv); err != nil {
 			return err
 		}
 		return writeReflect(enc, rvWirePtr.Elem(), tt)
 	}
 	// Handle errors that are implemented by arbitrary rv values.  E.g. the Go
 	// standard errors.errorString implements the error interface, but is an
 	// invalid vdl type since it doesn't have any exported fields.
 	//
 	// See corresponding special-case in reflect_type.go
 	if tt == ErrorType {
 		if rv.Type().Implements(rtError) {
 			return writeNonNilError(enc, rv)
 		}
 		if rv.CanAddr() && rv.Addr().Type().Implements(rtError) {
 			return writeNonNilError(enc, rv.Addr())
 		}
 	}
 	tt = tt.NonOptional()
 	// Handle fastpath values.
 	if ttWriteHasFastpath(tt) {
 		return writeValueFastpath(enc, rv, tt)
 	}
 	// Handle composite wire values.
 	if err := enc.StartValue(tt); err != nil {
 		return err
 	}
 	var err error
 	switch tt.Kind() {
 	case Array, List:
 		err = writeArrayOrList(enc, rv, tt)
 	case Set, Map:
 		err = writeSetOrMap(enc, rv, tt)
 	case Struct:
 		err = writeStruct(enc, rv, tt)
 	case Union:
 		err = writeUnion(enc, rv, tt)
 	default:
 		// Special representations like vdl.Type, vdl.Value and vom.RawBytes
 		// implement VDLWrite, and were handled by writeNonReflect.  Nil optional
 		// and any were handled by the pointer-flattening loop.
 		return fmt.Errorf("vdl: Write unhandled type %v %v", rv.Type(), tt)
 	}
 	if err != nil {
 		return err
 	}
 	return enc.FinishValue()
 }

 // writeNonNilError writes rvNative, which must be a non-nil implementation of
 // the Go error interface, out to enc.
 func writeNonNilError(enc Encoder, rvNative reflect.Value) error {
 	ni := nativeInfoFromNative(rtError)
 	if ni == nil {
 		return errNoRegisterNativeError
 	}
 	rvWirePtr := reflect.New(ni.WireType)
 	if err := ni.FromNative(rvWirePtr, rvNative); err != nil {
 		return err
 	}
 	return writeReflect(enc, rvWirePtr.Elem(), ErrorType)
 }

 func extractBytes(rv reflect.Value, tt *Type) []byte {
 	// Go doesn't allow type conversions from []MyByte to []byte, but the reflect
 	// package does let us perform this conversion.
 	if tt.Kind() == List {
 		return rv.Bytes()
 	}
 	switch {
 	case rv.CanAddr():
 		return rv.Slice(0, tt.Len()).Bytes()
 	case tt.Elem() == ByteType:
 		// Unaddressable arrays can't be sliced, so we must copy the bytes.
 		// TODO(toddw): Find a better way to do this.
 		bytes := make([]byte, tt.Len())
 		reflect.Copy(reflect.ValueOf(bytes), rv)
 		return bytes
 	default:
 		// Unaddressable arrays can't be sliced, so we must copy the bytes.
 		// TODO(toddw): Find a better way to do this.
 		rt, len := rv.Type(), tt.Len()
 		rvSlice := reflect.MakeSlice(reflect.SliceOf(rt.Elem()), len, len)
 		reflect.Copy(rvSlice, rv)
 		return rvSlice.Bytes()
 	}
 }

 func ttWriteHasFastpath(tt *Type) bool {
 	switch tt.Kind() {
 	case Bool, String, Enum, Byte, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64, Float32, Float64:
 		return true
 	}
 	return tt.IsBytes()
 }

 func writeValueFastpath(enc Encoder, rv reflect.Value, tt *Type) error {
 	switch tt.Kind() {
 	case Bool:
 		return enc.WriteValueBool(tt, rv.Bool())
 	case String:
 		return enc.WriteValueString(tt, rv.String())
 	case Enum:
 		// TypeFromReflect already validated String(); call without error checking.
 		return enc.WriteValueString(tt, rv.Interface().(stringer).String())
 	case Byte, Uint16, Uint32, Uint64:
 		return enc.WriteValueUint(tt, rv.Uint())
 	case Int8, Int16, Int32, Int64:
 		return enc.WriteValueInt(tt, rv.Int())
 	case Float32, Float64:
 		return enc.WriteValueFloat(tt, rv.Float())
 	}
 	if !tt.IsBytes() {
 		return fmt.Errorf("vdl: writeValueFastpath called on non-fastpath type %v, %v", tt, rv.Type())
 	}
 	return enc.WriteValueBytes(tt, extractBytes(rv, tt))
 }

 func writeNextEntryFastpath(enc Encoder, rv reflect.Value, tt *Type) error {
 	switch tt.Kind() {
 	case Bool:
 		return enc.NextEntryValueBool(tt, rv.Bool())
 	case String:
 		return enc.NextEntryValueString(tt, rv.String())
 	case Enum:
 		// TypeFromReflect already validated String(); call without error checking.
 		return enc.NextEntryValueString(tt, rv.Interface().(stringer).String())
 	case Byte, Uint16, Uint32, Uint64:
 		return enc.NextEntryValueUint(tt, rv.Uint())
 	case Int8, Int16, Int32, Int64:
 		return enc.NextEntryValueInt(tt, rv.Int())
 	case Float32, Float64:
 		return enc.NextEntryValueFloat(tt, rv.Float())
 	}
 	if !tt.IsBytes() {
 		return fmt.Errorf("vdl: writeNextEntryFastpath called on non-fastpath type %v, %v", tt, rv.Type())
 	}
 	return enc.NextEntryValueBytes(tt, extractBytes(rv, tt))
 }

 func writeNextFieldFastpath(enc Encoder, rv reflect.Value, tt *Type, index int) error {
 	switch tt.Kind() {
 	case Bool:
 		return enc.NextFieldValueBool(index, tt, rv.Bool())
 	case String:
 		return enc.NextFieldValueString(index, tt, rv.String())
 	case Enum:
 		// TypeFromReflect already validated String(); call without error checking.
 		return enc.NextFieldValueString(index, tt, rv.Interface().(stringer).String())
 	case Byte, Uint16, Uint32, Uint64:
 		return enc.NextFieldValueUint(index, tt, rv.Uint())
 	case Int8, Int16, Int32, Int64:
 		return enc.NextFieldValueInt(index, tt, rv.Int())
 	case Float32, Float64:
 		return enc.NextFieldValueFloat(index, tt, rv.Float())
 	}
 	if !tt.IsBytes() {
 		return fmt.Errorf("vdl: writeNextFieldFastpath called on non-fastpath type %v, %v", tt, rv.Type())
 	}
 	return enc.NextFieldValueBytes(index, tt, extractBytes(rv, tt))
 }

 func writeArrayOrList(enc Encoder, rv reflect.Value, tt *Type) error {
 	if tt.Kind() == List {
 		if err := enc.SetLenHint(rv.Len()); err != nil {
 			return err
 		}
 	}
 	ttElem := tt.Elem()
 	for ix := 0; ix < rv.Len(); ix++ {
 		rvElem := rv.Index(ix)
 		if ttWriteHasFastpath(ttElem) {
 			if err := writeNextEntryFastpath(enc, rvElem, ttElem); err != nil {
 				return err
 			}
 		} else {
 			if err := enc.NextEntry(false); err != nil {
 				return err
 			}
 			if err := writeReflect(enc, rvElem, ttElem); err != nil {
 				return err
 			}
 		}
 	}
 	return enc.NextEntry(true)
 }

 func writeSetOrMap(enc Encoder, rv reflect.Value, tt *Type) error {
 	if err := enc.SetLenHint(rv.Len()); err != nil {
 		return err
 	}
 	kind, ttKey := tt.Kind(), tt.Key()
 	for _, rvKey := range rv.MapKeys() {
 		if ttWriteHasFastpath(ttKey) {
 			if err := writeNextEntryFastpath(enc, rvKey, ttKey); err != nil {
 				return err
 			}
 		} else {
 			if err := enc.NextEntry(false); err != nil {
 				return err
 			}
 			if err := writeReflect(enc, rvKey, ttKey); err != nil {
 				return err
 			}
 		}
 		if kind == Map {
 			if err := writeReflect(enc, rv.MapIndex(rvKey), tt.Elem()); err != nil {
 				return err
 			}
 		}
 	}
 	return enc.NextEntry(true)
 }

 func writeStruct(enc Encoder, rv reflect.Value, tt *Type) error {
 	rt := rv.Type()
 	// Loop through tt fields rather than rt fields, since the VDL type tt might
 	// have ignored some of the fields in rt, e.g. unexported fields.
 	for index := 0; index < tt.NumField(); index++ {
 		field := tt.Field(index)
 		rvField := rv.Field(rtFieldIndexByName(rt, field.Name))
 		switch isZero, err := rvIsZeroValue(rvField, field.Type); {
 		case err != nil:
 			return err
 		case isZero:
 			continue // skip zero-valued fields
 		}
 		if ttWriteHasFastpath(field.Type) {
 			if err := writeNextFieldFastpath(enc, rvField, field.Type, index); err != nil {
 				return err
 			}
 		} else {
 			if err := enc.NextField(index); err != nil {
 				return err
 			}
 			if err := writeReflect(enc, rvField, field.Type); err != nil {
 				return err
 			}
 		}
 	}
 	return enc.NextField(-1)
 }

 func writeUnion(enc Encoder, rv reflect.Value, tt *Type) error {
 	// TypeFromReflect already validated Index().
 	iface := rv.Interface()
 	index := iface.(indexer).Index()
 	ttField := tt.Field(index).Type
 	// Since this is a non-nil union, we're guaranteed rv is the concrete field
 	// struct, so we can just grab the "Value" field.
 	rvField := rv.Field(0)
 	if ttWriteHasFastpath(ttField) {
 		if err := writeNextFieldFastpath(enc, rvField, ttField, index); err != nil {
 			return err
 		}
 	} else {
 		if err := enc.NextField(index); err != nil {
 			return err
 		}
 		if err := writeReflect(enc, rvField, ttField); err != nil {
 			return err
 		}
 	}
 	return enc.NextField(-1)
 }
	// Copyright 2016 The Vanadium 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 vdl

	import (
	"errors"
	"fmt"
	"reflect"
	)

	var (
	errWriteMustReflect = errors.New("vdl: write must be handled via reflection")
	)

	// Write uses enc to encode value v, calling VDLWrite methods and fast compiled
	// writers when available, and using reflection otherwise. This is basically an
	// all-purpose VDLWrite implementation.
	func Write(enc Encoder, v interface{}) error {
	if v == nil {
	return enc.NilValue(AnyType)
	}
	rv := reflect.ValueOf(v)
	// Fastpath check for non-reflect support. Unfortunately we must use
	// reflection to detect the case where v is a pointer, which is handled by the
	// more complicated optional-checking logic in writeReflect.
	//
	// TODO(toddw): *vom.RawBytes is 50% faster if we could special-case it here,
	// without breaking support for optional types.
	if rv.Kind() != reflect.Ptr {
	if err := writeNonReflect(enc, v); err != errWriteMustReflect {
	return err
	}
	}
	tt, err := TypeFromReflect(rv.Type())
	if err != nil {
	return err
	}
	return writeReflect(enc, rv, tt)
	}

	func writeNonReflect(enc Encoder, v interface{}) error {
	switch x := v.(type) {
	case Writer:
	// Writer handles code-generated VDLWrite methods, and special-cases such as
	// vdl.Value and vom.RawBytes.
	return x.VDLWrite(enc)

	// Cases after this point are purely performance optimizations.
	// TODO(toddw): Handle other common cases.
	case []byte:
	return enc.WriteValueBytes(ttByteList, x)
	}
	return errWriteMustReflect
	}

	// WriteReflect is like Write, but takes a reflect.Value argument.
	func WriteReflect(enc Encoder, rv reflect.Value) error {
	if !rv.IsValid() {
	return enc.NilValue(AnyType)
	}
	tt, err := TypeFromReflect(rv.Type())
	if err != nil {
	return err
	}
	return writeReflect(enc, rv, tt)
	}

	func writeReflect(enc Encoder, rv reflect.Value, tt *Type) error {
	// Fastpath check for non-reflect support. Optional types are tricky, since
	// they may be nil, and need SetNextStartValueIsOptional() to be set, so they
	// can't use this fastpath. This handles the non-nil *vom.RawBytes and
	// *vdl.Value cases, and avoids an expensive copy of all their fields.
	if tt.Kind() != Optional && (rv.Kind() != reflect.Ptr \|\| !rv.IsNil()) {
	if err := writeNonReflect(enc, rv.Interface()); err != errWriteMustReflect {
	return err
	}
	}
	// Walk pointers and interfaces in rv, and handle nil values.
	for {
	isPtr, isIface := rv.Kind() == reflect.Ptr, rv.Kind() == reflect.Interface
	if !isPtr && !isIface {
	break
	}
	if rv.IsNil() {
	switch {
	case tt.Kind() == TypeObject:
	// Treat nil *Type as AnyType.
	return AnyType.VDLWrite(enc)
	case tt.Kind() == Union && isIface:
	// Treat nil Union interface as the zero value of the type at index 0.
	return ZeroValue(tt).VDLWrite(enc)
	case tt.Kind() == Optional:
	enc.SetNextStartValueIsOptional()
	return enc.NilValue(tt)
	case tt == AnyType:
	return enc.NilValue(tt)
	}
	return fmt.Errorf("vdl: can't encode nil from non-any non-optional %v", tt)
	}
	rv = rv.Elem()
	// Recompute tt as we pass interface boundaries. There's no need to
	// recompute as we traverse pointers, since tt won't change.
	if isIface {
	var err error
	if tt, err = TypeFromReflect(rv.Type()); err != nil {
	return err
	}
	}
	}
	if tt.Kind() == Optional {
	enc.SetNextStartValueIsOptional()
	}
	// Check for faster non-reflect support, which also handles vdl.Value and
	// vom.RawBytes, and any other special-cases.
	if err := writeNonReflect(enc, rv.Interface()); err != errWriteMustReflect {
	return err
	}
	if reflect.PtrTo(rv.Type()).Implements(rtVDLWriter) {
	if rv.CanAddr() {
	return writeNonReflect(enc, rv.Addr().Interface())
	} else {
	// This handles the case where rv implements VDLWrite with a pointer
	// receiver, but we can't address rv to get a pointer. E.g.
	// type Foo string
	// func (x *Foo) VDLWrite(enc vdl.Encoder) error {...}
	// rv := Foo{}
	//
	// TODO(toddw): Do we need to handle this case?
	rvPtr := reflect.New(rv.Type())
	rvPtr.Elem().Set(rv)
	return writeNonReflect(enc, rvPtr.Interface())
	}
	}
	// Handle marshaling from native type to wire type.
	if ni := nativeInfoFromNative(rv.Type()); ni != nil {
	rvWirePtr := reflect.New(ni.WireType)
	if err := ni.FromNative(rvWirePtr, rv); err != nil {
	return err
	}
	return writeReflect(enc, rvWirePtr.Elem(), tt)
	}
	// Handle errors that are implemented by arbitrary rv values. E.g. the Go
	// standard errors.errorString implements the error interface, but is an
	// invalid vdl type since it doesn't have any exported fields.
	//
	// See corresponding special-case in reflect_type.go
	if tt == ErrorType {
	if rv.Type().Implements(rtError) {
	return writeNonNilError(enc, rv)
	}
	if rv.CanAddr() && rv.Addr().Type().Implements(rtError) {
	return writeNonNilError(enc, rv.Addr())
	}
	}
	tt = tt.NonOptional()
	// Handle fastpath values.
	if ttWriteHasFastpath(tt) {
	return writeValueFastpath(enc, rv, tt)
	}
	// Handle composite wire values.
	if err := enc.StartValue(tt); err != nil {
	return err
	}
	var err error
	switch tt.Kind() {
	case Array, List:
	err = writeArrayOrList(enc, rv, tt)
	case Set, Map:
	err = writeSetOrMap(enc, rv, tt)
	case Struct:
	err = writeStruct(enc, rv, tt)
	case Union:
	err = writeUnion(enc, rv, tt)
	default:
	// Special representations like vdl.Type, vdl.Value and vom.RawBytes
	// implement VDLWrite, and were handled by writeNonReflect. Nil optional
	// and any were handled by the pointer-flattening loop.
	return fmt.Errorf("vdl: Write unhandled type %v %v", rv.Type(), tt)
	}
	if err != nil {
	return err
	}
	return enc.FinishValue()
	}

	// writeNonNilError writes rvNative, which must be a non-nil implementation of
	// the Go error interface, out to enc.
	func writeNonNilError(enc Encoder, rvNative reflect.Value) error {
	ni := nativeInfoFromNative(rtError)
	if ni == nil {
	return errNoRegisterNativeError
	}
	rvWirePtr := reflect.New(ni.WireType)
	if err := ni.FromNative(rvWirePtr, rvNative); err != nil {
	return err
	}
	return writeReflect(enc, rvWirePtr.Elem(), ErrorType)
	}

	func extractBytes(rv reflect.Value, tt *Type) []byte {
	// Go doesn't allow type conversions from []MyByte to []byte, but the reflect
	// package does let us perform this conversion.
	if tt.Kind() == List {
	return rv.Bytes()
	}
	switch {
	case rv.CanAddr():
	return rv.Slice(0, tt.Len()).Bytes()
	case tt.Elem() == ByteType:
	// Unaddressable arrays can't be sliced, so we must copy the bytes.
	// TODO(toddw): Find a better way to do this.
	bytes := make([]byte, tt.Len())
	reflect.Copy(reflect.ValueOf(bytes), rv)
	return bytes
	default:
	// Unaddressable arrays can't be sliced, so we must copy the bytes.
	// TODO(toddw): Find a better way to do this.
	rt, len := rv.Type(), tt.Len()
	rvSlice := reflect.MakeSlice(reflect.SliceOf(rt.Elem()), len, len)
	reflect.Copy(rvSlice, rv)
	return rvSlice.Bytes()
	}
	}

	func ttWriteHasFastpath(tt *Type) bool {
	switch tt.Kind() {
	case Bool, String, Enum, Byte, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64, Float32, Float64:
	return true
	}
	return tt.IsBytes()
	}

	func writeValueFastpath(enc Encoder, rv reflect.Value, tt *Type) error {
	switch tt.Kind() {
	case Bool:
	return enc.WriteValueBool(tt, rv.Bool())
	case String:
	return enc.WriteValueString(tt, rv.String())
	case Enum:
	// TypeFromReflect already validated String(); call without error checking.
	return enc.WriteValueString(tt, rv.Interface().(stringer).String())
	case Byte, Uint16, Uint32, Uint64:
	return enc.WriteValueUint(tt, rv.Uint())
	case Int8, Int16, Int32, Int64:
	return enc.WriteValueInt(tt, rv.Int())
	case Float32, Float64:
	return enc.WriteValueFloat(tt, rv.Float())
	}
	if !tt.IsBytes() {
	return fmt.Errorf("vdl: writeValueFastpath called on non-fastpath type %v, %v", tt, rv.Type())
	}
	return enc.WriteValueBytes(tt, extractBytes(rv, tt))
	}

	func writeNextEntryFastpath(enc Encoder, rv reflect.Value, tt *Type) error {
	switch tt.Kind() {
	case Bool:
	return enc.NextEntryValueBool(tt, rv.Bool())
	case String:
	return enc.NextEntryValueString(tt, rv.String())
	case Enum:
	// TypeFromReflect already validated String(); call without error checking.
	return enc.NextEntryValueString(tt, rv.Interface().(stringer).String())
	case Byte, Uint16, Uint32, Uint64:
	return enc.NextEntryValueUint(tt, rv.Uint())
	case Int8, Int16, Int32, Int64:
	return enc.NextEntryValueInt(tt, rv.Int())
	case Float32, Float64:
	return enc.NextEntryValueFloat(tt, rv.Float())
	}
	if !tt.IsBytes() {
	return fmt.Errorf("vdl: writeNextEntryFastpath called on non-fastpath type %v, %v", tt, rv.Type())
	}
	return enc.NextEntryValueBytes(tt, extractBytes(rv, tt))
	}

	func writeNextFieldFastpath(enc Encoder, rv reflect.Value, tt *Type, index int) error {
	switch tt.Kind() {
	case Bool:
	return enc.NextFieldValueBool(index, tt, rv.Bool())
	case String:
	return enc.NextFieldValueString(index, tt, rv.String())
	case Enum:
	// TypeFromReflect already validated String(); call without error checking.
	return enc.NextFieldValueString(index, tt, rv.Interface().(stringer).String())
	case Byte, Uint16, Uint32, Uint64:
	return enc.NextFieldValueUint(index, tt, rv.Uint())
	case Int8, Int16, Int32, Int64:
	return enc.NextFieldValueInt(index, tt, rv.Int())
	case Float32, Float64:
	return enc.NextFieldValueFloat(index, tt, rv.Float())
	}
	if !tt.IsBytes() {
	return fmt.Errorf("vdl: writeNextFieldFastpath called on non-fastpath type %v, %v", tt, rv.Type())
	}
	return enc.NextFieldValueBytes(index, tt, extractBytes(rv, tt))
	}

	func writeArrayOrList(enc Encoder, rv reflect.Value, tt *Type) error {
	if tt.Kind() == List {
	if err := enc.SetLenHint(rv.Len()); err != nil {
	return err
	}
	}
	ttElem := tt.Elem()
	for ix := 0; ix < rv.Len(); ix++ {
	rvElem := rv.Index(ix)
	if ttWriteHasFastpath(ttElem) {
	if err := writeNextEntryFastpath(enc, rvElem, ttElem); err != nil {
	return err
	}
	} else {
	if err := enc.NextEntry(false); err != nil {
	return err
	}
	if err := writeReflect(enc, rvElem, ttElem); err != nil {
	return err
	}
	}
	}
	return enc.NextEntry(true)
	}

	func writeSetOrMap(enc Encoder, rv reflect.Value, tt *Type) error {
	if err := enc.SetLenHint(rv.Len()); err != nil {
	return err
	}
	kind, ttKey := tt.Kind(), tt.Key()
	for _, rvKey := range rv.MapKeys() {
	if ttWriteHasFastpath(ttKey) {
	if err := writeNextEntryFastpath(enc, rvKey, ttKey); err != nil {
	return err
	}
	} else {
	if err := enc.NextEntry(false); err != nil {
	return err
	}
	if err := writeReflect(enc, rvKey, ttKey); err != nil {
	return err
	}
	}
	if kind == Map {
	if err := writeReflect(enc, rv.MapIndex(rvKey), tt.Elem()); err != nil {
	return err
	}
	}
	}
	return enc.NextEntry(true)
	}

	func writeStruct(enc Encoder, rv reflect.Value, tt *Type) error {
	rt := rv.Type()
	// Loop through tt fields rather than rt fields, since the VDL type tt might
	// have ignored some of the fields in rt, e.g. unexported fields.
	for index := 0; index < tt.NumField(); index++ {
	field := tt.Field(index)
	rvField := rv.Field(rtFieldIndexByName(rt, field.Name))
	switch isZero, err := rvIsZeroValue(rvField, field.Type); {
	case err != nil:
	return err
	case isZero:
	continue // skip zero-valued fields
	}
	if ttWriteHasFastpath(field.Type) {
	if err := writeNextFieldFastpath(enc, rvField, field.Type, index); err != nil {
	return err
	}
	} else {
	if err := enc.NextField(index); err != nil {
	return err
	}
	if err := writeReflect(enc, rvField, field.Type); err != nil {
	return err
	}
	}
	}
	return enc.NextField(-1)
	}

	func writeUnion(enc Encoder, rv reflect.Value, tt *Type) error {
	// TypeFromReflect already validated Index().
	iface := rv.Interface()
	index := iface.(indexer).Index()
	ttField := tt.Field(index).Type
	// Since this is a non-nil union, we're guaranteed rv is the concrete field
	// struct, so we can just grab the "Value" field.
	rvField := rv.Field(0)
	if ttWriteHasFastpath(ttField) {
	if err := writeNextFieldFastpath(enc, rvField, ttField, index); err != nil {
	return err
	}
	} else {
	if err := enc.NextField(index); err != nil {
	return err
	}
	if err := writeReflect(enc, rvField, ttField); err != nil {
	return err
	}
	}
	return enc.NextField(-1)
	}