internal.vdl.go

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

// This file was auto-generated by the vanadium vdl tool.
// Package: internal
//
//nolint:revive
package internal

import (
	"fmt"
	"time"

	"v.io/v23/vdl"
	vdltime "v.io/v23/vdlroot/time"
	"v.io/v23/vom"
)

var initializeVDLCalled = false
var _ = initializeVDL() // Must be first; see initializeVDL comments for details.

// Hold type definitions in package-level variables, for better performance.
// Declare and initialize with default values here so that the initializeVDL
// method will be considered ready to initialize before any of the type
// definitions that appear below.
//
//nolint:unused
var (
	vdlTypeInt321     *vdl.Type = nil
	vdlTypeString2    *vdl.Type = nil
	vdlTypeEnum3      *vdl.Type = nil
	vdlTypeList4      *vdl.Type = nil
	vdlTypeArray5     *vdl.Type = nil
	vdlTypeArray6     *vdl.Type = nil
	vdlTypeList7      *vdl.Type = nil
	vdlTypeList8      *vdl.Type = nil
	vdlTypeSet9       *vdl.Type = nil
	vdlTypeMap10      *vdl.Type = nil
	vdlTypeStruct11   *vdl.Type = nil
	vdlTypeStruct12   *vdl.Type = nil
	vdlTypeUnion13    *vdl.Type = nil
	vdlTypeStruct14   *vdl.Type = nil
	vdlTypeOptional15 *vdl.Type = nil
	vdlTypeStruct16   *vdl.Type = nil
	vdlTypeStruct17   *vdl.Type = nil
	vdlTypeStruct18   *vdl.Type = nil
)

// Type definitions
// ================
type VNumber int32

func (VNumber) VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VNumber"`
}) {
}

func (x VNumber) VDLIsZero() bool { //nolint:gocyclo
	return x == 0
}

func (x VNumber) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.WriteValueInt(vdlTypeInt321, int64(x)); err != nil {
		return err
	}
	return nil
}

func (x *VNumber) VDLRead(dec vdl.Decoder) error { //nolint:gocyclo
	switch value, err := dec.ReadValueInt(32); {
	case err != nil:
		return err
	default:
		*x = VNumber(value)
	}
	return nil
}

type VString string

func (VString) VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VString"`
}) {
}

func (x VString) VDLIsZero() bool { //nolint:gocyclo
	return x == ""
}

func (x VString) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.WriteValueString(vdlTypeString2, string(x)); err != nil {
		return err
	}
	return nil
}

func (x *VString) VDLRead(dec vdl.Decoder) error { //nolint:gocyclo
	switch value, err := dec.ReadValueString(); {
	case err != nil:
		return err
	default:
		*x = VString(value)
	}
	return nil
}

type VEnum int

const (
	VEnumA VEnum = iota
	VEnumB
	VEnumC
)

// VEnumAll holds all labels for VEnum.
var VEnumAll = [...]VEnum{VEnumA, VEnumB, VEnumC}

// VEnumFromString creates a VEnum from a string label.
//
//nolint:unused
func VEnumFromString(label string) (x VEnum, err error) {
	err = x.Set(label)
	return
}

// Set assigns label to x.
func (x *VEnum) Set(label string) error {
	switch label {
	case "A", "a":
		*x = VEnumA
		return nil
	case "B", "b":
		*x = VEnumB
		return nil
	case "C", "c":
		*x = VEnumC
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in internal.VEnum", label)
}

// String returns the string label of x.
func (x VEnum) String() string {
	switch x {
	case VEnumA:
		return "A"
	case VEnumB:
		return "B"
	case VEnumC:
		return "C"
	}
	return ""
}

func (VEnum) VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VEnum"`
	Enum struct{ A, B, C string }
}) {
}

func (x VEnum) VDLIsZero() bool { //nolint:gocyclo
	return x == VEnumA
}

func (x VEnum) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.WriteValueString(vdlTypeEnum3, x.String()); err != nil {
		return err
	}
	return nil
}

func (x *VEnum) VDLRead(dec vdl.Decoder) error { //nolint:gocyclo
	switch value, err := dec.ReadValueString(); {
	case err != nil:
		return err
	default:
		if err := x.Set(value); err != nil {
			return err
		}
	}
	return nil
}

type VByteList []byte

func (VByteList) VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VByteList"`
}) {
}

func (x VByteList) VDLIsZero() bool { //nolint:gocyclo
	return len(x) == 0
}

func (x VByteList) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.WriteValueBytes(vdlTypeList4, []byte(x)); err != nil {
		return err
	}
	return nil
}

