vom/decoder_fast_read.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 vom

 import (
 	"strconv"

 	"v.io/v23/vdl"
 )

 // This file contains the ReadValue* methods.  The semantics of these methods is
 // the same as if StartValue, Decode*, FinishValue were called in sequence.  The
 // implementation is faster than actually calling that sequence, because we can
 // avoid pushing and popping the decoder stack and also avoid unnecessary
 // compatibility checks.  We also get a minor improvement by avoiding extra
 // method calls indirected through the Decoder interface.
 //
 // Each method has the same pattern:
 //
 // Check fastpath:
 //   If we've already determined from the parent type that we can use the
 //   fastpath, we simply decode the value, skipping both the StartValue logic as
 //   well as the conversion logic.
 // StartValue:
 //   If IgnoreNextStartValue is set, the type is already on the stack.
 //   Otherwise setup the type to process Any and Optional headers.  We pass nil
 //   to d.setupType to avoid the compatibility check, since the decode step will
 //   naturally let us perform that check.
 // Decode:
 //   We implement common-case fastpaths; e.g. avoiding unnecessary conversions.
 // FinishValue:
 //   Mirrors StartValue, only pop the stack if necessary.

 // isFastReadParent returns true iff subtypes of tt can use the fastpath for the
 // ReadValue* methods.  By using the fastpath we can skip the expensive
 // dfsNextType and setupType calls.  We can't use the fastpath for:
 //   Any:  since we always need to process the any header
 //   Enum: since ReadValueString won't know whether to decode a string or enum
 //   Byte: since ReadValueUint won't know whether to decode a uint or full byte
 //
 // REQUIRES: tt is identical to the want type that the user is decoding into,
 // which ensures that we don't need to perform conversions.
 func isFastReadParent(tt *vdl.Type) bool {
 	switch tt.Kind() {
 	case vdl.Array, vdl.List:
 		elem := tt.Elem().Kind()
 		return elem != vdl.Any && elem != vdl.Enum && elem != vdl.Byte
 	case vdl.Set:
 		key := tt.Key().Kind()
 		return key != vdl.Any && key != vdl.Enum && key != vdl.Byte
 	case vdl.Map:
 		key := tt.Key().Kind()
 		elem := tt.Elem().Kind()
 		return key != vdl.Any && key != vdl.Enum && key != vdl.Byte &&
 			elem != vdl.Any && elem != vdl.Enum && elem != vdl.Byte
 	case vdl.Struct, vdl.Union:
 		if !tt.ContainsKind(vdl.WalkAll, kkAnyEnumByte...) {
 			return true
 		}
 		for f := 0; f < tt.NumField(); f++ {
 			if k := tt.Field(f).Type.Kind(); k == vdl.Any || k == vdl.Enum || k == vdl.Byte {
 				return false
 			}
 		}
 		return true
 	default:
 		return false
 	}
 }

 var kkAnyEnumByte = []vdl.Kind{vdl.Any, vdl.Enum, vdl.Byte}

 func (d *decoder81) ReadValueBool() (value bool, err error) {
 	top, isOnStack := d.top(), d.flag.IgnoreNextStartValue()
 	// Check fastpath
 	if top != nil && top.Flag.FastRead() {
 		value, err = binaryDecodeBool(d.buf)
 	} else {
 		// StartValue
 		var tt *vdl.Type
 		if isOnStack {
 			tt = top.Type
 		} else {
 			if tt, err = d.dfsNextType(); err != nil {
 				return false, err
 			}
 			if tt, _, _, err = d.setupType(tt, nil); err != nil {
 				return false, err
 			}
 		}
 		// Decode
 		switch tt.Kind() {
 		case vdl.Bool:
 			value, err = binaryDecodeBool(d.buf)
 		default:
 			return false, errIncompatibleDecode(tt, "bool")
 		}
 	}
 	// FinishValue
 	if isOnStack {
 		if err := d.FinishValue(); err != nil {
 			return false, err
 		}
 	} else {
 		d.flag = d.flag.Clear(decFlagFinishValue)
 		if top == nil {
 			if err := d.endMessage(); err != nil {
 				return false, err
 			}
 		}
 	}
 	return value, err
 }

 func (d *decoder81) ReadValueString() (value string, err error) {
 	top, isOnStack := d.top(), d.flag.IgnoreNextStartValue()
 	// Check fastpath
 	if top != nil && top.Flag.FastRead() {
 		value, err = binaryDecodeString(d.buf)
 	} else {
 		// StartValue
 		var tt *vdl.Type
 		if isOnStack {
 			tt = top.Type
 		} else {
 			if tt, err = d.dfsNextType(); err != nil {
 				return "", err
 			}
 			if tt, _, _, err = d.setupType(tt, nil); err != nil {
 				return "", err
 			}
 		}
 		// Decode
 		switch tt.Kind() {
 		case vdl.String:
 			value, err = binaryDecodeString(d.buf)
 		case vdl.Enum:
 			value, err = d.binaryDecodeEnum(tt)
 		default:
 			return "", errIncompatibleDecode(tt, "string")
 		}
 	}
 	// FinishValue
 	if isOnStack {
 		if err := d.FinishValue(); err != nil {
 			return "", err
 		}
 	} else {
 		d.flag = d.flag.Clear(decFlagFinishValue)
 		if top == nil {
 			if err := d.endMessage(); err != nil {
 				return "", err
 			}
 		}
 	}
 	return value, err
 }

 func (d *decoder81) ReadValueUint(bitlen int) (value uint64, err error) {
 	top, isOnStack := d.top(), d.flag.IgnoreNextStartValue()
 	// Check fastpath
 	if top != nil && top.Flag.FastRead() {
 		value, err = binaryDecodeUint(d.buf)
 	} else {
 		// StartValue
 		var tt *vdl.Type
 		if isOnStack {
 			tt = top.Type
 		} else {
 			if tt, err = d.dfsNextType(); err != nil {
 				return 0, err
 			}
 			if tt, _, _, err = d.setupType(tt, nil); err != nil {
 				return 0, err
 			}
 		}
 		// Decode, avoiding unnecessary number conversions.
 		switch kind := tt.Kind(); kind {
 		case vdl.Uint16, vdl.Uint32, vdl.Uint64:
 			if kind.BitLen() <= bitlen {
 				value, err = binaryDecodeUint(d.buf)
 			} else {
 				value, err = d.decodeUint(tt, uint(bitlen))
 			}
 		case vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64, vdl.Float32, vdl.Float64:
 			value, err = d.decodeUint(tt, uint(bitlen))
 		case vdl.Byte:
 			var b byte
 			b, err = d.binaryDecodeByte()
 			value = uint64(b)
 		default:
 			return 0, errIncompatibleDecode(tt, "uint"+strconv.Itoa(bitlen))
 		}
 	}
 	// FinishValue
 	if isOnStack {
 		if err := d.FinishValue(); err != nil {
 			return 0, err
 		}
 	} else {
 		d.flag = d.flag.Clear(decFlagFinishValue)
 		if top == nil {
 			if err := d.endMessage(); err != nil {
 				return 0, err
 			}
 		}
 	}
 	return value, err
 }

 func (d *decoder81) ReadValueInt(bitlen int) (value int64, err error) {
 	top, isOnStack := d.top(), d.flag.IgnoreNextStartValue()
 	// Check fastpath
 	if top != nil && top.Flag.FastRead() {
 		value, err = binaryDecodeInt(d.buf)
 	} else {
 		// StartValue
 		var tt *vdl.Type
 		if isOnStack {
 			tt = top.Type
 		} else {
 			if tt, err = d.dfsNextType(); err != nil {
 				return 0, err
 			}
 			if tt, _, _, err = d.setupType(tt, nil); err != nil {
 				return 0, err
 			}
 		}
 		// Decode, avoiding unnecessary number conversions.
 		switch kind := tt.Kind(); kind {
 		case vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64:
 			if kind.BitLen() <= bitlen {
 				value, err = binaryDecodeInt(d.buf)
 			} else {
 				value, err = d.decodeInt(tt, uint(bitlen))
 			}
 		case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64, vdl.Float32, vdl.Float64:
 			value, err = d.decodeInt(tt, uint(bitlen))
 		default:
 			return 0, errIncompatibleDecode(tt, "int"+strconv.Itoa(bitlen))
 		}
 	}
 	// FinishValue
 	if isOnStack {
 		if err := d.FinishValue(); err != nil {
 			return 0, err
 		}
 	} else {
 		d.flag = d.flag.Clear(decFlagFinishValue)
 		if top == nil {
 			if err := d.endMessage(); err != nil {
 				return 0, err
 			}
 		}
 	}
 	return value, err
 }

 func (d *decoder81) ReadValueFloat(bitlen int) (value float64, err error) {
 	top, isOnStack := d.top(), d.flag.IgnoreNextStartValue()
 	// Check fastpath
 	if top != nil && top.Flag.FastRead() {
 		value, err = binaryDecodeFloat(d.buf)
 	} else {
 		// StartValue
 		var tt *vdl.Type
 		if isOnStack {
 			tt = top.Type
 		} else {
 			if tt, err = d.dfsNextType(); err != nil {
 				return 0, err
 			}
 			if tt, _, _, err = d.setupType(tt, nil); err != nil {
 				return 0, err
 			}
 		}
 		// Decode, avoiding unnecessary number conversions.
 		switch kind := tt.Kind(); kind {
 		case vdl.Float32, vdl.Float64:
 			if kind.BitLen() <= bitlen {
 				value, err = binaryDecodeFloat(d.buf)
 			} else {
 				value, err = d.decodeFloat(tt, uint(bitlen))
 			}
 		case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64, vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64:
 			value, err = d.decodeFloat(tt, uint(bitlen))
 		default:
 			return 0, errIncompatibleDecode(tt, "float"+strconv.Itoa(bitlen))
 		}
 	}
 	// FinishValue
 	if isOnStack {
 		if err := d.FinishValue(); err != nil {
 			return 0, err
 		}
 	} else {
 		d.flag = d.flag.Clear(decFlagFinishValue)
 		if top == nil {
 			if err := d.endMessage(); err != nil {
 				return 0, err
 			}
 		}
 	}
 	return value, err
 }

 func (d *decoder81) ReadValueTypeObject() (value *vdl.Type, err error) {
 	top, isOnStack := d.top(), d.flag.IgnoreNextStartValue()
 	// Check fastpath
 	if top != nil && top.Flag.FastRead() {
 		value, err = d.binaryDecodeType()
 	} else {
 		// StartValue
 		var tt *vdl.Type
 		if isOnStack {
 			tt = top.Type
 		} else {
 			if tt, err = d.dfsNextType(); err != nil {
 				return nil, err
 			}
 			if tt, _, _, err = d.setupType(tt, nil); err != nil {
 				return nil, err
 			}
 		}
 		// Decode
 		switch tt.Kind() {
 		case vdl.TypeObject:
 			value, err = d.binaryDecodeType()
 		default:
 			return nil, errIncompatibleDecode(tt, "typeobject")
 		}
 	}
 	// FinishValue
 	if isOnStack {
 		if err := d.FinishValue(); err != nil {
 			return nil, err
 		}
 	} else {
 		d.flag = d.flag.Clear(decFlagFinishValue)
 		if top == nil {
 			if err := d.endMessage(); err != nil {
 				return nil, err
 			}
 		}
 	}
 	return value, err
 }

 // ReadValueBytes is more complicated than the other ReadValue* methods, since
 // []byte lists and [n]byte arrays aren't scalar, and may need more complicated
 // conversions
 //
 // TODO(toddw): Implement fastpath for this?
 func (d *decoder81) ReadValueBytes(fixedLen int, x *[]byte) (err error) {
 	// StartValue.  Initialize tt and lenHint, and track whether the []byte type
 	// is already on the stack via isOnStack.
 	isOnStack := d.flag.IgnoreNextStartValue()
 	d.flag = d.flag.Clear(decFlagIgnoreNextStartValue)
 	var tt *vdl.Type
 	var lenHint int
 	if isOnStack {
 		top := d.top()
 		tt, lenHint = top.Type, top.LenHint
 	} else {
 		if tt, err = d.dfsNextType(); err != nil {
 			return err
 		}
 		var flag decStackFlag
 		if tt, lenHint, flag, err = d.setupType(tt, nil); err != nil {
 			return err
 		}
 		// If tt isn't []byte or [n]byte (or a named variant of these), we need to
 		// perform conversion byte-by-byte.  This is complicated, and can't be
 		// really fast, so we just push an entry onto the stack and handle this via
 		// DecodeConvertedBytes below.
 		//
 		// We also need to perform the compatibility check, to make sure tt is
 		// compatible with []byte.  The check is fairly expensive, so skipping it
 		// when tt is actually a bytes type makes the the common case faster.
 		if !tt.IsBytes() {
 			if !vdl.Compatible(tt, ttByteList) {
 				return errIncompatibleDecode(tt, "bytes")
 			}
 			d.stack = append(d.stack, decStackEntry{
 				Type:    tt,
 				Index:   -1,
 				LenHint: lenHint,
 				Flag:    flag,
 			})
 			isOnStack = true
 		}
 	}
 	// Decode.  The common-case fastpath reads directly from the buffer.
 	if tt.IsBytes() {
 		if err := d.decodeBytes(tt, lenHint, fixedLen, x); err != nil {
 			return err
 		}
 	} else {
 		if err := vdl.DecodeConvertedBytes(d, fixedLen, x); err != nil {
 			return err
 		}
 	}
 	// FinishValue
 	if isOnStack {
 		if err := d.FinishValue(); err != nil {
 			return err
 		}
 	} else {
 		d.flag = d.flag.Clear(decFlagIsParentBytes)
 		if len(d.stack) == 0 {
 			if err := d.endMessage(); err != nil {
 				return err
 			}
 		}
 	}
 	return nil
 }

 var ttByteList = vdl.ListType(vdl.ByteType)
	// 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 vom

	import (
	"strconv"

	"v.io/v23/vdl"
	)

	// This file contains the ReadValue* methods. The semantics of these methods is
	// the same as if StartValue, Decode*, FinishValue were called in sequence. The
	// implementation is faster than actually calling that sequence, because we can
	// avoid pushing and popping the decoder stack and also avoid unnecessary
	// compatibility checks. We also get a minor improvement by avoiding extra
	// method calls indirected through the Decoder interface.
	//
	// Each method has the same pattern:
	//
	// Check fastpath:
	// If we've already determined from the parent type that we can use the
	// fastpath, we simply decode the value, skipping both the StartValue logic as
	// well as the conversion logic.
	// StartValue:
	// If IgnoreNextStartValue is set, the type is already on the stack.
	// Otherwise setup the type to process Any and Optional headers. We pass nil
	// to d.setupType to avoid the compatibility check, since the decode step will
	// naturally let us perform that check.
	// Decode:
	// We implement common-case fastpaths; e.g. avoiding unnecessary conversions.
	// FinishValue:
	// Mirrors StartValue, only pop the stack if necessary.

	// isFastReadParent returns true iff subtypes of tt can use the fastpath for the
	// ReadValue* methods. By using the fastpath we can skip the expensive
	// dfsNextType and setupType calls. We can't use the fastpath for:
	// Any: since we always need to process the any header
	// Enum: since ReadValueString won't know whether to decode a string or enum
	// Byte: since ReadValueUint won't know whether to decode a uint or full byte
	//
	// REQUIRES: tt is identical to the want type that the user is decoding into,
	// which ensures that we don't need to perform conversions.
	func isFastReadParent(tt *vdl.Type) bool {
	switch tt.Kind() {
	case vdl.Array, vdl.List:
	elem := tt.Elem().Kind()
	return elem != vdl.Any && elem != vdl.Enum && elem != vdl.Byte
	case vdl.Set:
	key := tt.Key().Kind()
	return key != vdl.Any && key != vdl.Enum && key != vdl.Byte
	case vdl.Map:
	key := tt.Key().Kind()
	elem := tt.Elem().Kind()
	return key != vdl.Any && key != vdl.Enum && key != vdl.Byte &&
	elem != vdl.Any && elem != vdl.Enum && elem != vdl.Byte
	case vdl.Struct, vdl.Union:
	if !tt.ContainsKind(vdl.WalkAll, kkAnyEnumByte...) {
	return true
	}
	for f := 0; f < tt.NumField(); f++ {
	if k := tt.Field(f).Type.Kind(); k == vdl.Any \|\| k == vdl.Enum \|\| k == vdl.Byte {
	return false
	}
	}
	return true
	default:
	return false
	}
	}

	var kkAnyEnumByte = []vdl.Kind{vdl.Any, vdl.Enum, vdl.Byte}

	func (d *decoder81) ReadValueBool() (value bool, err error) {
	top, isOnStack := d.top(), d.flag.IgnoreNextStartValue()
	// Check fastpath
	if top != nil && top.Flag.FastRead() {
	value, err = binaryDecodeBool(d.buf)
	} else {
	// StartValue
	var tt *vdl.Type
	if isOnStack {
	tt = top.Type
	} else {
	if tt, err = d.dfsNextType(); err != nil {
	return false, err
	}
	if tt, _, _, err = d.setupType(tt, nil); err != nil {
	return false, err
	}
	}
	// Decode
	switch tt.Kind() {
	case vdl.Bool:
	value, err = binaryDecodeBool(d.buf)
	default:
	return false, errIncompatibleDecode(tt, "bool")
	}
	}
	// FinishValue
	if isOnStack {
	if err := d.FinishValue(); err != nil {
	return false, err
	}
	} else {
	d.flag = d.flag.Clear(decFlagFinishValue)
	if top == nil {
	if err := d.endMessage(); err != nil {
	return false, err
	}
	}
	}
	return value, err
	}

	func (d *decoder81) ReadValueString() (value string, err error) {
	top, isOnStack := d.top(), d.flag.IgnoreNextStartValue()
	// Check fastpath
	if top != nil && top.Flag.FastRead() {
	value, err = binaryDecodeString(d.buf)
	} else {
	// StartValue
	var tt *vdl.Type
	if isOnStack {
	tt = top.Type
	} else {
	if tt, err = d.dfsNextType(); err != nil {
	return "", err
	}
	if tt, _, _, err = d.setupType(tt, nil); err != nil {
	return "", err
	}
	}
	// Decode
	switch tt.Kind() {
	case vdl.String:
	value, err = binaryDecodeString(d.buf)
	case vdl.Enum:
	value, err = d.binaryDecodeEnum(tt)
	default:
	return "", errIncompatibleDecode(tt, "string")
	}
	}
	// FinishValue
	if isOnStack {
	if err := d.FinishValue(); err != nil {
	return "", err
	}
	} else {
	d.flag = d.flag.Clear(decFlagFinishValue)
	if top == nil {
	if err := d.endMessage(); err != nil {
	return "", err
	}
	}
	}
	return value, err
	}

	func (d *decoder81) ReadValueUint(bitlen int) (value uint64, err error) {
	top, isOnStack := d.top(), d.flag.IgnoreNextStartValue()
	// Check fastpath
	if top != nil && top.Flag.FastRead() {
	value, err = binaryDecodeUint(d.buf)
	} else {
	// StartValue
	var tt *vdl.Type
	if isOnStack {
	tt = top.Type
	} else {
	if tt, err = d.dfsNextType(); err != nil {
	return 0, err
	}
	if tt, _, _, err = d.setupType(tt, nil); err != nil {
	return 0, err
	}
	}
	// Decode, avoiding unnecessary number conversions.
	switch kind := tt.Kind(); kind {
	case vdl.Uint16, vdl.Uint32, vdl.Uint64:
	if kind.BitLen() <= bitlen {
	value, err = binaryDecodeUint(d.buf)
	} else {
	value, err = d.decodeUint(tt, uint(bitlen))
	}
	case vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64, vdl.Float32, vdl.Float64:
	value, err = d.decodeUint(tt, uint(bitlen))
	case vdl.Byte:
	var b byte
	b, err = d.binaryDecodeByte()
	value = uint64(b)
	default:
	return 0, errIncompatibleDecode(tt, "uint"+strconv.Itoa(bitlen))
	}
	}
	// FinishValue
	if isOnStack {
	if err := d.FinishValue(); err != nil {
	return 0, err
	}
	} else {
	d.flag = d.flag.Clear(decFlagFinishValue)
	if top == nil {
	if err := d.endMessage(); err != nil {
	return 0, err
	}
	}
	}
	return value, err
	}

	func (d *decoder81) ReadValueInt(bitlen int) (value int64, err error) {
	top, isOnStack := d.top(), d.flag.IgnoreNextStartValue()
	// Check fastpath
	if top != nil && top.Flag.FastRead() {
	value, err = binaryDecodeInt(d.buf)
	} else {
	// StartValue
	var tt *vdl.Type
	if isOnStack {
	tt = top.Type
	} else {
	if tt, err = d.dfsNextType(); err != nil {
	return 0, err
	}
	if tt, _, _, err = d.setupType(tt, nil); err != nil {
	return 0, err
	}
	}
	// Decode, avoiding unnecessary number conversions.
	switch kind := tt.Kind(); kind {
	case vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64:
	if kind.BitLen() <= bitlen {
	value, err = binaryDecodeInt(d.buf)
	} else {
	value, err = d.decodeInt(tt, uint(bitlen))
	}
	case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64, vdl.Float32, vdl.Float64:
	value, err = d.decodeInt(tt, uint(bitlen))
	default:
	return 0, errIncompatibleDecode(tt, "int"+strconv.Itoa(bitlen))
	}
	}
	// FinishValue
	if isOnStack {
	if err := d.FinishValue(); err != nil {
	return 0, err
	}
	} else {
	d.flag = d.flag.Clear(decFlagFinishValue)
	if top == nil {
	if err := d.endMessage(); err != nil {
	return 0, err
	}
	}
	}
	return value, err
	}

	func (d *decoder81) ReadValueFloat(bitlen int) (value float64, err error) {
	top, isOnStack := d.top(), d.flag.IgnoreNextStartValue()
	// Check fastpath
	if top != nil && top.Flag.FastRead() {
	value, err = binaryDecodeFloat(d.buf)
	} else {
	// StartValue
	var tt *vdl.Type
	if isOnStack {
	tt = top.Type
	} else {
	if tt, err = d.dfsNextType(); err != nil {
	return 0, err
	}
	if tt, _, _, err = d.setupType(tt, nil); err != nil {
	return 0, err
	}
	}
	// Decode, avoiding unnecessary number conversions.
	switch kind := tt.Kind(); kind {
	case vdl.Float32, vdl.Float64:
	if kind.BitLen() <= bitlen {
	value, err = binaryDecodeFloat(d.buf)
	} else {
	value, err = d.decodeFloat(tt, uint(bitlen))
	}
	case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64, vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64:
	value, err = d.decodeFloat(tt, uint(bitlen))
	default:
	return 0, errIncompatibleDecode(tt, "float"+strconv.Itoa(bitlen))
	}
	}
	// FinishValue
	if isOnStack {
	if err := d.FinishValue(); err != nil {
	return 0, err
	}
	} else {
	d.flag = d.flag.Clear(decFlagFinishValue)
	if top == nil {
	if err := d.endMessage(); err != nil {
	return 0, err
	}
	}
	}
	return value, err
	}

	func (d decoder81) ReadValueTypeObject() (value vdl.Type, err error) {
	top, isOnStack := d.top(), d.flag.IgnoreNextStartValue()
	// Check fastpath
	if top != nil && top.Flag.FastRead() {
	value, err = d.binaryDecodeType()
	} else {
	// StartValue
	var tt *vdl.Type
	if isOnStack {
	tt = top.Type
	} else {
	if tt, err = d.dfsNextType(); err != nil {
	return nil, err
	}
	if tt, _, _, err = d.setupType(tt, nil); err != nil {
	return nil, err
	}
	}
	// Decode
	switch tt.Kind() {
	case vdl.TypeObject:
	value, err = d.binaryDecodeType()
	default:
	return nil, errIncompatibleDecode(tt, "typeobject")
	}
	}
	// FinishValue
	if isOnStack {
	if err := d.FinishValue(); err != nil {
	return nil, err
	}
	} else {
	d.flag = d.flag.Clear(decFlagFinishValue)
	if top == nil {
	if err := d.endMessage(); err != nil {
	return nil, err
	}
	}
	}
	return value, err
	}

	// ReadValueBytes is more complicated than the other ReadValue* methods, since
	// []byte lists and [n]byte arrays aren't scalar, and may need more complicated
	// conversions
	//
	// TODO(toddw): Implement fastpath for this?
	func (d decoder81) ReadValueBytes(fixedLen int, x []byte) (err error) {
	// StartValue. Initialize tt and lenHint, and track whether the []byte type
	// is already on the stack via isOnStack.
	isOnStack := d.flag.IgnoreNextStartValue()
	d.flag = d.flag.Clear(decFlagIgnoreNextStartValue)
	var tt *vdl.Type
	var lenHint int
	if isOnStack {
	top := d.top()
	tt, lenHint = top.Type, top.LenHint
	} else {
	if tt, err = d.dfsNextType(); err != nil {
	return err
	}
	var flag decStackFlag
	if tt, lenHint, flag, err = d.setupType(tt, nil); err != nil {
	return err
	}
	// If tt isn't []byte or [n]byte (or a named variant of these), we need to
	// perform conversion byte-by-byte. This is complicated, and can't be
	// really fast, so we just push an entry onto the stack and handle this via
	// DecodeConvertedBytes below.
	//
	// We also need to perform the compatibility check, to make sure tt is
	// compatible with []byte. The check is fairly expensive, so skipping it
	// when tt is actually a bytes type makes the the common case faster.
	if !tt.IsBytes() {
	if !vdl.Compatible(tt, ttByteList) {
	return errIncompatibleDecode(tt, "bytes")
	}
	d.stack = append(d.stack, decStackEntry{
	Type: tt,
	Index: -1,
	LenHint: lenHint,
	Flag: flag,
	})
	isOnStack = true
	}
	}
	// Decode. The common-case fastpath reads directly from the buffer.
	if tt.IsBytes() {
	if err := d.decodeBytes(tt, lenHint, fixedLen, x); err != nil {
	return err
	}
	} else {
	if err := vdl.DecodeConvertedBytes(d, fixedLen, x); err != nil {
	return err
	}
	}
	// FinishValue
	if isOnStack {
	if err := d.FinishValue(); err != nil {
	return err
	}
	} else {
	d.flag = d.flag.Clear(decFlagIsParentBytes)
	if len(d.stack) == 0 {
	if err := d.endMessage(); err != nil {
	return err
	}
	}
	}
	return nil
	}

	var ttByteList = vdl.ListType(vdl.ByteType)