func (x *VByteList) VDLRead(dec vdl.Decoder) error { //nolint:gocyclo
	var bytes []byte
	if err := dec.ReadValueBytes(-1, &bytes); err != nil {
		return err
	}
	*x = bytes
	return nil
}

type VByteArray [3]byte

func (VByteArray) VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VByteArray"`
}) {
}

func (x VByteArray) VDLIsZero() bool { //nolint:gocyclo
	return x == VByteArray{}
}

func (x VByteArray) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.WriteValueBytes(vdlTypeArray5, x[:]); err != nil {
		return err
	}
	return nil
}

func (x *VByteArray) VDLRead(dec vdl.Decoder) error { //nolint:gocyclo
	bytes := x[:]
	if err := dec.ReadValueBytes(3, &bytes); err != nil {
		return err
	}
	return nil
}

type VArray [3]int32

func (VArray) VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VArray"`
}) {
}

func (x VArray) VDLIsZero() bool { //nolint:gocyclo
	return x == VArray{}
}

func (x VArray) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.StartValue(vdlTypeArray6); err != nil {
		return err
	}
	for _, elem := range x {
		if err := enc.NextEntryValueInt(vdl.Int32Type, int64(elem)); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VArray) VDLRead(dec vdl.Decoder) error { //nolint:gocyclo
	if err := dec.StartValue(vdlTypeArray6); err != nil {
		return err
	}
	for index := 0; index < 3; index++ {
		switch done, elem, err := dec.NextEntryValueInt(32); {
		case err != nil:
			return err
		case done:
			return fmt.Errorf("short array, got len %d < 3 %T)", index, *x)
		default:
			x[index] = int32(elem)
		}
	}
	switch done, err := dec.NextEntry(); {
	case err != nil:
		return err
	case !done:
		return fmt.Errorf("long array, got len > 3 %T", *x)
	}
	return dec.FinishValue()
}

type VList []int32

func (VList) VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VList"`
}) {
}

func (x VList) VDLIsZero() bool { //nolint:gocyclo
	return len(x) == 0
}

func (x VList) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.StartValue(vdlTypeList7); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for _, elem := range x {
		if err := enc.NextEntryValueInt(vdl.Int32Type, int64(elem)); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VList) VDLRead(dec vdl.Decoder) error { //nolint:gocyclo
	if err := dec.StartValue(vdlTypeList7); err != nil {
		return err
	}
	if len := dec.LenHint(); len > 0 {
		*x = make(VList, 0, len)
	} else {
		*x = nil
	}
	for {
		switch done, elem, err := dec.NextEntryValueInt(32); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		default:
			*x = append(*x, int32(elem))
		}
	}
}

type VListAny []*vom.RawBytes

func (VListAny) VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VListAny"`
}) {
}

func (x VListAny) VDLIsZero() bool { //nolint:gocyclo
	return len(x) == 0
}

func (x VListAny) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.StartValue(vdlTypeList8); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for _, elem := range x {
		if err := enc.NextEntry(false); err != nil {
			return err
		}
		if elem == nil {
			if err := enc.NilValue(vdl.AnyType); err != nil {
				return err
			}
		} else {
			if err := elem.VDLWrite(enc); err != nil {
				return err
			}
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VListAny) VDLRead(dec vdl.Decoder) error { //nolint:gocyclo
	if err := dec.StartValue(vdlTypeList8); err != nil {
		return err
	}
	if len := dec.LenHint(); len > 0 {
		*x = make(VListAny, 0, len)
	} else {
		*x = nil
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		default:
			var elem *vom.RawBytes
			elem = new(vom.RawBytes)
			if err := elem.VDLRead(dec); err != nil {
				return err
			}
			*x = append(*x, elem)
		}
	}
}

type VSet map[string]struct{}

func (VSet) VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VSet"`
}) {
}

func (x VSet) VDLIsZero() bool { //nolint:gocyclo
	return len(x) == 0
}

func (x VSet) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.StartValue(vdlTypeSet9); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for key := range x {
		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VSet) VDLRead(dec vdl.Decoder) error { //nolint:gocyclo
	if err := dec.StartValue(vdlTypeSet9); err != nil {
		return err
	}
	var tmpMap VSet
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(VSet, len)
	}
	for {
		switch done, key, err := dec.NextEntryValueString(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		default:
			if tmpMap == nil {
				tmpMap = make(VSet)
			}
			tmpMap[key] = struct{}{}
		}
	}
}

type VMap map[string]bool

func (VMap) VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VMap"`
}) {
}

func (x VMap) VDLIsZero() bool { //nolint:gocyclo
	return len(x) == 0
}

func (x VMap) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.StartValue(vdlTypeMap10); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for key, elem := range x {
		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
			return err
		}
		if err := enc.WriteValueBool(vdl.BoolType, elem); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VMap) VDLRead(dec vdl.Decoder) error { //nolint:gocyclo
	if err := dec.StartValue(vdlTypeMap10); err != nil {
		return err
	}
	var tmpMap VMap
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(VMap, len)
	}
	for {
		switch done, key, err := dec.NextEntryValueString(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		default:
			var elem bool
			switch value, err := dec.ReadValueBool(); {
			case err != nil:
				return err
			default:
				elem = value
			}
			if tmpMap == nil {
				tmpMap = make(VMap)
			}
			tmpMap[key] = elem
		}
	}
}

type VSmallStruct struct {
	A int32
	B string
	C bool
}

func (VSmallStruct) VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VSmallStruct"`
}) {
}

func (x VSmallStruct) VDLIsZero() bool { //nolint:gocyclo
	return x == VSmallStruct{}
}

func (x VSmallStruct) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.StartValue(vdlTypeStruct11); err != nil {
		return err
	}
	if x.A != 0 {
		if err := enc.NextFieldValueInt(0, vdl.Int32Type, int64(x.A)); err != nil {
			return err
		}
	}
	if x.B != "" {
		if err := enc.NextFieldValueString(1, vdl.StringType, x.B); err != nil {
			return err
		}
	}
	if x.C {
		if err := enc.NextFieldValueBool(2, vdl.BoolType, x.C); err != nil {
			return err
		}
	}
	if err := enc.NextField(-1); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VSmallStruct) VDLRead(dec vdl.Decoder) error { //nolint:gocyclo
	*x = VSmallStruct{}
	if err := dec.StartValue(vdlTypeStruct11); err != nil {
		return err
	}
	decType := dec.Type()
	for {
		index, err := dec.NextField()
		switch {
		case err != nil:
			return err
		case index == -1:
			return dec.FinishValue()
		}
		if decType != vdlTypeStruct11 {
			index = vdlTypeStruct11.FieldIndexByName(decType.Field(index).Name)
			if index == -1 {
				if err := dec.SkipValue(); err != nil {
					return err
				}
				continue
			}
		}
		switch index {
		case 0:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.A = int32(value)
			}
		case 1:
			switch value, err := dec.ReadValueString(); {
			case err != nil:
				return err
			default:
				x.B = value
			}
		case 2:
			switch value, err := dec.ReadValueBool(); {
			case err != nil:
				return err
			default:
				x.C = value
			}
		}
	}
}

type VLargeStruct struct {
	F1  int32
	F2  int32
	F3  int32
	F4  int32
	F5  int32
	F6  int32
	F7  int32
	F8  int32
	F9  int32
	F10 int32
	F11 int32
	F12 int32
	F13 int32
	F14 int32
	F15 int32
	F16 int32
	F17 int32
	F18 int32
	F19 int32
	F20 int32
	F21 int32
	F22 int32
	F23 int32
	F24 int32
	F25 int32
	F26 int32
	F27 int32
	F28 int32
	F29 int32
	F30 int32
	F31 int32
	F32 int32
	F33 int32
	F34 int32
	F35 int32
	F36 int32
	F37 int32
	F38 int32
	F39 int32
	F40 int32
	F41 int32
	F42 int32
	F43 int32
	F44 int32
	F45 int32
	F46 int32
	F47 int32
	F48 int32
	F49 int32
	F50 int32
}

func (VLargeStruct) VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VLargeStruct"`
}) {
}

func (x VLargeStruct) VDLIsZero() bool { //nolint:gocyclo
	return x == VLargeStruct{}
}

func (x VLargeStruct) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.StartValue(vdlTypeStruct12); err != nil {
		return err
	}
	if x.F1 != 0 {
		if err := enc.NextFieldValueInt(0, vdl.Int32Type, int64(x.F1)); err != nil {
			return err
		}
	}
	if x.F2 != 0 {
		if err := enc.NextFieldValueInt(1, vdl.Int32Type, int64(x.F2)); err != nil {
			return err
		}
	}
	if x.F3 != 0 {
		if err := enc.NextFieldValueInt(2, vdl.Int32Type, int64(x.F3)); err != nil {
			return err
		}
	}
	if x.F4 != 0 {
		if err := enc.NextFieldValueInt(3, vdl.Int32Type, int64(x.F4)); err != nil {
			return err
		}
	}
	if x.F5 != 0 {
		if err := enc.NextFieldValueInt(4, vdl.Int32Type, int64(x.F5)); err != nil {
			return err
		}
	}
	if x.F6 != 0 {
		if err := enc.NextFieldValueInt(5, vdl.Int32Type, int64(x.F6)); err != nil {
			return err
		}
	}
	if x.F7 != 0 {
		if err := enc.NextFieldValueInt(6, vdl.Int32Type, int64(x.F7)); err != nil {
			return err
		}
	}
	if x.F8 != 0 {
		if err := enc.NextFieldValueInt(7, vdl.Int32Type, int64(x.F8)); err != nil {
			return err
		}
	}
	if x.F9 != 0 {
		if err := enc.NextFieldValueInt(8, vdl.Int32Type, int64(x.F9)); err != nil {
			return err
		}
	}
	if x.F10 != 0 {
		if err := enc.NextFieldValueInt(9, vdl.Int32Type, int64(x.F10)); err != nil {
			return err
		}
	}
	if x.F11 != 0 {
		if err := enc.NextFieldValueInt(10, vdl.Int32Type, int64(x.F11)); err != nil {
			return err
		}
	}
	if x.F12 != 0 {
		if err := enc.NextFieldValueInt(11, vdl.Int32Type, int64(x.F12)); err != nil {
			return err
		}
	}
	if x.F13 != 0 {
		if err := enc.NextFieldValueInt(12, vdl.Int32Type, int64(x.F13)); err != nil {
			return err
		}
	}
	if x.F14 != 0 {
		if err := enc.NextFieldValueInt(13, vdl.Int32Type, int64(x.F14)); err != nil {
			return err
		}
	}
	if x.F15 != 0 {
		if err := enc.NextFieldValueInt(14, vdl.Int32Type, int64(x.F15)); err != nil {
			return err
		}
	}
	if x.F16 != 0 {
		if err := enc.NextFieldValueInt(15, vdl.Int32Type, int64(x.F16)); err != nil {
			return err
		}
	}
	if x.F17 != 0 {
		if err := enc.NextFieldValueInt(16, vdl.Int32Type, int64(x.F17)); err != nil {
			return err
		}
	}
	if x.F18 != 0 {
		if err := enc.NextFieldValueInt(17, vdl.Int32Type, int64(x.F18)); err != nil {
			return err
		}
	}
	if x.F19 != 0 {
		if err := enc.NextFieldValueInt(18, vdl.Int32Type, int64(x.F19)); err != nil {
			return err
		}
	}
	if x.F20 != 0 {
		if err := enc.NextFieldValueInt(19, vdl.Int32Type, int64(x.F20)); err != nil {
			return err
		}
	}
	if x.F21 != 0 {
		if err := enc.NextFieldValueInt(20, vdl.Int32Type, int64(x.F21)); err != nil {
			return err
		}
	}
	if x.F22 != 0 {
		if err := enc.NextFieldValueInt(21, vdl.Int32Type, int64(x.F22)); err != nil {
			return err
		}
	}
	if x.F23 != 0 {
		if err := enc.NextFieldValueInt(22, vdl.Int32Type, int64(x.F23)); err != nil {
			return err
		}
	}
	if x.F24 != 0 {
		if err := enc.NextFieldValueInt(23, vdl.Int32Type, int64(x.F24)); err != nil {
			return err
		}
	}
	if x.F25 != 0 {
		if err := enc.NextFieldValueInt(24, vdl.Int32Type, int64(x.F25)); err != nil {
			return err
		}
	}
	if x.F26 != 0 {
		if err := enc.NextFieldValueInt(25, vdl.Int32Type, int64(x.F26)); err != nil {
			return err
		}
	}
	if x.F27 != 0 {
		if err := enc.NextFieldValueInt(26, vdl.Int32Type, int64(x.F27)); err != nil {
			return err
		}
	}
	if x.F28 != 0 {
		if err := enc.NextFieldValueInt(27, vdl.Int32Type, int64(x.F28)); err != nil {
			return err
		}
	}
	if x.F29 != 0 {
		if err := enc.NextFieldValueInt(28, vdl.Int32Type, int64(x.F29)); err != nil {
			return err
		}
	}
	if x.F30 != 0 {
		if err := enc.NextFieldValueInt(29, vdl.Int32Type, int64(x.F30)); err != nil {
			return err
		}
	}
	if x.F31 != 0 {
		if err := enc.NextFieldValueInt(30, vdl.Int32Type, int64(x.F31)); err != nil {
			return err
		}
	}
	if x.F32 != 0 {
		if err := enc.NextFieldValueInt(31, vdl.Int32Type, int64(x.F32)); err != nil {
			return err
		}
	}
	if x.F33 != 0 {
		if err := enc.NextFieldValueInt(32, vdl.Int32Type, int64(x.F33)); err != nil {
			return err
		}
	}
	if x.F34 != 0 {
		if err := enc.NextFieldValueInt(33, vdl.Int32Type, int64(x.F34)); err != nil {
			return err
		}
	}
	if x.F35 != 0 {
		if err := enc.NextFieldValueInt(34, vdl.Int32Type, int64(x.F35)); err != nil {
			return err
		}
	}
	if x.F36 != 0 {
		if err := enc.NextFieldValueInt(35, vdl.Int32Type, int64(x.F36)); err != nil {
			return err
		}
	}
	if x.F37 != 0 {
		if err := enc.NextFieldValueInt(36, vdl.Int32Type, int64(x.F37)); err != nil {
			return err
		}
	}
	if x.F38 != 0 {
		if err := enc.NextFieldValueInt(37, vdl.Int32Type, int64(x.F38)); err != nil {
			return err
		}
	}
	if x.F39 != 0 {
		if err := enc.NextFieldValueInt(38, vdl.Int32Type, int64(x.F39)); err != nil {
			return err
		}
	}
	if x.F40 != 0 {
		if err := enc.NextFieldValueInt(39, vdl.Int32Type, int64(x.F40)); err != nil {
			return err
		}
	}
	if x.F41 != 0 {
		if err := enc.NextFieldValueInt(40, vdl.Int32Type, int64(x.F41)); err != nil {
			return err
		}
	}
	if x.F42 != 0 {
		if err := enc.NextFieldValueInt(41, vdl.Int32Type, int64(x.F42)); err != nil {
			return err
		}
	}
	if x.F43 != 0 {
		if err := enc.NextFieldValueInt(42, vdl.Int32Type, int64(x.F43)); err != nil {
			return err
		}
	}
	if x.F44 != 0 {
		if err := enc.NextFieldValueInt(43, vdl.Int32Type, int64(x.F44)); err != nil {
			return err
		}
	}
	if x.F45 != 0 {
		if err := enc.NextFieldValueInt(44, vdl.Int32Type, int64(x.F45)); err != nil {
			return err
		}
	}
	if x.F46 != 0 {
		if err := enc.NextFieldValueInt(45, vdl.Int32Type, int64(x.F46)); err != nil {
			return err
		}
	}
	if x.F47 != 0 {
		if err := enc.NextFieldValueInt(46, vdl.Int32Type, int64(x.F47)); err != nil {
			return err
		}
	}
	if x.F48 != 0 {
		if err := enc.NextFieldValueInt(47, vdl.Int32Type, int64(x.F48)); err != nil {
			return err
		}
	}
	if x.F49 != 0 {
		if err := enc.NextFieldValueInt(48, vdl.Int32Type, int64(x.F49)); err != nil {
			return err
		}
	}
	if x.F50 != 0 {
		if err := enc.NextFieldValueInt(49, vdl.Int32Type, int64(x.F50)); err != nil {
			return err
		}
	}
	if err := enc.NextField(-1); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VLargeStruct) VDLRead(dec vdl.Decoder) error { //nolint:gocyclo
	*x = VLargeStruct{}
	if err := dec.StartValue(vdlTypeStruct12); err != nil {
		return err
	}
	decType := dec.Type()
	for {
		index, err := dec.NextField()
		switch {
		case err != nil:
			return err
		case index == -1:
			return dec.FinishValue()
		}
		if decType != vdlTypeStruct12 {
			index = vdlTypeStruct12.FieldIndexByName(decType.Field(index).Name)
			if index == -1 {
				if err := dec.SkipValue(); err != nil {
					return err
				}
				continue
			}
		}
		switch index {
		case 0:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F1 = int32(value)
			}
		case 1:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F2 = int32(value)
			}
		case 2:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F3 = int32(value)
			}
		case 3:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F4 = int32(value)
			}
		case 4:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F5 = int32(value)
			}
		case 5:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F6 = int32(value)
			}
		case 6:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F7 = int32(value)
			}
		case 7:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F8 = int32(value)
			}
		case 8:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F9 = int32(value)
			}
		case 9:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F10 = int32(value)
			}
		case 10:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F11 = int32(value)
			}
		case 11:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F12 = int32(value)
			}
		case 12:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F13 = int32(value)
			}
		case 13:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F14 = int32(value)
			}
		case 14:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F15 = int32(value)
			}
		case 15:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F16 = int32(value)
			}
		case 16:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F17 = int32(value)
			}
		case 17:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F18 = int32(value)
			}
		case 18:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F19 = int32(value)
			}
		case 19:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F20 = int32(value)
			}
		case 20:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F21 = int32(value)
			}
		case 21:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F22 = int32(value)
			}
		case 22:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F23 = int32(value)
			}
		case 23:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F24 = int32(value)
			}
		case 24:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F25 = int32(value)
			}
		case 25:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F26 = int32(value)
			}
		case 26:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F27 = int32(value)
			}
		case 27:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F28 = int32(value)
			}
		case 28:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F29 = int32(value)
			}
		case 29:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F30 = int32(value)
			}
		case 30:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F31 = int32(value)
			}
		case 31:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F32 = int32(value)
			}
		case 32:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F33 = int32(value)
			}
		case 33:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F34 = int32(value)
			}
		case 34:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F35 = int32(value)
			}
		case 35:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F36 = int32(value)
			}
		case 36:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F37 = int32(value)
			}
		case 37:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F38 = int32(value)
			}
		case 38:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F39 = int32(value)
			}
		case 39:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F40 = int32(value)
			}
		case 40:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F41 = int32(value)
			}
		case 41:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F42 = int32(value)
			}
		case 42:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F43 = int32(value)
			}
		case 43:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F44 = int32(value)
			}
		case 44:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F45 = int32(value)
			}
		case 45:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F46 = int32(value)
			}
		case 46:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F47 = int32(value)
			}
		case 47:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F48 = int32(value)
			}
		case 48:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F49 = int32(value)
			}
		case 49:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F50 = int32(value)
			}
		}
	}
}

type (
	// VSmallUnion represents any single field of the VSmallUnion union type.
	VSmallUnion interface {
		// Index returns the field index.
		Index() int
		// Interface returns the field value as an interface.
		Interface() interface{}
		// Name returns the field name.
		Name() string
		// VDLReflect describes the VSmallUnion union type.
		VDLReflect(vdlVSmallUnionReflect)
		VDLIsZero() bool
		VDLWrite(vdl.Encoder) error
	}
	// VSmallUnionA represents field A of the VSmallUnion union type.
	VSmallUnionA struct{ Value int32 }
	// VSmallUnionB represents field B of the VSmallUnion union type.
	VSmallUnionB struct{ Value string }
	// VSmallUnionC represents field C of the VSmallUnion union type.
	VSmallUnionC struct{ Value bool }
	// vdlVSmallUnionReflect describes the VSmallUnion union type.
	vdlVSmallUnionReflect struct {
		Name  string `vdl:"v.io/v23/vom/internal.VSmallUnion"`
		Type  VSmallUnion
		Union struct {
			A VSmallUnionA
			B VSmallUnionB
			C VSmallUnionC
		}
	}
)

func (x VSmallUnionA) Index() int                       { return 0 }
func (x VSmallUnionA) Interface() interface{}           { return x.Value }
func (x VSmallUnionA) Name() string                     { return "A" }
func (x VSmallUnionA) VDLReflect(vdlVSmallUnionReflect) {}

func (x VSmallUnionB) Index() int                       { return 1 }
func (x VSmallUnionB) Interface() interface{}           { return x.Value }
func (x VSmallUnionB) Name() string                     { return "B" }
func (x VSmallUnionB) VDLReflect(vdlVSmallUnionReflect) {}

func (x VSmallUnionC) Index() int                       { return 2 }
func (x VSmallUnionC) Interface() interface{}           { return x.Value }
func (x VSmallUnionC) Name() string                     { return "C" }
func (x VSmallUnionC) VDLReflect(vdlVSmallUnionReflect) {}

func (x VSmallUnionA) VDLIsZero() bool { //nolint:gocyclo
	return x.Value == 0
}

func (x VSmallUnionB) VDLIsZero() bool {
	return false
}

func (x VSmallUnionC) VDLIsZero() bool {
	return false
}

func (x VSmallUnionA) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.StartValue(vdlTypeUnion13); err != nil {
		return err
	}
	if err := enc.NextFieldValueInt(0, vdl.Int32Type, int64(x.Value)); err != nil {
		return err
	}
	if err := enc.NextField(-1); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x VSmallUnionB) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.StartValue(vdlTypeUnion13); err != nil {
		return err
	}
	if err := enc.NextFieldValueString(1, vdl.StringType, x.Value); err != nil {
		return err
	}
	if err := enc.NextField(-1); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x VSmallUnionC) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.StartValue(vdlTypeUnion13); err != nil {
		return err
	}
	if err := enc.NextFieldValueBool(2, vdl.BoolType, x.Value); err != nil {
		return err
	}
	if err := enc.NextField(-1); err != nil {
		return err
	}
	return enc.FinishValue()
}

func VDLReadVSmallUnion(dec vdl.Decoder, x *VSmallUnion) error { //nolint:gocyclo
	if err := dec.StartValue(vdlTypeUnion13); err != nil {
		return err
	}
	decType := dec.Type()
	index, err := dec.NextField()
	switch {
	case err != nil:
		return err
	case index == -1:
		return fmt.Errorf("missing field in union %T, from %v", x, decType)
	}
	if decType != vdlTypeUnion13 {
		name := decType.Field(index).Name
		index = vdlTypeUnion13.FieldIndexByName(name)
		if index == -1 {
			return fmt.Errorf("field %q not in union %T, from %v", name, x, decType)
		}
	}
	switch index {
	case 0:
		var field VSmallUnionA
		switch value, err := dec.ReadValueInt(32); {
		case err != nil:
			return err
		default:
			field.Value = int32(value)
		}
		*x = field
	case 1:
		var field VSmallUnionB
		switch value, err := dec.ReadValueString(); {
		case err != nil:
			return err
		default:
			field.Value = value
		}
		*x = field
	case 2:
		var field VSmallUnionC
		switch value, err := dec.ReadValueBool(); {
		case err != nil:
			return err
		default:
			field.Value = value
		}
		*x = field
	}
	switch index, err := dec.NextField(); {
	case err != nil:
		return err
	case index != -1:
		return fmt.Errorf("extra field %d in union %T, from %v", index, x, dec.Type())
	}
	return dec.FinishValue()
}

type VStructWithOptional struct {
	F1 int32
	F2 *VSmallStruct
}

func (VStructWithOptional) VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VStructWithOptional"`
}) {
}

func (x VStructWithOptional) VDLIsZero() bool { //nolint:gocyclo
	return x == VStructWithOptional{}
}

func (x VStructWithOptional) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.StartValue(vdlTypeStruct14); err != nil {
		return err
	}
	if x.F1 != 0 {
		if err := enc.NextFieldValueInt(0, vdl.Int32Type, int64(x.F1)); err != nil {
			return err
		}
	}
	if x.F2 != nil {
		if err := enc.NextField(1); err != nil {
			return err
		}
		enc.SetNextStartValueIsOptional()
		if err := x.F2.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(-1); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VStructWithOptional) VDLRead(dec vdl.Decoder) error { //nolint:gocyclo
	*x = VStructWithOptional{}
	if err := dec.StartValue(vdlTypeStruct14); err != nil {
		return err
	}
	decType := dec.Type()
	for {
		index, err := dec.NextField()
		switch {
		case err != nil:
			return err
		case index == -1:
			return dec.FinishValue()
		}
		if decType != vdlTypeStruct14 {
			index = vdlTypeStruct14.FieldIndexByName(decType.Field(index).Name)
			if index == -1 {
				if err := dec.SkipValue(); err != nil {
					return err
				}
				continue
			}
		}
		switch index {
		case 0:
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F1 = int32(value)
			}
		case 1:
			if err := dec.StartValue(vdlTypeOptional15); err != nil {
				return err
			}
			if dec.IsNil() {
				x.F2 = nil
				if err := dec.FinishValue(); err != nil {
					return err
				}
			} else {
				x.F2 = new(VSmallStruct)
				dec.IgnoreNextStartValue()
				if err := x.F2.VDLRead(dec); err != nil {
					return err
				}
			}
		}
	}
}

type VStructWithNative struct {
	Time     time.Time
	Duration time.Duration
}

func (VStructWithNative) VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VStructWithNative"`
}) {
}

func (x VStructWithNative) VDLIsZero() bool { //nolint:gocyclo
	if !x.Time.IsZero() {
		return false
	}
	if x.Duration != 0 {
		return false
	}
	return true
}

func (x VStructWithNative) VDLWrite(enc vdl.Encoder) error { //nolint:gocyclo
	if err := enc.StartValue(vdlTypeStruct16); err != nil {
		return err
	}
	if !x.Time.IsZero() {
		if err := enc.NextField(0); err != nil {
			return err
		}
		var wire vdltime.Time
		if err := vdltime.TimeFromNative(&wire, x.Time); err != nil {
			return err
		}
		if err := wire.VDLWrite(enc); err != nil {
			return err
		}
	}
	if x.Duration != 0 {
		if err := enc.NextField(1); err != nil {
			return err
		}
		var wire vdltime.Duration
		if err := vdltime.DurationFromNative(&wire, x.Duration); err != nil {
			return err
		}
		if err := wire.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(-1); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VStructWithNative) VDLRead(dec vdl.Decoder) error { //nolint:gocyclo
	*x = VStructWithNative{}
	if err := dec.StartValue(vdlTypeStruct16); err != nil {
		return err
	}
	decType := dec.Type()
	for {
		index, err := dec.NextField()
		switch {
		case err != nil:
			return err
		case index == -1:
			return dec.FinishValue()
		}
		if decType != vdlTypeStruct16 {
			index = vdlTypeStruct16.FieldIndexByName(decType.Field(index).Name)
			if index == -1 {
				if err := dec.SkipValue(); err != nil {
					return err
				}
				continue
			}
		}
		switch index {
		case 0:
			var wire vdltime.Time
			if err := wire.VDLRead(dec); err != nil {
				return err
			}
			if err := vdltime.TimeToNative(wire, &x.Time); err != nil {
				return err
			}
		case 1:
			var wire vdltime.Duration
			if err := wire.VDLRead(dec); err != nil {
				return err
			}
			if err := vdltime.DurationToNative(wire, &x.Duration); err != nil {
				return err
			}
		}
	}
}

// initializeVDL performs vdl initialization.  It is safe to call multiple times.
// If you have an init ordering issue, just insert the following line verbatim
// into your source files in this package, right after the "package foo" clause:
//
// var _ = initializeVDL()
//
// The purpose of this function is to ensure that vdl initialization occurs in
// the right order, and very early in the init sequence.  In particular, vdl
// registration and package variable initialization needs to occur before
// functions like vdl.TypeOf will work properly.
//
// This function returns a dummy value, so that it can be used to initialize the
// first var in the file, to take advantage of Go's defined init order.
func initializeVDL() struct{} {
	if initializeVDLCalled {
		return struct{}{}
	}
	initializeVDLCalled = true

	// Register types.
	vdl.Register((*VNumber)(nil))
	vdl.Register((*VString)(nil))
	vdl.Register((*VEnum)(nil))
	vdl.Register((*VByteList)(nil))
	vdl.Register((*VByteArray)(nil))
	vdl.Register((*VArray)(nil))
	vdl.Register((*VList)(nil))
	vdl.Register((*VListAny)(nil))
	vdl.Register((*VSet)(nil))
	vdl.Register((*VMap)(nil))
	vdl.Register((*VSmallStruct)(nil))
	vdl.Register((*VLargeStruct)(nil))
	vdl.Register((*VSmallUnion)(nil))
	vdl.Register((*VStructWithOptional)(nil))
	vdl.Register((*VStructWithNative)(nil))

	// Initialize type definitions.
	vdlTypeInt321 = vdl.TypeOf((*VNumber)(nil))
	vdlTypeString2 = vdl.TypeOf((*VString)(nil))
	vdlTypeEnum3 = vdl.TypeOf((*VEnum)(nil))
	vdlTypeList4 = vdl.TypeOf((*VByteList)(nil))
	vdlTypeArray5 = vdl.TypeOf((*VByteArray)(nil))
	vdlTypeArray6 = vdl.TypeOf((*VArray)(nil))
	vdlTypeList7 = vdl.TypeOf((*VList)(nil))
	vdlTypeList8 = vdl.TypeOf((*VListAny)(nil))
	vdlTypeSet9 = vdl.TypeOf((*VSet)(nil))
	vdlTypeMap10 = vdl.TypeOf((*VMap)(nil))
	vdlTypeStruct11 = vdl.TypeOf((*VSmallStruct)(nil)).Elem()
	vdlTypeStruct12 = vdl.TypeOf((*VLargeStruct)(nil)).Elem()
	vdlTypeUnion13 = vdl.TypeOf((*VSmallUnion)(nil))
	vdlTypeStruct14 = vdl.TypeOf((*VStructWithOptional)(nil)).Elem()
	vdlTypeOptional15 = vdl.TypeOf((*VSmallStruct)(nil))
	vdlTypeStruct16 = vdl.TypeOf((*VStructWithNative)(nil)).Elem()
	vdlTypeStruct17 = vdl.TypeOf((*vdltime.Time)(nil)).Elem()
	vdlTypeStruct18 = vdl.TypeOf((*vdltime.Duration)(nil)).Elem()

	return struct{}{}
}