| // Copyright 2015 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: types |
| |
| package types |
| |
| import ( |
| "fmt" |
| "v.io/v23/vdl" |
| ) |
| |
| var _ = __VDLInit() // Must be first; see __VDLInit comments for details. |
| |
| ////////////////////////////////////////////////// |
| // Type definitions |
| |
| // TestCase represents an individual testcase for vom encoding and decoding. |
| type TestCase struct { |
| Name string // Name of the testcase |
| Value *vdl.Value // Value to test |
| TypeString string // The string representation of the Type |
| Hex string // Hex pattern representing vom encoding |
| HexVersion string // Hex pattern representing vom encoding of Version |
| HexType string // Hex pattern representing vom encoding of Type |
| HexValue string // Hex pattern representing vom encoding of Value |
| } |
| |
| func (TestCase) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.TestCase"` |
| }) { |
| } |
| |
| func (x TestCase) VDLIsZero() bool { |
| if x.Name != "" { |
| return false |
| } |
| if x.Value != nil && !x.Value.VDLIsZero() { |
| return false |
| } |
| if x.TypeString != "" { |
| return false |
| } |
| if x.Hex != "" { |
| return false |
| } |
| if x.HexVersion != "" { |
| return false |
| } |
| if x.HexType != "" { |
| return false |
| } |
| if x.HexValue != "" { |
| return false |
| } |
| return true |
| } |
| |
| func (x TestCase) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_1); err != nil { |
| return err |
| } |
| if x.Name != "" { |
| if err := enc.NextFieldValueString(0, vdl.StringType, x.Name); err != nil { |
| return err |
| } |
| } |
| if x.Value != nil && !x.Value.VDLIsZero() { |
| if err := enc.NextField(1); err != nil { |
| return err |
| } |
| if err := x.Value.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.TypeString != "" { |
| if err := enc.NextFieldValueString(2, vdl.StringType, x.TypeString); err != nil { |
| return err |
| } |
| } |
| if x.Hex != "" { |
| if err := enc.NextFieldValueString(3, vdl.StringType, x.Hex); err != nil { |
| return err |
| } |
| } |
| if x.HexVersion != "" { |
| if err := enc.NextFieldValueString(4, vdl.StringType, x.HexVersion); err != nil { |
| return err |
| } |
| } |
| if x.HexType != "" { |
| if err := enc.NextFieldValueString(5, vdl.StringType, x.HexType); err != nil { |
| return err |
| } |
| } |
| if x.HexValue != "" { |
| if err := enc.NextFieldValueString(6, vdl.StringType, x.HexValue); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *TestCase) VDLRead(dec vdl.Decoder) error { |
| *x = TestCase{ |
| Value: vdl.ZeroValue(vdl.AnyType), |
| } |
| if err := dec.StartValue(__VDLType_struct_1); 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 != __VDLType_struct_1 { |
| index = __VDLType_struct_1.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.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| x.Name = value |
| } |
| case 1: |
| x.Value = new(vdl.Value) |
| if err := x.Value.VDLRead(dec); err != nil { |
| return err |
| } |
| case 2: |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| x.TypeString = value |
| } |
| case 3: |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| x.Hex = value |
| } |
| case 4: |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| x.HexVersion = value |
| } |
| case 5: |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| x.HexType = value |
| } |
| case 6: |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| x.HexValue = value |
| } |
| } |
| } |
| } |
| |
| // vomdata config types |
| type ConvertGroup struct { |
| Name string |
| PrimaryType *vdl.Type |
| Values []*vdl.Value |
| } |
| |
| func (ConvertGroup) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.ConvertGroup"` |
| }) { |
| } |
| |
| func (x ConvertGroup) VDLIsZero() bool { |
| if x.Name != "" { |
| return false |
| } |
| if x.PrimaryType != nil && x.PrimaryType != vdl.AnyType { |
| return false |
| } |
| if len(x.Values) != 0 { |
| return false |
| } |
| return true |
| } |
| |
| func (x ConvertGroup) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_2); err != nil { |
| return err |
| } |
| if x.Name != "" { |
| if err := enc.NextFieldValueString(0, vdl.StringType, x.Name); err != nil { |
| return err |
| } |
| } |
| if x.PrimaryType != nil && x.PrimaryType != vdl.AnyType { |
| if err := enc.NextFieldValueTypeObject(1, x.PrimaryType); err != nil { |
| return err |
| } |
| } |
| if len(x.Values) != 0 { |
| if err := enc.NextField(2); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_list_1(enc, x.Values); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func __VDLWriteAnon_list_1(enc vdl.Encoder, x []*vdl.Value) error { |
| if err := enc.StartValue(__VDLType_list_3); 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 *ConvertGroup) VDLRead(dec vdl.Decoder) error { |
| *x = ConvertGroup{ |
| PrimaryType: vdl.AnyType, |
| } |
| if err := dec.StartValue(__VDLType_struct_2); 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 != __VDLType_struct_2 { |
| index = __VDLType_struct_2.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.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| x.Name = value |
| } |
| case 1: |
| switch value, err := dec.ReadValueTypeObject(); { |
| case err != nil: |
| return err |
| default: |
| x.PrimaryType = value |
| } |
| case 2: |
| if err := __VDLReadAnon_list_1(dec, &x.Values); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| func __VDLReadAnon_list_1(dec vdl.Decoder, x *[]*vdl.Value) error { |
| if err := dec.StartValue(__VDLType_list_3); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make([]*vdl.Value, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| var elem *vdl.Value |
| elem = new(vdl.Value) |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| type VomdataStruct struct { |
| EncodeDecodeData map[byte][]*vdl.Value // map from min required VOM version to test values |
| CompatData map[string][]*vdl.Type |
| ConvertData map[string][]ConvertGroup |
| } |
| |
| func (VomdataStruct) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.VomdataStruct"` |
| }) { |
| } |
| |
| func (x VomdataStruct) VDLIsZero() bool { |
| if len(x.EncodeDecodeData) != 0 { |
| return false |
| } |
| if len(x.CompatData) != 0 { |
| return false |
| } |
| if len(x.ConvertData) != 0 { |
| return false |
| } |
| return true |
| } |
| |
| func (x VomdataStruct) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_4); err != nil { |
| return err |
| } |
| if len(x.EncodeDecodeData) != 0 { |
| if err := enc.NextField(0); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_map_2(enc, x.EncodeDecodeData); err != nil { |
| return err |
| } |
| } |
| if len(x.CompatData) != 0 { |
| if err := enc.NextField(1); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_map_3(enc, x.CompatData); err != nil { |
| return err |
| } |
| } |
| if len(x.ConvertData) != 0 { |
| if err := enc.NextField(2); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_map_4(enc, x.ConvertData); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func __VDLWriteAnon_map_2(enc vdl.Encoder, x map[byte][]*vdl.Value) error { |
| if err := enc.StartValue(__VDLType_map_5); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key, elem := range x { |
| if err := enc.NextEntryValueUint(vdl.ByteType, uint64(key)); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_list_1(enc, elem); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func __VDLWriteAnon_map_3(enc vdl.Encoder, x map[string][]*vdl.Type) error { |
| if err := enc.StartValue(__VDLType_map_6); 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 := __VDLWriteAnon_list_5(enc, elem); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func __VDLWriteAnon_map_4(enc vdl.Encoder, x map[string][]ConvertGroup) error { |
| if err := enc.StartValue(__VDLType_map_7); 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 := __VDLWriteAnon_list_6(enc, elem); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func __VDLWriteAnon_list_5(enc vdl.Encoder, x []*vdl.Type) error { |
| if err := enc.StartValue(__VDLType_list_8); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for _, elem := range x { |
| if err := enc.NextEntryValueTypeObject(elem); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func __VDLWriteAnon_list_6(enc vdl.Encoder, x []ConvertGroup) error { |
| if err := enc.StartValue(__VDLType_list_9); 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 err := elem.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *VomdataStruct) VDLRead(dec vdl.Decoder) error { |
| *x = VomdataStruct{} |
| if err := dec.StartValue(__VDLType_struct_4); 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 != __VDLType_struct_4 { |
| index = __VDLType_struct_4.FieldIndexByName(decType.Field(index).Name) |
| if index == -1 { |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| continue |
| } |
| } |
| switch index { |
| case 0: |
| if err := __VDLReadAnon_map_2(dec, &x.EncodeDecodeData); err != nil { |
| return err |
| } |
| case 1: |
| if err := __VDLReadAnon_map_3(dec, &x.CompatData); err != nil { |
| return err |
| } |
| case 2: |
| if err := __VDLReadAnon_map_4(dec, &x.ConvertData); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| func __VDLReadAnon_map_2(dec vdl.Decoder, x *map[byte][]*vdl.Value) error { |
| if err := dec.StartValue(__VDLType_map_5); err != nil { |
| return err |
| } |
| var tmpMap map[byte][]*vdl.Value |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(map[byte][]*vdl.Value, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueUint(8); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| var elem []*vdl.Value |
| if err := __VDLReadAnon_list_1(dec, &elem); err != nil { |
| return err |
| } |
| if tmpMap == nil { |
| tmpMap = make(map[byte][]*vdl.Value) |
| } |
| tmpMap[byte(key)] = elem |
| } |
| } |
| } |
| |
| func __VDLReadAnon_map_3(dec vdl.Decoder, x *map[string][]*vdl.Type) error { |
| if err := dec.StartValue(__VDLType_map_6); err != nil { |
| return err |
| } |
| var tmpMap map[string][]*vdl.Type |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(map[string][]*vdl.Type, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueString(); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| var elem []*vdl.Type |
| if err := __VDLReadAnon_list_5(dec, &elem); err != nil { |
| return err |
| } |
| if tmpMap == nil { |
| tmpMap = make(map[string][]*vdl.Type) |
| } |
| tmpMap[key] = elem |
| } |
| } |
| } |
| |
| func __VDLReadAnon_map_4(dec vdl.Decoder, x *map[string][]ConvertGroup) error { |
| if err := dec.StartValue(__VDLType_map_7); err != nil { |
| return err |
| } |
| var tmpMap map[string][]ConvertGroup |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(map[string][]ConvertGroup, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueString(); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| var elem []ConvertGroup |
| if err := __VDLReadAnon_list_6(dec, &elem); err != nil { |
| return err |
| } |
| if tmpMap == nil { |
| tmpMap = make(map[string][]ConvertGroup) |
| } |
| tmpMap[key] = elem |
| } |
| } |
| } |
| |
| func __VDLReadAnon_list_5(dec vdl.Decoder, x *[]*vdl.Type) error { |
| if err := dec.StartValue(__VDLType_list_8); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make([]*vdl.Type, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, elem, err := dec.NextEntryValueTypeObject(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| func __VDLReadAnon_list_6(dec vdl.Decoder, x *[]ConvertGroup) error { |
| if err := dec.StartValue(__VDLType_list_9); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make([]ConvertGroup, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| var elem ConvertGroup |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| // Named Types |
| type NBool bool |
| |
| func (NBool) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NBool"` |
| }) { |
| } |
| |
| func (x NBool) VDLIsZero() bool { |
| return bool(!x) |
| } |
| |
| func (x NBool) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueBool(__VDLType_bool_10, bool(x)); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *NBool) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| *x = NBool(value) |
| } |
| return nil |
| } |
| |
| type NString string |
| |
| func (NString) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NString"` |
| }) { |
| } |
| |
| func (x NString) VDLIsZero() bool { |
| return x == "" |
| } |
| |
| func (x NString) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueString(__VDLType_string_11, string(x)); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *NString) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| *x = NString(value) |
| } |
| return nil |
| } |
| |
| type NByteSlice []byte |
| |
| func (NByteSlice) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NByteSlice"` |
| }) { |
| } |
| |
| func (x NByteSlice) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x NByteSlice) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueBytes(__VDLType_list_12, []byte(x)); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *NByteSlice) VDLRead(dec vdl.Decoder) error { |
| var bytes []byte |
| if err := dec.ReadValueBytes(-1, &bytes); err != nil { |
| return err |
| } |
| *x = bytes |
| return nil |
| } |
| |
| type NByteArray [4]byte |
| |
| func (NByteArray) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NByteArray"` |
| }) { |
| } |
| |
| func (x NByteArray) VDLIsZero() bool { |
| return x == NByteArray{} |
| } |
| |
| func (x NByteArray) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueBytes(__VDLType_array_13, x[:]); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *NByteArray) VDLRead(dec vdl.Decoder) error { |
| bytes := x[:] |
| if err := dec.ReadValueBytes(4, &bytes); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type NByte byte |
| |
| func (NByte) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NByte"` |
| }) { |
| } |
| |
| func (x NByte) VDLIsZero() bool { |
| return x == 0 |
| } |
| |
| func (x NByte) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueUint(__VDLType_byte_14, uint64(x)); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *NByte) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueUint(8); { |
| case err != nil: |
| return err |
| default: |
| *x = NByte(value) |
| } |
| return nil |
| } |
| |
| type NUint16 uint16 |
| |
| func (NUint16) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NUint16"` |
| }) { |
| } |
| |
| func (x NUint16) VDLIsZero() bool { |
| return x == 0 |
| } |
| |
| func (x NUint16) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueUint(__VDLType_uint16_15, uint64(x)); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *NUint16) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueUint(16); { |
| case err != nil: |
| return err |
| default: |
| *x = NUint16(value) |
| } |
| return nil |
| } |
| |
| type NUint32 uint32 |
| |
| func (NUint32) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NUint32"` |
| }) { |
| } |
| |
| func (x NUint32) VDLIsZero() bool { |
| return x == 0 |
| } |
| |
| func (x NUint32) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueUint(__VDLType_uint32_16, uint64(x)); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *NUint32) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueUint(32); { |
| case err != nil: |
| return err |
| default: |
| *x = NUint32(value) |
| } |
| return nil |
| } |
| |
| type NUint64 uint64 |
| |
| func (NUint64) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NUint64"` |
| }) { |
| } |
| |
| func (x NUint64) VDLIsZero() bool { |
| return x == 0 |
| } |
| |
| func (x NUint64) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueUint(__VDLType_uint64_17, uint64(x)); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *NUint64) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueUint(64); { |
| case err != nil: |
| return err |
| default: |
| *x = NUint64(value) |
| } |
| return nil |
| } |
| |
| type NInt8 int8 |
| |
| func (NInt8) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NInt8"` |
| }) { |
| } |
| |
| func (x NInt8) VDLIsZero() bool { |
| return x == 0 |
| } |
| |
| func (x NInt8) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueInt(__VDLType_int8_18, int64(x)); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *NInt8) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueInt(8); { |
| case err != nil: |
| return err |
| default: |
| *x = NInt8(value) |
| } |
| return nil |
| } |
| |
| type NInt16 int16 |
| |
| func (NInt16) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NInt16"` |
| }) { |
| } |
| |
| func (x NInt16) VDLIsZero() bool { |
| return x == 0 |
| } |
| |
| func (x NInt16) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueInt(__VDLType_int16_19, int64(x)); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *NInt16) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueInt(16); { |
| case err != nil: |
| return err |
| default: |
| *x = NInt16(value) |
| } |
| return nil |
| } |
| |
| type NInt32 int32 |
| |
| func (NInt32) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NInt32"` |
| }) { |
| } |
| |
| func (x NInt32) VDLIsZero() bool { |
| return x == 0 |
| } |
| |
| func (x NInt32) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueInt(__VDLType_int32_20, int64(x)); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *NInt32) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueInt(32); { |
| case err != nil: |
| return err |
| default: |
| *x = NInt32(value) |
| } |
| return nil |
| } |
| |
| type NInt64 int64 |
| |
| func (NInt64) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NInt64"` |
| }) { |
| } |
| |
| func (x NInt64) VDLIsZero() bool { |
| return x == 0 |
| } |
| |
| func (x NInt64) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueInt(__VDLType_int64_21, int64(x)); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *NInt64) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueInt(64); { |
| case err != nil: |
| return err |
| default: |
| *x = NInt64(value) |
| } |
| return nil |
| } |
| |
| type NFloat32 float32 |
| |
| func (NFloat32) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NFloat32"` |
| }) { |
| } |
| |
| func (x NFloat32) VDLIsZero() bool { |
| return x == 0 |
| } |
| |
| func (x NFloat32) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueFloat(__VDLType_float32_22, float64(x)); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *NFloat32) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueFloat(32); { |
| case err != nil: |
| return err |
| default: |
| *x = NFloat32(value) |
| } |
| return nil |
| } |
| |
| type NFloat64 float64 |
| |
| func (NFloat64) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NFloat64"` |
| }) { |
| } |
| |
| func (x NFloat64) VDLIsZero() bool { |
| return x == 0 |
| } |
| |
| func (x NFloat64) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueFloat(__VDLType_float64_23, float64(x)); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *NFloat64) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueFloat(64); { |
| case err != nil: |
| return err |
| default: |
| *x = NFloat64(value) |
| } |
| return nil |
| } |
| |
| type NArray2Uint64 [2]uint64 |
| |
| func (NArray2Uint64) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NArray2Uint64"` |
| }) { |
| } |
| |
| func (x NArray2Uint64) VDLIsZero() bool { |
| return x == NArray2Uint64{} |
| } |
| |
| func (x NArray2Uint64) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_array_24); err != nil { |
| return err |
| } |
| for _, elem := range x { |
| if err := enc.NextEntryValueUint(vdl.Uint64Type, elem); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *NArray2Uint64) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_array_24); err != nil { |
| return err |
| } |
| for index := 0; index < 2; index++ { |
| switch done, elem, err := dec.NextEntryValueUint(64); { |
| case err != nil: |
| return err |
| case done: |
| return fmt.Errorf("short array, got len %d < 2 %T)", index, *x) |
| default: |
| x[index] = elem |
| } |
| } |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case !done: |
| return fmt.Errorf("long array, got len > 2 %T", *x) |
| } |
| return dec.FinishValue() |
| } |
| |
| type NListUint64 []uint64 |
| |
| func (NListUint64) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NListUint64"` |
| }) { |
| } |
| |
| func (x NListUint64) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x NListUint64) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_list_25); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for _, elem := range x { |
| if err := enc.NextEntryValueUint(vdl.Uint64Type, elem); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *NListUint64) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_list_25); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make(NListUint64, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, elem, err := dec.NextEntryValueUint(64); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| type NSetUint64 map[uint64]struct{} |
| |
| func (NSetUint64) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NSetUint64"` |
| }) { |
| } |
| |
| func (x NSetUint64) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x NSetUint64) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_set_26); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key := range x { |
| if err := enc.NextEntryValueUint(vdl.Uint64Type, key); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *NSetUint64) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_set_26); err != nil { |
| return err |
| } |
| var tmpMap NSetUint64 |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(NSetUint64, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueUint(64); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| if tmpMap == nil { |
| tmpMap = make(NSetUint64) |
| } |
| tmpMap[key] = struct{}{} |
| } |
| } |
| } |
| |
| type NMapUint64String map[uint64]string |
| |
| func (NMapUint64String) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NMapUint64String"` |
| }) { |
| } |
| |
| func (x NMapUint64String) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x NMapUint64String) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_map_27); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key, elem := range x { |
| if err := enc.NextEntryValueUint(vdl.Uint64Type, key); err != nil { |
| return err |
| } |
| if err := enc.WriteValueString(vdl.StringType, elem); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *NMapUint64String) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_map_27); err != nil { |
| return err |
| } |
| var tmpMap NMapUint64String |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(NMapUint64String, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueUint(64); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| var elem string |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| elem = value |
| } |
| if tmpMap == nil { |
| tmpMap = make(NMapUint64String) |
| } |
| tmpMap[key] = elem |
| } |
| } |
| } |
| |
| type NStruct struct { |
| A bool |
| B string |
| C int64 |
| } |
| |
| func (NStruct) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NStruct"` |
| }) { |
| } |
| |
| func (x NStruct) VDLIsZero() bool { |
| return x == NStruct{} |
| } |
| |
| func (x NStruct) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_28); err != nil { |
| return err |
| } |
| if x.A { |
| if err := enc.NextFieldValueBool(0, vdl.BoolType, 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 != 0 { |
| if err := enc.NextFieldValueInt(2, vdl.Int64Type, x.C); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *NStruct) VDLRead(dec vdl.Decoder) error { |
| *x = NStruct{} |
| if err := dec.StartValue(__VDLType_struct_28); 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 != __VDLType_struct_28 { |
| index = __VDLType_struct_28.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.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| x.A = value |
| } |
| case 1: |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| x.B = value |
| } |
| case 2: |
| switch value, err := dec.ReadValueInt(64); { |
| case err != nil: |
| return err |
| default: |
| x.C = value |
| } |
| } |
| } |
| } |
| |
| type NEnum int |
| |
| const ( |
| NEnumA NEnum = iota |
| NEnumB |
| NEnumC |
| ) |
| |
| // NEnumAll holds all labels for NEnum. |
| var NEnumAll = [...]NEnum{NEnumA, NEnumB, NEnumC} |
| |
| // NEnumFromString creates a NEnum from a string label. |
| func NEnumFromString(label string) (x NEnum, err error) { |
| err = x.Set(label) |
| return |
| } |
| |
| // Set assigns label to x. |
| func (x *NEnum) Set(label string) error { |
| switch label { |
| case "A", "a": |
| *x = NEnumA |
| return nil |
| case "B", "b": |
| *x = NEnumB |
| return nil |
| case "C", "c": |
| *x = NEnumC |
| return nil |
| } |
| *x = -1 |
| return fmt.Errorf("unknown label %q in types.NEnum", label) |
| } |
| |
| // String returns the string label of x. |
| func (x NEnum) String() string { |
| switch x { |
| case NEnumA: |
| return "A" |
| case NEnumB: |
| return "B" |
| case NEnumC: |
| return "C" |
| } |
| return "" |
| } |
| |
| func (NEnum) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NEnum"` |
| Enum struct{ A, B, C string } |
| }) { |
| } |
| |
| func (x NEnum) VDLIsZero() bool { |
| return x == NEnumA |
| } |
| |
| func (x NEnum) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueString(__VDLType_enum_29, x.String()); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *NEnum) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| if err := x.Set(value); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| |
| type ( |
| // NUnion represents any single field of the NUnion union type. |
| NUnion 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 NUnion union type. |
| __VDLReflect(__NUnionReflect) |
| VDLIsZero() bool |
| VDLWrite(vdl.Encoder) error |
| } |
| // NUnionA represents field A of the NUnion union type. |
| NUnionA struct{ Value bool } |
| // NUnionB represents field B of the NUnion union type. |
| NUnionB struct{ Value string } |
| // NUnionC represents field C of the NUnion union type. |
| NUnionC struct{ Value int64 } |
| // __NUnionReflect describes the NUnion union type. |
| __NUnionReflect struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.NUnion"` |
| Type NUnion |
| Union struct { |
| A NUnionA |
| B NUnionB |
| C NUnionC |
| } |
| } |
| ) |
| |
| func (x NUnionA) Index() int { return 0 } |
| func (x NUnionA) Interface() interface{} { return x.Value } |
| func (x NUnionA) Name() string { return "A" } |
| func (x NUnionA) __VDLReflect(__NUnionReflect) {} |
| |
| func (x NUnionB) Index() int { return 1 } |
| func (x NUnionB) Interface() interface{} { return x.Value } |
| func (x NUnionB) Name() string { return "B" } |
| func (x NUnionB) __VDLReflect(__NUnionReflect) {} |
| |
| func (x NUnionC) Index() int { return 2 } |
| func (x NUnionC) Interface() interface{} { return x.Value } |
| func (x NUnionC) Name() string { return "C" } |
| func (x NUnionC) __VDLReflect(__NUnionReflect) {} |
| |
| func (x NUnionA) VDLIsZero() bool { |
| return !x.Value |
| } |
| |
| func (x NUnionB) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x NUnionC) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x NUnionA) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_union_30); err != nil { |
| return err |
| } |
| if err := enc.NextFieldValueBool(0, vdl.BoolType, x.Value); err != nil { |
| return err |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x NUnionB) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_union_30); 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 NUnionC) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_union_30); err != nil { |
| return err |
| } |
| if err := enc.NextFieldValueInt(2, vdl.Int64Type, x.Value); err != nil { |
| return err |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func VDLReadNUnion(dec vdl.Decoder, x *NUnion) error { |
| if err := dec.StartValue(__VDLType_union_30); 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 != __VDLType_union_30 { |
| name := decType.Field(index).Name |
| index = __VDLType_union_30.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 NUnionA |
| switch value, err := dec.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| field.Value = value |
| } |
| *x = field |
| case 1: |
| var field NUnionB |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| field.Value = value |
| } |
| *x = field |
| case 2: |
| var field NUnionC |
| switch value, err := dec.ReadValueInt(64); { |
| 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() |
| } |
| |
| // Nested Custom Types |
| type MBool NBool |
| |
| func (MBool) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.MBool"` |
| }) { |
| } |
| |
| func (x MBool) VDLIsZero() bool { |
| return bool(!x) |
| } |
| |
| func (x MBool) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueBool(__VDLType_bool_31, bool(x)); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *MBool) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| *x = MBool(value) |
| } |
| return nil |
| } |
| |
| type MStruct struct { |
| A bool |
| B NBool |
| C MBool |
| D *NStruct |
| E *vdl.Type |
| F *vdl.Value |
| } |
| |
| func (MStruct) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.MStruct"` |
| }) { |
| } |
| |
| func (x MStruct) VDLIsZero() bool { |
| if x.A { |
| return false |
| } |
| if x.B { |
| return false |
| } |
| if x.C { |
| return false |
| } |
| if x.D != nil { |
| return false |
| } |
| if x.E != nil && x.E != vdl.AnyType { |
| return false |
| } |
| if x.F != nil && !x.F.VDLIsZero() { |
| return false |
| } |
| return true |
| } |
| |
| func (x MStruct) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_32); err != nil { |
| return err |
| } |
| if x.A { |
| if err := enc.NextFieldValueBool(0, vdl.BoolType, x.A); err != nil { |
| return err |
| } |
| } |
| if x.B { |
| if err := enc.NextFieldValueBool(1, __VDLType_bool_10, bool(x.B)); err != nil { |
| return err |
| } |
| } |
| if x.C { |
| if err := enc.NextFieldValueBool(2, __VDLType_bool_31, bool(x.C)); err != nil { |
| return err |
| } |
| } |
| if x.D != nil { |
| if err := enc.NextField(3); err != nil { |
| return err |
| } |
| enc.SetNextStartValueIsOptional() |
| if err := x.D.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.E != nil && x.E != vdl.AnyType { |
| if err := enc.NextFieldValueTypeObject(4, x.E); err != nil { |
| return err |
| } |
| } |
| if x.F != nil && !x.F.VDLIsZero() { |
| if err := enc.NextField(5); err != nil { |
| return err |
| } |
| if err := x.F.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *MStruct) VDLRead(dec vdl.Decoder) error { |
| *x = MStruct{ |
| E: vdl.AnyType, |
| F: vdl.ZeroValue(vdl.AnyType), |
| } |
| if err := dec.StartValue(__VDLType_struct_32); 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 != __VDLType_struct_32 { |
| index = __VDLType_struct_32.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.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| x.A = value |
| } |
| case 1: |
| switch value, err := dec.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| x.B = NBool(value) |
| } |
| case 2: |
| switch value, err := dec.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| x.C = MBool(value) |
| } |
| case 3: |
| if err := dec.StartValue(__VDLType_optional_33); err != nil { |
| return err |
| } |
| if dec.IsNil() { |
| x.D = nil |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| } else { |
| x.D = new(NStruct) |
| dec.IgnoreNextStartValue() |
| if err := x.D.VDLRead(dec); err != nil { |
| return err |
| } |
| } |
| case 4: |
| switch value, err := dec.ReadValueTypeObject(); { |
| case err != nil: |
| return err |
| default: |
| x.E = value |
| } |
| case 5: |
| x.F = new(vdl.Value) |
| if err := x.F.VDLRead(dec); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| type MList []NListUint64 |
| |
| func (MList) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.MList"` |
| }) { |
| } |
| |
| func (x MList) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x MList) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_list_34); 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 err := elem.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *MList) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_list_34); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make(MList, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| var elem NListUint64 |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| type MMap map[NFloat32]NListUint64 |
| |
| func (MMap) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.MMap"` |
| }) { |
| } |
| |
| func (x MMap) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x MMap) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_map_35); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key, elem := range x { |
| if err := enc.NextEntryValueFloat(__VDLType_float32_22, float64(key)); err != nil { |
| return err |
| } |
| if err := elem.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *MMap) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_map_35); err != nil { |
| return err |
| } |
| var tmpMap MMap |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(MMap, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueFloat(32); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| var elem NListUint64 |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| if tmpMap == nil { |
| tmpMap = make(MMap) |
| } |
| tmpMap[NFloat32(key)] = elem |
| } |
| } |
| } |
| |
| type MByteSlice []byte |
| |
| func (MByteSlice) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.MByteSlice"` |
| }) { |
| } |
| |
| func (x MByteSlice) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x MByteSlice) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueBytes(__VDLType_list_36, []byte(x)); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *MByteSlice) VDLRead(dec vdl.Decoder) error { |
| var bytes []byte |
| if err := dec.ReadValueBytes(-1, &bytes); err != nil { |
| return err |
| } |
| *x = bytes |
| return nil |
| } |
| |
| type MInt8Slice []int8 |
| |
| func (MInt8Slice) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.MInt8Slice"` |
| }) { |
| } |
| |
| func (x MInt8Slice) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x MInt8Slice) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_list_37); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for _, elem := range x { |
| if err := enc.NextEntryValueInt(vdl.Int8Type, int64(elem)); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *MInt8Slice) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_list_37); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make(MInt8Slice, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, elem, err := dec.NextEntryValueInt(8); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| *x = append(*x, int8(elem)) |
| } |
| } |
| } |
| |
| // Recursive Type Definitions |
| type RecA []RecA |
| |
| func (RecA) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.RecA"` |
| }) { |
| } |
| |
| func (x RecA) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x RecA) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_list_38); 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 err := elem.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *RecA) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_list_38); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make(RecA, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| var elem RecA |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| type RecY []RecX |
| |
| func (RecY) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.RecY"` |
| }) { |
| } |
| |
| func (x RecY) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x RecY) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_list_39); 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 err := elem.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *RecY) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_list_39); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make(RecY, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| var elem RecX |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| type RecX []RecY |
| |
| func (RecX) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.RecX"` |
| }) { |
| } |
| |
| func (x RecX) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x RecX) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_list_40); 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 err := elem.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *RecX) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_list_40); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make(RecX, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| var elem RecY |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| type Rec4 []Rec1 |
| |
| func (Rec4) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.Rec4"` |
| }) { |
| } |
| |
| func (x Rec4) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x Rec4) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_list_41); 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 err := elem.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *Rec4) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_list_41); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make(Rec4, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| var elem Rec1 |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| type Rec3 []Rec4 |
| |
| func (Rec3) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.Rec3"` |
| }) { |
| } |
| |
| func (x Rec3) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x Rec3) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_list_43); 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 err := elem.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *Rec3) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_list_43); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make(Rec3, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| var elem Rec4 |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| type Rec2 []Rec3 |
| |
| func (Rec2) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.Rec2"` |
| }) { |
| } |
| |
| func (x Rec2) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x Rec2) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_list_44); 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 err := elem.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *Rec2) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_list_44); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make(Rec2, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| var elem Rec3 |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| type Rec1 []Rec2 |
| |
| func (Rec1) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.Rec1"` |
| }) { |
| } |
| |
| func (x Rec1) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x Rec1) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_list_42); 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 err := elem.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *Rec1) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_list_42); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make(Rec1, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| var elem Rec2 |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| type RecStruct struct { |
| A *RecStruct |
| } |
| |
| func (RecStruct) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.RecStruct"` |
| }) { |
| } |
| |
| func (x RecStruct) VDLIsZero() bool { |
| return x == RecStruct{} |
| } |
| |
| func (x RecStruct) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_45); err != nil { |
| return err |
| } |
| if x.A != nil { |
| if err := enc.NextField(0); err != nil { |
| return err |
| } |
| enc.SetNextStartValueIsOptional() |
| if err := x.A.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *RecStruct) VDLRead(dec vdl.Decoder) error { |
| *x = RecStruct{} |
| if err := dec.StartValue(__VDLType_struct_45); 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 != __VDLType_struct_45 { |
| index = __VDLType_struct_45.FieldIndexByName(decType.Field(index).Name) |
| if index == -1 { |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| continue |
| } |
| } |
| switch index { |
| case 0: |
| if err := dec.StartValue(__VDLType_optional_46); err != nil { |
| return err |
| } |
| if dec.IsNil() { |
| x.A = nil |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| } else { |
| x.A = new(RecStruct) |
| dec.IgnoreNextStartValue() |
| if err := x.A.VDLRead(dec); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| } |
| |
| type Rec1234 struct { |
| R1 Rec1 |
| R2 Rec2 |
| R3 Rec3 |
| R4 Rec4 |
| } |
| |
| func (Rec1234) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.Rec1234"` |
| }) { |
| } |
| |
| func (x Rec1234) VDLIsZero() bool { |
| if len(x.R1) != 0 { |
| return false |
| } |
| if len(x.R2) != 0 { |
| return false |
| } |
| if len(x.R3) != 0 { |
| return false |
| } |
| if len(x.R4) != 0 { |
| return false |
| } |
| return true |
| } |
| |
| func (x Rec1234) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_47); err != nil { |
| return err |
| } |
| if len(x.R1) != 0 { |
| if err := enc.NextField(0); err != nil { |
| return err |
| } |
| if err := x.R1.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if len(x.R2) != 0 { |
| if err := enc.NextField(1); err != nil { |
| return err |
| } |
| if err := x.R2.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if len(x.R3) != 0 { |
| if err := enc.NextField(2); err != nil { |
| return err |
| } |
| if err := x.R3.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if len(x.R4) != 0 { |
| if err := enc.NextField(3); err != nil { |
| return err |
| } |
| if err := x.R4.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *Rec1234) VDLRead(dec vdl.Decoder) error { |
| *x = Rec1234{} |
| if err := dec.StartValue(__VDLType_struct_47); 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 != __VDLType_struct_47 { |
| index = __VDLType_struct_47.FieldIndexByName(decType.Field(index).Name) |
| if index == -1 { |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| continue |
| } |
| } |
| switch index { |
| case 0: |
| if err := x.R1.VDLRead(dec); err != nil { |
| return err |
| } |
| case 1: |
| if err := x.R2.VDLRead(dec); err != nil { |
| return err |
| } |
| case 2: |
| if err := x.R3.VDLRead(dec); err != nil { |
| return err |
| } |
| case 3: |
| if err := x.R4.VDLRead(dec); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| type Rec1234A struct { |
| A []Rec1234A |
| Rec1234 []Rec1234 |
| } |
| |
| func (Rec1234A) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.Rec1234A"` |
| }) { |
| } |
| |
| func (x Rec1234A) VDLIsZero() bool { |
| if len(x.A) != 0 { |
| return false |
| } |
| if len(x.Rec1234) != 0 { |
| return false |
| } |
| return true |
| } |
| |
| func (x Rec1234A) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_48); err != nil { |
| return err |
| } |
| if len(x.A) != 0 { |
| if err := enc.NextField(0); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_list_7(enc, x.A); err != nil { |
| return err |
| } |
| } |
| if len(x.Rec1234) != 0 { |
| if err := enc.NextField(1); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_list_8(enc, x.Rec1234); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func __VDLWriteAnon_list_7(enc vdl.Encoder, x []Rec1234A) error { |
| if err := enc.StartValue(__VDLType_list_49); 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 err := elem.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func __VDLWriteAnon_list_8(enc vdl.Encoder, x []Rec1234) error { |
| if err := enc.StartValue(__VDLType_list_50); 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 err := elem.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *Rec1234A) VDLRead(dec vdl.Decoder) error { |
| *x = Rec1234A{} |
| if err := dec.StartValue(__VDLType_struct_48); 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 != __VDLType_struct_48 { |
| index = __VDLType_struct_48.FieldIndexByName(decType.Field(index).Name) |
| if index == -1 { |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| continue |
| } |
| } |
| switch index { |
| case 0: |
| if err := __VDLReadAnon_list_7(dec, &x.A); err != nil { |
| return err |
| } |
| case 1: |
| if err := __VDLReadAnon_list_8(dec, &x.Rec1234); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| func __VDLReadAnon_list_7(dec vdl.Decoder, x *[]Rec1234A) error { |
| if err := dec.StartValue(__VDLType_list_49); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make([]Rec1234A, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| var elem Rec1234A |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| func __VDLReadAnon_list_8(dec vdl.Decoder, x *[]Rec1234) error { |
| if err := dec.StartValue(__VDLType_list_50); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make([]Rec1234, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| var elem Rec1234 |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| type Rec1234B struct { |
| B []Rec1234B |
| Rec1234 []Rec1234 |
| } |
| |
| func (Rec1234B) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.Rec1234B"` |
| }) { |
| } |
| |
| func (x Rec1234B) VDLIsZero() bool { |
| if len(x.B) != 0 { |
| return false |
| } |
| if len(x.Rec1234) != 0 { |
| return false |
| } |
| return true |
| } |
| |
| func (x Rec1234B) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_51); err != nil { |
| return err |
| } |
| if len(x.B) != 0 { |
| if err := enc.NextField(0); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_list_9(enc, x.B); err != nil { |
| return err |
| } |
| } |
| if len(x.Rec1234) != 0 { |
| if err := enc.NextField(1); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_list_8(enc, x.Rec1234); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func __VDLWriteAnon_list_9(enc vdl.Encoder, x []Rec1234B) error { |
| if err := enc.StartValue(__VDLType_list_52); 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 err := elem.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *Rec1234B) VDLRead(dec vdl.Decoder) error { |
| *x = Rec1234B{} |
| if err := dec.StartValue(__VDLType_struct_51); 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 != __VDLType_struct_51 { |
| index = __VDLType_struct_51.FieldIndexByName(decType.Field(index).Name) |
| if index == -1 { |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| continue |
| } |
| } |
| switch index { |
| case 0: |
| if err := __VDLReadAnon_list_9(dec, &x.B); err != nil { |
| return err |
| } |
| case 1: |
| if err := __VDLReadAnon_list_8(dec, &x.Rec1234); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| func __VDLReadAnon_list_9(dec vdl.Decoder, x *[]Rec1234B) error { |
| if err := dec.StartValue(__VDLType_list_52); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make([]Rec1234B, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| var elem Rec1234B |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| type Rec1234All struct { |
| A Rec1234A |
| B Rec1234B |
| } |
| |
| func (Rec1234All) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.Rec1234All"` |
| }) { |
| } |
| |
| func (x Rec1234All) VDLIsZero() bool { |
| if !x.A.VDLIsZero() { |
| return false |
| } |
| if !x.B.VDLIsZero() { |
| return false |
| } |
| return true |
| } |
| |
| func (x Rec1234All) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_53); err != nil { |
| return err |
| } |
| if !x.A.VDLIsZero() { |
| if err := enc.NextField(0); err != nil { |
| return err |
| } |
| if err := x.A.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if !x.B.VDLIsZero() { |
| if err := enc.NextField(1); err != nil { |
| return err |
| } |
| if err := x.B.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *Rec1234All) VDLRead(dec vdl.Decoder) error { |
| *x = Rec1234All{} |
| if err := dec.StartValue(__VDLType_struct_53); 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 != __VDLType_struct_53 { |
| index = __VDLType_struct_53.FieldIndexByName(decType.Field(index).Name) |
| if index == -1 { |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| continue |
| } |
| } |
| switch index { |
| case 0: |
| if err := x.A.VDLRead(dec); err != nil { |
| return err |
| } |
| case 1: |
| if err := x.B.VDLRead(dec); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| // Additional types for compatibility and conversion checks |
| type ListString []string |
| |
| func (ListString) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.ListString"` |
| }) { |
| } |
| |
| func (x ListString) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x ListString) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_list_54); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for _, elem := range x { |
| if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *ListString) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_list_54); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make(ListString, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, elem, err := dec.NextEntryValueString(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| type Array3String [3]string |
| |
| func (Array3String) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.Array3String"` |
| }) { |
| } |
| |
| func (x Array3String) VDLIsZero() bool { |
| return x == Array3String{} |
| } |
| |
| func (x Array3String) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_array_55); err != nil { |
| return err |
| } |
| for _, elem := range x { |
| if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *Array3String) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_array_55); err != nil { |
| return err |
| } |
| for index := 0; index < 3; index++ { |
| switch done, elem, err := dec.NextEntryValueString(); { |
| case err != nil: |
| return err |
| case done: |
| return fmt.Errorf("short array, got len %d < 3 %T)", index, *x) |
| default: |
| x[index] = 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 Array4String [4]string |
| |
| func (Array4String) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.Array4String"` |
| }) { |
| } |
| |
| func (x Array4String) VDLIsZero() bool { |
| return x == Array4String{} |
| } |
| |
| func (x Array4String) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_array_56); err != nil { |
| return err |
| } |
| for _, elem := range x { |
| if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *Array4String) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_array_56); err != nil { |
| return err |
| } |
| for index := 0; index < 4; index++ { |
| switch done, elem, err := dec.NextEntryValueString(); { |
| case err != nil: |
| return err |
| case done: |
| return fmt.Errorf("short array, got len %d < 4 %T)", index, *x) |
| default: |
| x[index] = elem |
| } |
| } |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case !done: |
| return fmt.Errorf("long array, got len > 4 %T", *x) |
| } |
| return dec.FinishValue() |
| } |
| |
| type AbcStruct struct { |
| A bool |
| B string |
| C int64 |
| } |
| |
| func (AbcStruct) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.AbcStruct"` |
| }) { |
| } |
| |
| func (x AbcStruct) VDLIsZero() bool { |
| return x == AbcStruct{} |
| } |
| |
| func (x AbcStruct) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_57); err != nil { |
| return err |
| } |
| if x.A { |
| if err := enc.NextFieldValueBool(0, vdl.BoolType, 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 != 0 { |
| if err := enc.NextFieldValueInt(2, vdl.Int64Type, x.C); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *AbcStruct) VDLRead(dec vdl.Decoder) error { |
| *x = AbcStruct{} |
| if err := dec.StartValue(__VDLType_struct_57); 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 != __VDLType_struct_57 { |
| index = __VDLType_struct_57.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.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| x.A = value |
| } |
| case 1: |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| x.B = value |
| } |
| case 2: |
| switch value, err := dec.ReadValueInt(64); { |
| case err != nil: |
| return err |
| default: |
| x.C = value |
| } |
| } |
| } |
| } |
| |
| type AdeStruct struct { |
| A bool |
| D *vdl.Value |
| E *vdl.Type |
| } |
| |
| func (AdeStruct) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.AdeStruct"` |
| }) { |
| } |
| |
| func (x AdeStruct) VDLIsZero() bool { |
| if x.A { |
| return false |
| } |
| if x.D != nil && !x.D.VDLIsZero() { |
| return false |
| } |
| if x.E != nil && x.E != vdl.AnyType { |
| return false |
| } |
| return true |
| } |
| |
| func (x AdeStruct) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_58); err != nil { |
| return err |
| } |
| if x.A { |
| if err := enc.NextFieldValueBool(0, vdl.BoolType, x.A); err != nil { |
| return err |
| } |
| } |
| if x.D != nil && !x.D.VDLIsZero() { |
| if err := enc.NextField(1); err != nil { |
| return err |
| } |
| if err := x.D.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.E != nil && x.E != vdl.AnyType { |
| if err := enc.NextFieldValueTypeObject(2, x.E); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *AdeStruct) VDLRead(dec vdl.Decoder) error { |
| *x = AdeStruct{ |
| D: vdl.ZeroValue(vdl.AnyType), |
| E: vdl.AnyType, |
| } |
| if err := dec.StartValue(__VDLType_struct_58); 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 != __VDLType_struct_58 { |
| index = __VDLType_struct_58.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.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| x.A = value |
| } |
| case 1: |
| x.D = new(vdl.Value) |
| if err := x.D.VDLRead(dec); err != nil { |
| return err |
| } |
| case 2: |
| switch value, err := dec.ReadValueTypeObject(); { |
| case err != nil: |
| return err |
| default: |
| x.E = value |
| } |
| } |
| } |
| } |
| |
| type XyzStruct struct { |
| X bool |
| Y MBool |
| Z string |
| } |
| |
| func (XyzStruct) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.XyzStruct"` |
| }) { |
| } |
| |
| func (x XyzStruct) VDLIsZero() bool { |
| return x == XyzStruct{} |
| } |
| |
| func (x XyzStruct) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_59); err != nil { |
| return err |
| } |
| if x.X { |
| if err := enc.NextFieldValueBool(0, vdl.BoolType, x.X); err != nil { |
| return err |
| } |
| } |
| if x.Y { |
| if err := enc.NextFieldValueBool(1, __VDLType_bool_31, bool(x.Y)); err != nil { |
| return err |
| } |
| } |
| if x.Z != "" { |
| if err := enc.NextFieldValueString(2, vdl.StringType, x.Z); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *XyzStruct) VDLRead(dec vdl.Decoder) error { |
| *x = XyzStruct{} |
| if err := dec.StartValue(__VDLType_struct_59); 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 != __VDLType_struct_59 { |
| index = __VDLType_struct_59.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.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| x.X = value |
| } |
| case 1: |
| switch value, err := dec.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| x.Y = MBool(value) |
| } |
| case 2: |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| x.Z = value |
| } |
| } |
| } |
| } |
| |
| type YzStruct struct { |
| Y NBool |
| Z NString |
| } |
| |
| func (YzStruct) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.YzStruct"` |
| }) { |
| } |
| |
| func (x YzStruct) VDLIsZero() bool { |
| return x == YzStruct{} |
| } |
| |
| func (x YzStruct) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_60); err != nil { |
| return err |
| } |
| if x.Y { |
| if err := enc.NextFieldValueBool(0, __VDLType_bool_10, bool(x.Y)); err != nil { |
| return err |
| } |
| } |
| if x.Z != "" { |
| if err := enc.NextFieldValueString(1, __VDLType_string_11, string(x.Z)); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *YzStruct) VDLRead(dec vdl.Decoder) error { |
| *x = YzStruct{} |
| if err := dec.StartValue(__VDLType_struct_60); 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 != __VDLType_struct_60 { |
| index = __VDLType_struct_60.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.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| x.Y = NBool(value) |
| } |
| case 1: |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| x.Z = NString(value) |
| } |
| } |
| } |
| } |
| |
| type ZStruct struct { |
| Z string |
| } |
| |
| func (ZStruct) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.ZStruct"` |
| }) { |
| } |
| |
| func (x ZStruct) VDLIsZero() bool { |
| return x == ZStruct{} |
| } |
| |
| func (x ZStruct) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_61); err != nil { |
| return err |
| } |
| if x.Z != "" { |
| if err := enc.NextFieldValueString(0, vdl.StringType, x.Z); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *ZStruct) VDLRead(dec vdl.Decoder) error { |
| *x = ZStruct{} |
| if err := dec.StartValue(__VDLType_struct_61); 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 != __VDLType_struct_61 { |
| index = __VDLType_struct_61.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.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| x.Z = value |
| } |
| } |
| } |
| } |
| |
| type MapOnlyStruct struct { |
| Key1 int64 |
| Key2 uint32 |
| } |
| |
| func (MapOnlyStruct) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.MapOnlyStruct"` |
| }) { |
| } |
| |
| func (x MapOnlyStruct) VDLIsZero() bool { |
| return x == MapOnlyStruct{} |
| } |
| |
| func (x MapOnlyStruct) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_62); err != nil { |
| return err |
| } |
| if x.Key1 != 0 { |
| if err := enc.NextFieldValueInt(0, vdl.Int64Type, x.Key1); err != nil { |
| return err |
| } |
| } |
| if x.Key2 != 0 { |
| if err := enc.NextFieldValueUint(1, vdl.Uint32Type, uint64(x.Key2)); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *MapOnlyStruct) VDLRead(dec vdl.Decoder) error { |
| *x = MapOnlyStruct{} |
| if err := dec.StartValue(__VDLType_struct_62); 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 != __VDLType_struct_62 { |
| index = __VDLType_struct_62.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(64); { |
| case err != nil: |
| return err |
| default: |
| x.Key1 = value |
| } |
| case 1: |
| switch value, err := dec.ReadValueUint(32); { |
| case err != nil: |
| return err |
| default: |
| x.Key2 = uint32(value) |
| } |
| } |
| } |
| } |
| |
| type StructOnlyMap map[string]uint64 |
| |
| func (StructOnlyMap) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.StructOnlyMap"` |
| }) { |
| } |
| |
| func (x StructOnlyMap) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x StructOnlyMap) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_map_63); 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.WriteValueUint(vdl.Uint64Type, elem); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *StructOnlyMap) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_map_63); err != nil { |
| return err |
| } |
| var tmpMap StructOnlyMap |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(StructOnlyMap, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueString(); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| var elem uint64 |
| switch value, err := dec.ReadValueUint(64); { |
| case err != nil: |
| return err |
| default: |
| elem = value |
| } |
| if tmpMap == nil { |
| tmpMap = make(StructOnlyMap) |
| } |
| tmpMap[key] = elem |
| } |
| } |
| } |
| |
| type MapSetStruct struct { |
| Feat bool |
| Tire bool |
| Eel bool |
| } |
| |
| func (MapSetStruct) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.MapSetStruct"` |
| }) { |
| } |
| |
| func (x MapSetStruct) VDLIsZero() bool { |
| return x == MapSetStruct{} |
| } |
| |
| func (x MapSetStruct) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_64); err != nil { |
| return err |
| } |
| if x.Feat { |
| if err := enc.NextFieldValueBool(0, vdl.BoolType, x.Feat); err != nil { |
| return err |
| } |
| } |
| if x.Tire { |
| if err := enc.NextFieldValueBool(1, vdl.BoolType, x.Tire); err != nil { |
| return err |
| } |
| } |
| if x.Eel { |
| if err := enc.NextFieldValueBool(2, vdl.BoolType, x.Eel); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *MapSetStruct) VDLRead(dec vdl.Decoder) error { |
| *x = MapSetStruct{} |
| if err := dec.StartValue(__VDLType_struct_64); 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 != __VDLType_struct_64 { |
| index = __VDLType_struct_64.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.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| x.Feat = value |
| } |
| case 1: |
| switch value, err := dec.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| x.Tire = value |
| } |
| case 2: |
| switch value, err := dec.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| x.Eel = value |
| } |
| } |
| } |
| } |
| |
| type SetStructMap map[string]bool |
| |
| func (SetStructMap) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.SetStructMap"` |
| }) { |
| } |
| |
| func (x SetStructMap) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x SetStructMap) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_map_65); 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 *SetStructMap) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_map_65); err != nil { |
| return err |
| } |
| var tmpMap SetStructMap |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(SetStructMap, 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(SetStructMap) |
| } |
| tmpMap[key] = elem |
| } |
| } |
| } |
| |
| type MapStructSet map[string]struct{} |
| |
| func (MapStructSet) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.MapStructSet"` |
| }) { |
| } |
| |
| func (x MapStructSet) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x MapStructSet) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_set_66); 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 *MapStructSet) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_set_66); err != nil { |
| return err |
| } |
| var tmpMap MapStructSet |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(MapStructSet, 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(MapStructSet) |
| } |
| tmpMap[key] = struct{}{} |
| } |
| } |
| } |
| |
| type SetOnlyMap map[float64]bool |
| |
| func (SetOnlyMap) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.SetOnlyMap"` |
| }) { |
| } |
| |
| func (x SetOnlyMap) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x SetOnlyMap) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_map_67); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key, elem := range x { |
| if err := enc.NextEntryValueFloat(vdl.Float64Type, 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 *SetOnlyMap) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_map_67); err != nil { |
| return err |
| } |
| var tmpMap SetOnlyMap |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(SetOnlyMap, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueFloat(64); { |
| 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(SetOnlyMap) |
| } |
| tmpMap[key] = elem |
| } |
| } |
| } |
| |
| type SometimesSetMap map[float64]*vdl.Value |
| |
| func (SometimesSetMap) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.SometimesSetMap"` |
| }) { |
| } |
| |
| func (x SometimesSetMap) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x SometimesSetMap) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_map_68); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key, elem := range x { |
| if err := enc.NextEntryValueFloat(vdl.Float64Type, key); 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 *SometimesSetMap) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_map_68); err != nil { |
| return err |
| } |
| var tmpMap SometimesSetMap |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(SometimesSetMap, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueFloat(64); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| var elem *vdl.Value |
| elem = new(vdl.Value) |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| if tmpMap == nil { |
| tmpMap = make(SometimesSetMap) |
| } |
| tmpMap[key] = elem |
| } |
| } |
| } |
| |
| type MapOnlySet map[float64]struct{} |
| |
| func (MapOnlySet) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.MapOnlySet"` |
| }) { |
| } |
| |
| func (x MapOnlySet) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x MapOnlySet) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_set_69); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key := range x { |
| if err := enc.NextEntryValueFloat(vdl.Float64Type, key); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *MapOnlySet) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_set_69); err != nil { |
| return err |
| } |
| var tmpMap MapOnlySet |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(MapOnlySet, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueFloat(64); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| if tmpMap == nil { |
| tmpMap = make(MapOnlySet) |
| } |
| tmpMap[key] = struct{}{} |
| } |
| } |
| } |
| |
| type SetOnlyA map[bool]struct{} |
| |
| func (SetOnlyA) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.SetOnlyA"` |
| }) { |
| } |
| |
| func (x SetOnlyA) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x SetOnlyA) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_set_70); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key := range x { |
| if err := enc.NextEntryValueBool(vdl.BoolType, key); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *SetOnlyA) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_set_70); err != nil { |
| return err |
| } |
| var tmpMap SetOnlyA |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(SetOnlyA, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueBool(); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| if tmpMap == nil { |
| tmpMap = make(SetOnlyA) |
| } |
| tmpMap[key] = struct{}{} |
| } |
| } |
| } |
| |
| type SetOnlyA2 map[NBool]struct{} |
| |
| func (SetOnlyA2) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.SetOnlyA2"` |
| }) { |
| } |
| |
| func (x SetOnlyA2) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x SetOnlyA2) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_set_71); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key := range x { |
| if err := enc.NextEntryValueBool(__VDLType_bool_10, bool(key)); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *SetOnlyA2) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_set_71); err != nil { |
| return err |
| } |
| var tmpMap SetOnlyA2 |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(SetOnlyA2, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueBool(); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| if tmpMap == nil { |
| tmpMap = make(SetOnlyA2) |
| } |
| tmpMap[NBool(key)] = struct{}{} |
| } |
| } |
| } |
| |
| type SetOnlyB map[int16]struct{} |
| |
| func (SetOnlyB) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.SetOnlyB"` |
| }) { |
| } |
| |
| func (x SetOnlyB) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x SetOnlyB) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_set_72); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key := range x { |
| if err := enc.NextEntryValueInt(vdl.Int16Type, int64(key)); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *SetOnlyB) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_set_72); err != nil { |
| return err |
| } |
| var tmpMap SetOnlyB |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(SetOnlyB, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueInt(16); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| if tmpMap == nil { |
| tmpMap = make(SetOnlyB) |
| } |
| tmpMap[int16(key)] = struct{}{} |
| } |
| } |
| } |
| |
| type SetOnlyB2 map[NInt16]struct{} |
| |
| func (SetOnlyB2) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.SetOnlyB2"` |
| }) { |
| } |
| |
| func (x SetOnlyB2) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x SetOnlyB2) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_set_73); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key := range x { |
| if err := enc.NextEntryValueInt(__VDLType_int16_19, int64(key)); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *SetOnlyB2) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_set_73); err != nil { |
| return err |
| } |
| var tmpMap SetOnlyB2 |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(SetOnlyB2, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueInt(16); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| if tmpMap == nil { |
| tmpMap = make(SetOnlyB2) |
| } |
| tmpMap[NInt16(key)] = struct{}{} |
| } |
| } |
| } |
| |
| type MapOnlyA map[uint32]uint32 |
| |
| func (MapOnlyA) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.MapOnlyA"` |
| }) { |
| } |
| |
| func (x MapOnlyA) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x MapOnlyA) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_map_74); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key, elem := range x { |
| if err := enc.NextEntryValueUint(vdl.Uint32Type, uint64(key)); err != nil { |
| return err |
| } |
| if err := enc.WriteValueUint(vdl.Uint32Type, uint64(elem)); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *MapOnlyA) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_map_74); err != nil { |
| return err |
| } |
| var tmpMap MapOnlyA |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(MapOnlyA, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueUint(32); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| var elem uint32 |
| switch value, err := dec.ReadValueUint(32); { |
| case err != nil: |
| return err |
| default: |
| elem = uint32(value) |
| } |
| if tmpMap == nil { |
| tmpMap = make(MapOnlyA) |
| } |
| tmpMap[uint32(key)] = elem |
| } |
| } |
| } |
| |
| type MapOnlyA2 map[int64]float64 |
| |
| func (MapOnlyA2) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.MapOnlyA2"` |
| }) { |
| } |
| |
| func (x MapOnlyA2) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x MapOnlyA2) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_map_75); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key, elem := range x { |
| if err := enc.NextEntryValueInt(vdl.Int64Type, key); err != nil { |
| return err |
| } |
| if err := enc.WriteValueFloat(vdl.Float64Type, elem); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *MapOnlyA2) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_map_75); err != nil { |
| return err |
| } |
| var tmpMap MapOnlyA2 |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(MapOnlyA2, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueInt(64); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| var elem float64 |
| switch value, err := dec.ReadValueFloat(64); { |
| case err != nil: |
| return err |
| default: |
| elem = value |
| } |
| if tmpMap == nil { |
| tmpMap = make(MapOnlyA2) |
| } |
| tmpMap[key] = elem |
| } |
| } |
| } |
| |
| type MapOnlyB map[bool]string |
| |
| func (MapOnlyB) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.MapOnlyB"` |
| }) { |
| } |
| |
| func (x MapOnlyB) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x MapOnlyB) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_map_76); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key, elem := range x { |
| if err := enc.NextEntryValueBool(vdl.BoolType, key); err != nil { |
| return err |
| } |
| if err := enc.WriteValueString(vdl.StringType, elem); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *MapOnlyB) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_map_76); err != nil { |
| return err |
| } |
| var tmpMap MapOnlyB |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(MapOnlyB, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueBool(); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| var elem string |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| elem = value |
| } |
| if tmpMap == nil { |
| tmpMap = make(MapOnlyB) |
| } |
| tmpMap[key] = elem |
| } |
| } |
| } |
| |
| type MapOnlyB2 map[NBool]NString |
| |
| func (MapOnlyB2) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.MapOnlyB2"` |
| }) { |
| } |
| |
| func (x MapOnlyB2) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x MapOnlyB2) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_map_77); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key, elem := range x { |
| if err := enc.NextEntryValueBool(__VDLType_bool_10, bool(key)); err != nil { |
| return err |
| } |
| if err := enc.WriteValueString(__VDLType_string_11, string(elem)); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *MapOnlyB2) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_map_77); err != nil { |
| return err |
| } |
| var tmpMap MapOnlyB2 |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(MapOnlyB2, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueBool(); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| var elem NString |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| elem = NString(value) |
| } |
| if tmpMap == nil { |
| tmpMap = make(MapOnlyB2) |
| } |
| tmpMap[NBool(key)] = elem |
| } |
| } |
| } |
| |
| type ( |
| // BdeUnion represents any single field of the BdeUnion union type. |
| BdeUnion 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 BdeUnion union type. |
| __VDLReflect(__BdeUnionReflect) |
| VDLIsZero() bool |
| VDLWrite(vdl.Encoder) error |
| } |
| // BdeUnionB represents field B of the BdeUnion union type. |
| BdeUnionB struct{ Value string } |
| // BdeUnionD represents field D of the BdeUnion union type. |
| BdeUnionD struct{ Value *vdl.Value } |
| // BdeUnionE represents field E of the BdeUnion union type. |
| BdeUnionE struct{ Value *vdl.Type } |
| // __BdeUnionReflect describes the BdeUnion union type. |
| __BdeUnionReflect struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.BdeUnion"` |
| Type BdeUnion |
| Union struct { |
| B BdeUnionB |
| D BdeUnionD |
| E BdeUnionE |
| } |
| } |
| ) |
| |
| func (x BdeUnionB) Index() int { return 0 } |
| func (x BdeUnionB) Interface() interface{} { return x.Value } |
| func (x BdeUnionB) Name() string { return "B" } |
| func (x BdeUnionB) __VDLReflect(__BdeUnionReflect) {} |
| |
| func (x BdeUnionD) Index() int { return 1 } |
| func (x BdeUnionD) Interface() interface{} { return x.Value } |
| func (x BdeUnionD) Name() string { return "D" } |
| func (x BdeUnionD) __VDLReflect(__BdeUnionReflect) {} |
| |
| func (x BdeUnionE) Index() int { return 2 } |
| func (x BdeUnionE) Interface() interface{} { return x.Value } |
| func (x BdeUnionE) Name() string { return "E" } |
| func (x BdeUnionE) __VDLReflect(__BdeUnionReflect) {} |
| |
| func (x BdeUnionB) VDLIsZero() bool { |
| return x.Value == "" |
| } |
| |
| func (x BdeUnionD) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x BdeUnionE) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x BdeUnionB) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_union_78); err != nil { |
| return err |
| } |
| if err := enc.NextFieldValueString(0, vdl.StringType, x.Value); err != nil { |
| return err |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x BdeUnionD) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_union_78); err != nil { |
| return err |
| } |
| if err := enc.NextField(1); err != nil { |
| return err |
| } |
| if x.Value == nil { |
| if err := enc.NilValue(vdl.AnyType); err != nil { |
| return err |
| } |
| } else { |
| if err := x.Value.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x BdeUnionE) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_union_78); err != nil { |
| return err |
| } |
| if err := enc.NextFieldValueTypeObject(2, x.Value); err != nil { |
| return err |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func VDLReadBdeUnion(dec vdl.Decoder, x *BdeUnion) error { |
| if err := dec.StartValue(__VDLType_union_78); 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 != __VDLType_union_78 { |
| name := decType.Field(index).Name |
| index = __VDLType_union_78.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 BdeUnionB |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| field.Value = value |
| } |
| *x = field |
| case 1: |
| var field BdeUnionD |
| field.Value = new(vdl.Value) |
| if err := field.Value.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = field |
| case 2: |
| var field BdeUnionE |
| switch value, err := dec.ReadValueTypeObject(); { |
| 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 BrieEnum int |
| |
| const ( |
| BrieEnumGlee BrieEnum = iota |
| BrieEnumBrie |
| BrieEnumThree |
| ) |
| |
| // BrieEnumAll holds all labels for BrieEnum. |
| var BrieEnumAll = [...]BrieEnum{BrieEnumGlee, BrieEnumBrie, BrieEnumThree} |
| |
| // BrieEnumFromString creates a BrieEnum from a string label. |
| func BrieEnumFromString(label string) (x BrieEnum, err error) { |
| err = x.Set(label) |
| return |
| } |
| |
| // Set assigns label to x. |
| func (x *BrieEnum) Set(label string) error { |
| switch label { |
| case "Glee", "glee": |
| *x = BrieEnumGlee |
| return nil |
| case "Brie", "brie": |
| *x = BrieEnumBrie |
| return nil |
| case "Three", "three": |
| *x = BrieEnumThree |
| return nil |
| } |
| *x = -1 |
| return fmt.Errorf("unknown label %q in types.BrieEnum", label) |
| } |
| |
| // String returns the string label of x. |
| func (x BrieEnum) String() string { |
| switch x { |
| case BrieEnumGlee: |
| return "Glee" |
| case BrieEnumBrie: |
| return "Brie" |
| case BrieEnumThree: |
| return "Three" |
| } |
| return "" |
| } |
| |
| func (BrieEnum) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.BrieEnum"` |
| Enum struct{ Glee, Brie, Three string } |
| }) { |
| } |
| |
| func (x BrieEnum) VDLIsZero() bool { |
| return x == BrieEnumGlee |
| } |
| |
| func (x BrieEnum) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueString(__VDLType_enum_79, x.String()); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *BrieEnum) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| if err := x.Set(value); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| |
| type BeanEnum int |
| |
| const ( |
| BeanEnumBean BeanEnum = iota |
| ) |
| |
| // BeanEnumAll holds all labels for BeanEnum. |
| var BeanEnumAll = [...]BeanEnum{BeanEnumBean} |
| |
| // BeanEnumFromString creates a BeanEnum from a string label. |
| func BeanEnumFromString(label string) (x BeanEnum, err error) { |
| err = x.Set(label) |
| return |
| } |
| |
| // Set assigns label to x. |
| func (x *BeanEnum) Set(label string) error { |
| switch label { |
| case "Bean", "bean": |
| *x = BeanEnumBean |
| return nil |
| } |
| *x = -1 |
| return fmt.Errorf("unknown label %q in types.BeanEnum", label) |
| } |
| |
| // String returns the string label of x. |
| func (x BeanEnum) String() string { |
| switch x { |
| case BeanEnumBean: |
| return "Bean" |
| } |
| return "" |
| } |
| |
| func (BeanEnum) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.BeanEnum"` |
| Enum struct{ Bean string } |
| }) { |
| } |
| |
| func (x BeanEnum) VDLIsZero() bool { |
| return x == BeanEnumBean |
| } |
| |
| func (x BeanEnum) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueString(__VDLType_enum_80, x.String()); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *BeanEnum) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| if err := x.Set(value); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| |
| type FoodEnum int |
| |
| const ( |
| FoodEnumBean FoodEnum = iota |
| FoodEnumBrie |
| FoodEnumCherry |
| ) |
| |
| // FoodEnumAll holds all labels for FoodEnum. |
| var FoodEnumAll = [...]FoodEnum{FoodEnumBean, FoodEnumBrie, FoodEnumCherry} |
| |
| // FoodEnumFromString creates a FoodEnum from a string label. |
| func FoodEnumFromString(label string) (x FoodEnum, err error) { |
| err = x.Set(label) |
| return |
| } |
| |
| // Set assigns label to x. |
| func (x *FoodEnum) Set(label string) error { |
| switch label { |
| case "Bean", "bean": |
| *x = FoodEnumBean |
| return nil |
| case "Brie", "brie": |
| *x = FoodEnumBrie |
| return nil |
| case "Cherry", "cherry": |
| *x = FoodEnumCherry |
| return nil |
| } |
| *x = -1 |
| return fmt.Errorf("unknown label %q in types.FoodEnum", label) |
| } |
| |
| // String returns the string label of x. |
| func (x FoodEnum) String() string { |
| switch x { |
| case FoodEnumBean: |
| return "Bean" |
| case FoodEnumBrie: |
| return "Brie" |
| case FoodEnumCherry: |
| return "Cherry" |
| } |
| return "" |
| } |
| |
| func (FoodEnum) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.FoodEnum"` |
| Enum struct{ Bean, Brie, Cherry string } |
| }) { |
| } |
| |
| func (x FoodEnum) VDLIsZero() bool { |
| return x == FoodEnumBean |
| } |
| |
| func (x FoodEnum) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.WriteValueString(__VDLType_enum_81, x.String()); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (x *FoodEnum) VDLRead(dec vdl.Decoder) error { |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| if err := x.Set(value); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| |
| type StructAny struct { |
| Any *vdl.Value |
| } |
| |
| func (StructAny) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.StructAny"` |
| }) { |
| } |
| |
| func (x StructAny) VDLIsZero() bool { |
| if x.Any != nil && !x.Any.VDLIsZero() { |
| return false |
| } |
| return true |
| } |
| |
| func (x StructAny) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_82); err != nil { |
| return err |
| } |
| if x.Any != nil && !x.Any.VDLIsZero() { |
| if err := enc.NextField(0); err != nil { |
| return err |
| } |
| if err := x.Any.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *StructAny) VDLRead(dec vdl.Decoder) error { |
| *x = StructAny{ |
| Any: vdl.ZeroValue(vdl.AnyType), |
| } |
| if err := dec.StartValue(__VDLType_struct_82); 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 != __VDLType_struct_82 { |
| index = __VDLType_struct_82.FieldIndexByName(decType.Field(index).Name) |
| if index == -1 { |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| continue |
| } |
| } |
| switch index { |
| case 0: |
| x.Any = new(vdl.Value) |
| if err := x.Any.VDLRead(dec); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| type StructMap struct { |
| Map map[int64]int64 |
| } |
| |
| func (StructMap) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.StructMap"` |
| }) { |
| } |
| |
| func (x StructMap) VDLIsZero() bool { |
| if len(x.Map) != 0 { |
| return false |
| } |
| return true |
| } |
| |
| func (x StructMap) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_83); err != nil { |
| return err |
| } |
| if len(x.Map) != 0 { |
| if err := enc.NextField(0); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_map_10(enc, x.Map); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func __VDLWriteAnon_map_10(enc vdl.Encoder, x map[int64]int64) error { |
| if err := enc.StartValue(__VDLType_map_84); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key, elem := range x { |
| if err := enc.NextEntryValueInt(vdl.Int64Type, key); err != nil { |
| return err |
| } |
| if err := enc.WriteValueInt(vdl.Int64Type, elem); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *StructMap) VDLRead(dec vdl.Decoder) error { |
| *x = StructMap{} |
| if err := dec.StartValue(__VDLType_struct_83); 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 != __VDLType_struct_83 { |
| index = __VDLType_struct_83.FieldIndexByName(decType.Field(index).Name) |
| if index == -1 { |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| continue |
| } |
| } |
| switch index { |
| case 0: |
| if err := __VDLReadAnon_map_10(dec, &x.Map); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| func __VDLReadAnon_map_10(dec vdl.Decoder, x *map[int64]int64) error { |
| if err := dec.StartValue(__VDLType_map_84); err != nil { |
| return err |
| } |
| var tmpMap map[int64]int64 |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(map[int64]int64, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueInt(64); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| var elem int64 |
| switch value, err := dec.ReadValueInt(64); { |
| case err != nil: |
| return err |
| default: |
| elem = value |
| } |
| if tmpMap == nil { |
| tmpMap = make(map[int64]int64) |
| } |
| tmpMap[key] = elem |
| } |
| } |
| } |
| |
| // Since the encoding changes if struct fields are zero values, |
| // test each of the kinds in a struct both as zero and non-zero values. |
| type StructManyTypes struct { |
| Bool bool |
| AByte byte |
| Int16 int16 |
| Int32 int32 |
| Int64 int64 |
| Uint16 uint16 |
| Uint32 uint32 |
| Uint64 uint64 |
| String string |
| Bytes []byte |
| Float32 float32 |
| Float64 float64 |
| FoodEnum FoodEnum |
| NEnum NEnum |
| NListUint64 NListUint64 |
| NByteArray NByteArray |
| NArray2Uint64 NArray2Uint64 |
| NSetUint64 NSetUint64 |
| NMapUint64String NMapUint64String |
| NStruct NStruct |
| NUnion NUnion |
| TypeObject *vdl.Type |
| } |
| |
| func (StructManyTypes) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.StructManyTypes"` |
| }) { |
| } |
| |
| func (x StructManyTypes) VDLIsZero() bool { |
| if x.Bool { |
| return false |
| } |
| if x.AByte != 0 { |
| return false |
| } |
| if x.Int16 != 0 { |
| return false |
| } |
| if x.Int32 != 0 { |
| return false |
| } |
| if x.Int64 != 0 { |
| return false |
| } |
| if x.Uint16 != 0 { |
| return false |
| } |
| if x.Uint32 != 0 { |
| return false |
| } |
| if x.Uint64 != 0 { |
| return false |
| } |
| if x.String != "" { |
| return false |
| } |
| if len(x.Bytes) != 0 { |
| return false |
| } |
| if x.Float32 != 0 { |
| return false |
| } |
| if x.Float64 != 0 { |
| return false |
| } |
| if x.FoodEnum != FoodEnumBean { |
| return false |
| } |
| if x.NEnum != NEnumA { |
| return false |
| } |
| if len(x.NListUint64) != 0 { |
| return false |
| } |
| if x.NByteArray != (NByteArray{}) { |
| return false |
| } |
| if x.NArray2Uint64 != (NArray2Uint64{}) { |
| return false |
| } |
| if len(x.NSetUint64) != 0 { |
| return false |
| } |
| if len(x.NMapUint64String) != 0 { |
| return false |
| } |
| if x.NStruct != (NStruct{}) { |
| return false |
| } |
| if x.NUnion != nil && !x.NUnion.VDLIsZero() { |
| return false |
| } |
| if x.TypeObject != nil && x.TypeObject != vdl.AnyType { |
| return false |
| } |
| return true |
| } |
| |
| func (x StructManyTypes) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_85); err != nil { |
| return err |
| } |
| if x.Bool { |
| if err := enc.NextFieldValueBool(0, vdl.BoolType, x.Bool); err != nil { |
| return err |
| } |
| } |
| if x.AByte != 0 { |
| if err := enc.NextFieldValueUint(1, vdl.ByteType, uint64(x.AByte)); err != nil { |
| return err |
| } |
| } |
| if x.Int16 != 0 { |
| if err := enc.NextFieldValueInt(2, vdl.Int16Type, int64(x.Int16)); err != nil { |
| return err |
| } |
| } |
| if x.Int32 != 0 { |
| if err := enc.NextFieldValueInt(3, vdl.Int32Type, int64(x.Int32)); err != nil { |
| return err |
| } |
| } |
| if x.Int64 != 0 { |
| if err := enc.NextFieldValueInt(4, vdl.Int64Type, x.Int64); err != nil { |
| return err |
| } |
| } |
| if x.Uint16 != 0 { |
| if err := enc.NextFieldValueUint(5, vdl.Uint16Type, uint64(x.Uint16)); err != nil { |
| return err |
| } |
| } |
| if x.Uint32 != 0 { |
| if err := enc.NextFieldValueUint(6, vdl.Uint32Type, uint64(x.Uint32)); err != nil { |
| return err |
| } |
| } |
| if x.Uint64 != 0 { |
| if err := enc.NextFieldValueUint(7, vdl.Uint64Type, x.Uint64); err != nil { |
| return err |
| } |
| } |
| if x.String != "" { |
| if err := enc.NextFieldValueString(8, vdl.StringType, x.String); err != nil { |
| return err |
| } |
| } |
| if len(x.Bytes) != 0 { |
| if err := enc.NextFieldValueBytes(9, __VDLType_list_86, x.Bytes); err != nil { |
| return err |
| } |
| } |
| if x.Float32 != 0 { |
| if err := enc.NextFieldValueFloat(10, vdl.Float32Type, float64(x.Float32)); err != nil { |
| return err |
| } |
| } |
| if x.Float64 != 0 { |
| if err := enc.NextFieldValueFloat(11, vdl.Float64Type, x.Float64); err != nil { |
| return err |
| } |
| } |
| if x.FoodEnum != FoodEnumBean { |
| if err := enc.NextFieldValueString(12, __VDLType_enum_81, x.FoodEnum.String()); err != nil { |
| return err |
| } |
| } |
| if x.NEnum != NEnumA { |
| if err := enc.NextFieldValueString(13, __VDLType_enum_29, x.NEnum.String()); err != nil { |
| return err |
| } |
| } |
| if len(x.NListUint64) != 0 { |
| if err := enc.NextField(14); err != nil { |
| return err |
| } |
| if err := x.NListUint64.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.NByteArray != (NByteArray{}) { |
| if err := enc.NextFieldValueBytes(15, __VDLType_array_13, x.NByteArray[:]); err != nil { |
| return err |
| } |
| } |
| if x.NArray2Uint64 != (NArray2Uint64{}) { |
| if err := enc.NextField(16); err != nil { |
| return err |
| } |
| if err := x.NArray2Uint64.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if len(x.NSetUint64) != 0 { |
| if err := enc.NextField(17); err != nil { |
| return err |
| } |
| if err := x.NSetUint64.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if len(x.NMapUint64String) != 0 { |
| if err := enc.NextField(18); err != nil { |
| return err |
| } |
| if err := x.NMapUint64String.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.NStruct != (NStruct{}) { |
| if err := enc.NextField(19); err != nil { |
| return err |
| } |
| if err := x.NStruct.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.NUnion != nil && !x.NUnion.VDLIsZero() { |
| if err := enc.NextField(20); err != nil { |
| return err |
| } |
| if err := x.NUnion.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.TypeObject != nil && x.TypeObject != vdl.AnyType { |
| if err := enc.NextFieldValueTypeObject(21, x.TypeObject); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *StructManyTypes) VDLRead(dec vdl.Decoder) error { |
| *x = StructManyTypes{ |
| NUnion: NUnionA{}, |
| TypeObject: vdl.AnyType, |
| } |
| if err := dec.StartValue(__VDLType_struct_85); 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 != __VDLType_struct_85 { |
| index = __VDLType_struct_85.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.ReadValueBool(); { |
| case err != nil: |
| return err |
| default: |
| x.Bool = value |
| } |
| case 1: |
| switch value, err := dec.ReadValueUint(8); { |
| case err != nil: |
| return err |
| default: |
| x.AByte = byte(value) |
| } |
| case 2: |
| switch value, err := dec.ReadValueInt(16); { |
| case err != nil: |
| return err |
| default: |
| x.Int16 = int16(value) |
| } |
| case 3: |
| switch value, err := dec.ReadValueInt(32); { |
| case err != nil: |
| return err |
| default: |
| x.Int32 = int32(value) |
| } |
| case 4: |
| switch value, err := dec.ReadValueInt(64); { |
| case err != nil: |
| return err |
| default: |
| x.Int64 = value |
| } |
| case 5: |
| switch value, err := dec.ReadValueUint(16); { |
| case err != nil: |
| return err |
| default: |
| x.Uint16 = uint16(value) |
| } |
| case 6: |
| switch value, err := dec.ReadValueUint(32); { |
| case err != nil: |
| return err |
| default: |
| x.Uint32 = uint32(value) |
| } |
| case 7: |
| switch value, err := dec.ReadValueUint(64); { |
| case err != nil: |
| return err |
| default: |
| x.Uint64 = value |
| } |
| case 8: |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| x.String = value |
| } |
| case 9: |
| if err := dec.ReadValueBytes(-1, &x.Bytes); err != nil { |
| return err |
| } |
| case 10: |
| switch value, err := dec.ReadValueFloat(32); { |
| case err != nil: |
| return err |
| default: |
| x.Float32 = float32(value) |
| } |
| case 11: |
| switch value, err := dec.ReadValueFloat(64); { |
| case err != nil: |
| return err |
| default: |
| x.Float64 = value |
| } |
| case 12: |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| if err := x.FoodEnum.Set(value); err != nil { |
| return err |
| } |
| } |
| case 13: |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| if err := x.NEnum.Set(value); err != nil { |
| return err |
| } |
| } |
| case 14: |
| if err := x.NListUint64.VDLRead(dec); err != nil { |
| return err |
| } |
| case 15: |
| bytes := x.NByteArray[:] |
| if err := dec.ReadValueBytes(4, &bytes); err != nil { |
| return err |
| } |
| case 16: |
| if err := x.NArray2Uint64.VDLRead(dec); err != nil { |
| return err |
| } |
| case 17: |
| if err := x.NSetUint64.VDLRead(dec); err != nil { |
| return err |
| } |
| case 18: |
| if err := x.NMapUint64String.VDLRead(dec); err != nil { |
| return err |
| } |
| case 19: |
| if err := x.NStruct.VDLRead(dec); err != nil { |
| return err |
| } |
| case 20: |
| if err := VDLReadNUnion(dec, &x.NUnion); err != nil { |
| return err |
| } |
| case 21: |
| switch value, err := dec.ReadValueTypeObject(); { |
| case err != nil: |
| return err |
| default: |
| x.TypeObject = value |
| } |
| } |
| } |
| } |
| |
| type AnySlice []*vdl.Value |
| |
| func (AnySlice) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.AnySlice"` |
| }) { |
| } |
| |
| func (x AnySlice) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x AnySlice) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_list_87); 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 *AnySlice) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(__VDLType_list_87); err != nil { |
| return err |
| } |
| if len := dec.LenHint(); len > 0 { |
| *x = make(AnySlice, 0, len) |
| } else { |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| default: |
| var elem *vdl.Value |
| elem = new(vdl.Value) |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| } |
| |
| type LargeMessageType struct { |
| Payload []byte |
| Next *LargeMessageType |
| } |
| |
| func (LargeMessageType) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.LargeMessageType"` |
| }) { |
| } |
| |
| func (x LargeMessageType) VDLIsZero() bool { |
| if len(x.Payload) != 0 { |
| return false |
| } |
| if x.Next != nil { |
| return false |
| } |
| return true |
| } |
| |
| func (x LargeMessageType) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_88); err != nil { |
| return err |
| } |
| if len(x.Payload) != 0 { |
| if err := enc.NextFieldValueBytes(0, __VDLType_list_86, x.Payload); err != nil { |
| return err |
| } |
| } |
| if x.Next != nil { |
| if err := enc.NextField(1); err != nil { |
| return err |
| } |
| enc.SetNextStartValueIsOptional() |
| if err := x.Next.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *LargeMessageType) VDLRead(dec vdl.Decoder) error { |
| *x = LargeMessageType{} |
| if err := dec.StartValue(__VDLType_struct_88); 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 != __VDLType_struct_88 { |
| index = __VDLType_struct_88.FieldIndexByName(decType.Field(index).Name) |
| if index == -1 { |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| continue |
| } |
| } |
| switch index { |
| case 0: |
| if err := dec.ReadValueBytes(-1, &x.Payload); err != nil { |
| return err |
| } |
| case 1: |
| if err := dec.StartValue(__VDLType_optional_89); err != nil { |
| return err |
| } |
| if dec.IsNil() { |
| x.Next = nil |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| } else { |
| x.Next = new(LargeMessageType) |
| dec.IgnoreNextStartValue() |
| if err := x.Next.VDLRead(dec); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| } |
| |
| type LargeAnyMessageType struct { |
| Payload *vdl.Value |
| Next *LargeAnyMessageType |
| } |
| |
| func (LargeAnyMessageType) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/testdata/types.LargeAnyMessageType"` |
| }) { |
| } |
| |
| func (x LargeAnyMessageType) VDLIsZero() bool { |
| if x.Payload != nil && !x.Payload.VDLIsZero() { |
| return false |
| } |
| if x.Next != nil { |
| return false |
| } |
| return true |
| } |
| |
| func (x LargeAnyMessageType) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_90); err != nil { |
| return err |
| } |
| if x.Payload != nil && !x.Payload.VDLIsZero() { |
| if err := enc.NextField(0); err != nil { |
| return err |
| } |
| if err := x.Payload.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.Next != nil { |
| if err := enc.NextField(1); err != nil { |
| return err |
| } |
| enc.SetNextStartValueIsOptional() |
| if err := x.Next.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *LargeAnyMessageType) VDLRead(dec vdl.Decoder) error { |
| *x = LargeAnyMessageType{ |
| Payload: vdl.ZeroValue(vdl.AnyType), |
| } |
| if err := dec.StartValue(__VDLType_struct_90); 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 != __VDLType_struct_90 { |
| index = __VDLType_struct_90.FieldIndexByName(decType.Field(index).Name) |
| if index == -1 { |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| continue |
| } |
| } |
| switch index { |
| case 0: |
| x.Payload = new(vdl.Value) |
| if err := x.Payload.VDLRead(dec); err != nil { |
| return err |
| } |
| case 1: |
| if err := dec.StartValue(__VDLType_optional_91); err != nil { |
| return err |
| } |
| if dec.IsNil() { |
| x.Next = nil |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| } else { |
| x.Next = new(LargeAnyMessageType) |
| dec.IgnoreNextStartValue() |
| if err := x.Next.VDLRead(dec); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| } |
| |
| // Hold type definitions in package-level variables, for better performance. |
| var ( |
| __VDLType_struct_1 *vdl.Type |
| __VDLType_struct_2 *vdl.Type |
| __VDLType_list_3 *vdl.Type |
| __VDLType_struct_4 *vdl.Type |
| __VDLType_map_5 *vdl.Type |
| __VDLType_map_6 *vdl.Type |
| __VDLType_map_7 *vdl.Type |
| __VDLType_list_8 *vdl.Type |
| __VDLType_list_9 *vdl.Type |
| __VDLType_bool_10 *vdl.Type |
| __VDLType_string_11 *vdl.Type |
| __VDLType_list_12 *vdl.Type |
| __VDLType_array_13 *vdl.Type |
| __VDLType_byte_14 *vdl.Type |
| __VDLType_uint16_15 *vdl.Type |
| __VDLType_uint32_16 *vdl.Type |
| __VDLType_uint64_17 *vdl.Type |
| __VDLType_int8_18 *vdl.Type |
| __VDLType_int16_19 *vdl.Type |
| __VDLType_int32_20 *vdl.Type |
| __VDLType_int64_21 *vdl.Type |
| __VDLType_float32_22 *vdl.Type |
| __VDLType_float64_23 *vdl.Type |
| __VDLType_array_24 *vdl.Type |
| __VDLType_list_25 *vdl.Type |
| __VDLType_set_26 *vdl.Type |
| __VDLType_map_27 *vdl.Type |
| __VDLType_struct_28 *vdl.Type |
| __VDLType_enum_29 *vdl.Type |
| __VDLType_union_30 *vdl.Type |
| __VDLType_bool_31 *vdl.Type |
| __VDLType_struct_32 *vdl.Type |
| __VDLType_optional_33 *vdl.Type |
| __VDLType_list_34 *vdl.Type |
| __VDLType_map_35 *vdl.Type |
| __VDLType_list_36 *vdl.Type |
| __VDLType_list_37 *vdl.Type |
| __VDLType_list_38 *vdl.Type |
| __VDLType_list_39 *vdl.Type |
| __VDLType_list_40 *vdl.Type |
| __VDLType_list_41 *vdl.Type |
| __VDLType_list_42 *vdl.Type |
| __VDLType_list_43 *vdl.Type |
| __VDLType_list_44 *vdl.Type |
| __VDLType_struct_45 *vdl.Type |
| __VDLType_optional_46 *vdl.Type |
| __VDLType_struct_47 *vdl.Type |
| __VDLType_struct_48 *vdl.Type |
| __VDLType_list_49 *vdl.Type |
| __VDLType_list_50 *vdl.Type |
| __VDLType_struct_51 *vdl.Type |
| __VDLType_list_52 *vdl.Type |
| __VDLType_struct_53 *vdl.Type |
| __VDLType_list_54 *vdl.Type |
| __VDLType_array_55 *vdl.Type |
| __VDLType_array_56 *vdl.Type |
| __VDLType_struct_57 *vdl.Type |
| __VDLType_struct_58 *vdl.Type |
| __VDLType_struct_59 *vdl.Type |
| __VDLType_struct_60 *vdl.Type |
| __VDLType_struct_61 *vdl.Type |
| __VDLType_struct_62 *vdl.Type |
| __VDLType_map_63 *vdl.Type |
| __VDLType_struct_64 *vdl.Type |
| __VDLType_map_65 *vdl.Type |
| __VDLType_set_66 *vdl.Type |
| __VDLType_map_67 *vdl.Type |
| __VDLType_map_68 *vdl.Type |
| __VDLType_set_69 *vdl.Type |
| __VDLType_set_70 *vdl.Type |
| __VDLType_set_71 *vdl.Type |
| __VDLType_set_72 *vdl.Type |
| __VDLType_set_73 *vdl.Type |
| __VDLType_map_74 *vdl.Type |
| __VDLType_map_75 *vdl.Type |
| __VDLType_map_76 *vdl.Type |
| __VDLType_map_77 *vdl.Type |
| __VDLType_union_78 *vdl.Type |
| __VDLType_enum_79 *vdl.Type |
| __VDLType_enum_80 *vdl.Type |
| __VDLType_enum_81 *vdl.Type |
| __VDLType_struct_82 *vdl.Type |
| __VDLType_struct_83 *vdl.Type |
| __VDLType_map_84 *vdl.Type |
| __VDLType_struct_85 *vdl.Type |
| __VDLType_list_86 *vdl.Type |
| __VDLType_list_87 *vdl.Type |
| __VDLType_struct_88 *vdl.Type |
| __VDLType_optional_89 *vdl.Type |
| __VDLType_struct_90 *vdl.Type |
| __VDLType_optional_91 *vdl.Type |
| ) |
| |
| var __VDLInitCalled bool |
| |
| // __VDLInit 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 _ = __VDLInit() |
| // |
| // 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 __VDLInit() struct{} { |
| if __VDLInitCalled { |
| return struct{}{} |
| } |
| __VDLInitCalled = true |
| |
| // Register types. |
| vdl.Register((*TestCase)(nil)) |
| vdl.Register((*ConvertGroup)(nil)) |
| vdl.Register((*VomdataStruct)(nil)) |
| vdl.Register((*NBool)(nil)) |
| vdl.Register((*NString)(nil)) |
| vdl.Register((*NByteSlice)(nil)) |
| vdl.Register((*NByteArray)(nil)) |
| vdl.Register((*NByte)(nil)) |
| vdl.Register((*NUint16)(nil)) |
| vdl.Register((*NUint32)(nil)) |
| vdl.Register((*NUint64)(nil)) |
| vdl.Register((*NInt8)(nil)) |
| vdl.Register((*NInt16)(nil)) |
| vdl.Register((*NInt32)(nil)) |
| vdl.Register((*NInt64)(nil)) |
| vdl.Register((*NFloat32)(nil)) |
| vdl.Register((*NFloat64)(nil)) |
| vdl.Register((*NArray2Uint64)(nil)) |
| vdl.Register((*NListUint64)(nil)) |
| vdl.Register((*NSetUint64)(nil)) |
| vdl.Register((*NMapUint64String)(nil)) |
| vdl.Register((*NStruct)(nil)) |
| vdl.Register((*NEnum)(nil)) |
| vdl.Register((*NUnion)(nil)) |
| vdl.Register((*MBool)(nil)) |
| vdl.Register((*MStruct)(nil)) |
| vdl.Register((*MList)(nil)) |
| vdl.Register((*MMap)(nil)) |
| vdl.Register((*MByteSlice)(nil)) |
| vdl.Register((*MInt8Slice)(nil)) |
| vdl.Register((*RecA)(nil)) |
| vdl.Register((*RecY)(nil)) |
| vdl.Register((*RecX)(nil)) |
| vdl.Register((*Rec4)(nil)) |
| vdl.Register((*Rec3)(nil)) |
| vdl.Register((*Rec2)(nil)) |
| vdl.Register((*Rec1)(nil)) |
| vdl.Register((*RecStruct)(nil)) |
| vdl.Register((*Rec1234)(nil)) |
| vdl.Register((*Rec1234A)(nil)) |
| vdl.Register((*Rec1234B)(nil)) |
| vdl.Register((*Rec1234All)(nil)) |
| vdl.Register((*ListString)(nil)) |
| vdl.Register((*Array3String)(nil)) |
| vdl.Register((*Array4String)(nil)) |
| vdl.Register((*AbcStruct)(nil)) |
| vdl.Register((*AdeStruct)(nil)) |
| vdl.Register((*XyzStruct)(nil)) |
| vdl.Register((*YzStruct)(nil)) |
| vdl.Register((*ZStruct)(nil)) |
| vdl.Register((*MapOnlyStruct)(nil)) |
| vdl.Register((*StructOnlyMap)(nil)) |
| vdl.Register((*MapSetStruct)(nil)) |
| vdl.Register((*SetStructMap)(nil)) |
| vdl.Register((*MapStructSet)(nil)) |
| vdl.Register((*SetOnlyMap)(nil)) |
| vdl.Register((*SometimesSetMap)(nil)) |
| vdl.Register((*MapOnlySet)(nil)) |
| vdl.Register((*SetOnlyA)(nil)) |
| vdl.Register((*SetOnlyA2)(nil)) |
| vdl.Register((*SetOnlyB)(nil)) |
| vdl.Register((*SetOnlyB2)(nil)) |
| vdl.Register((*MapOnlyA)(nil)) |
| vdl.Register((*MapOnlyA2)(nil)) |
| vdl.Register((*MapOnlyB)(nil)) |
| vdl.Register((*MapOnlyB2)(nil)) |
| vdl.Register((*BdeUnion)(nil)) |
| vdl.Register((*BrieEnum)(nil)) |
| vdl.Register((*BeanEnum)(nil)) |
| vdl.Register((*FoodEnum)(nil)) |
| vdl.Register((*StructAny)(nil)) |
| vdl.Register((*StructMap)(nil)) |
| vdl.Register((*StructManyTypes)(nil)) |
| vdl.Register((*AnySlice)(nil)) |
| vdl.Register((*LargeMessageType)(nil)) |
| vdl.Register((*LargeAnyMessageType)(nil)) |
| |
| // Initialize type definitions. |
| __VDLType_struct_1 = vdl.TypeOf((*TestCase)(nil)).Elem() |
| __VDLType_struct_2 = vdl.TypeOf((*ConvertGroup)(nil)).Elem() |
| __VDLType_list_3 = vdl.TypeOf((*[]*vdl.Value)(nil)) |
| __VDLType_struct_4 = vdl.TypeOf((*VomdataStruct)(nil)).Elem() |
| __VDLType_map_5 = vdl.TypeOf((*map[byte][]*vdl.Value)(nil)) |
| __VDLType_map_6 = vdl.TypeOf((*map[string][]*vdl.Type)(nil)) |
| __VDLType_map_7 = vdl.TypeOf((*map[string][]ConvertGroup)(nil)) |
| __VDLType_list_8 = vdl.TypeOf((*[]*vdl.Type)(nil)) |
| __VDLType_list_9 = vdl.TypeOf((*[]ConvertGroup)(nil)) |
| __VDLType_bool_10 = vdl.TypeOf((*NBool)(nil)) |
| __VDLType_string_11 = vdl.TypeOf((*NString)(nil)) |
| __VDLType_list_12 = vdl.TypeOf((*NByteSlice)(nil)) |
| __VDLType_array_13 = vdl.TypeOf((*NByteArray)(nil)) |
| __VDLType_byte_14 = vdl.TypeOf((*NByte)(nil)) |
| __VDLType_uint16_15 = vdl.TypeOf((*NUint16)(nil)) |
| __VDLType_uint32_16 = vdl.TypeOf((*NUint32)(nil)) |
| __VDLType_uint64_17 = vdl.TypeOf((*NUint64)(nil)) |
| __VDLType_int8_18 = vdl.TypeOf((*NInt8)(nil)) |
| __VDLType_int16_19 = vdl.TypeOf((*NInt16)(nil)) |
| __VDLType_int32_20 = vdl.TypeOf((*NInt32)(nil)) |
| __VDLType_int64_21 = vdl.TypeOf((*NInt64)(nil)) |
| __VDLType_float32_22 = vdl.TypeOf((*NFloat32)(nil)) |
| __VDLType_float64_23 = vdl.TypeOf((*NFloat64)(nil)) |
| __VDLType_array_24 = vdl.TypeOf((*NArray2Uint64)(nil)) |
| __VDLType_list_25 = vdl.TypeOf((*NListUint64)(nil)) |
| __VDLType_set_26 = vdl.TypeOf((*NSetUint64)(nil)) |
| __VDLType_map_27 = vdl.TypeOf((*NMapUint64String)(nil)) |
| __VDLType_struct_28 = vdl.TypeOf((*NStruct)(nil)).Elem() |
| __VDLType_enum_29 = vdl.TypeOf((*NEnum)(nil)) |
| __VDLType_union_30 = vdl.TypeOf((*NUnion)(nil)) |
| __VDLType_bool_31 = vdl.TypeOf((*MBool)(nil)) |
| __VDLType_struct_32 = vdl.TypeOf((*MStruct)(nil)).Elem() |
| __VDLType_optional_33 = vdl.TypeOf((*NStruct)(nil)) |
| __VDLType_list_34 = vdl.TypeOf((*MList)(nil)) |
| __VDLType_map_35 = vdl.TypeOf((*MMap)(nil)) |
| __VDLType_list_36 = vdl.TypeOf((*MByteSlice)(nil)) |
| __VDLType_list_37 = vdl.TypeOf((*MInt8Slice)(nil)) |
| __VDLType_list_38 = vdl.TypeOf((*RecA)(nil)) |
| __VDLType_list_39 = vdl.TypeOf((*RecY)(nil)) |
| __VDLType_list_40 = vdl.TypeOf((*RecX)(nil)) |
| __VDLType_list_41 = vdl.TypeOf((*Rec4)(nil)) |
| __VDLType_list_42 = vdl.TypeOf((*Rec1)(nil)) |
| __VDLType_list_43 = vdl.TypeOf((*Rec3)(nil)) |
| __VDLType_list_44 = vdl.TypeOf((*Rec2)(nil)) |
| __VDLType_struct_45 = vdl.TypeOf((*RecStruct)(nil)).Elem() |
| __VDLType_optional_46 = vdl.TypeOf((*RecStruct)(nil)) |
| __VDLType_struct_47 = vdl.TypeOf((*Rec1234)(nil)).Elem() |
| __VDLType_struct_48 = vdl.TypeOf((*Rec1234A)(nil)).Elem() |
| __VDLType_list_49 = vdl.TypeOf((*[]Rec1234A)(nil)) |
| __VDLType_list_50 = vdl.TypeOf((*[]Rec1234)(nil)) |
| __VDLType_struct_51 = vdl.TypeOf((*Rec1234B)(nil)).Elem() |
| __VDLType_list_52 = vdl.TypeOf((*[]Rec1234B)(nil)) |
| __VDLType_struct_53 = vdl.TypeOf((*Rec1234All)(nil)).Elem() |
| __VDLType_list_54 = vdl.TypeOf((*ListString)(nil)) |
| __VDLType_array_55 = vdl.TypeOf((*Array3String)(nil)) |
| __VDLType_array_56 = vdl.TypeOf((*Array4String)(nil)) |
| __VDLType_struct_57 = vdl.TypeOf((*AbcStruct)(nil)).Elem() |
| __VDLType_struct_58 = vdl.TypeOf((*AdeStruct)(nil)).Elem() |
| __VDLType_struct_59 = vdl.TypeOf((*XyzStruct)(nil)).Elem() |
| __VDLType_struct_60 = vdl.TypeOf((*YzStruct)(nil)).Elem() |
| __VDLType_struct_61 = vdl.TypeOf((*ZStruct)(nil)).Elem() |
| __VDLType_struct_62 = vdl.TypeOf((*MapOnlyStruct)(nil)).Elem() |
| __VDLType_map_63 = vdl.TypeOf((*StructOnlyMap)(nil)) |
| __VDLType_struct_64 = vdl.TypeOf((*MapSetStruct)(nil)).Elem() |
| __VDLType_map_65 = vdl.TypeOf((*SetStructMap)(nil)) |
| __VDLType_set_66 = vdl.TypeOf((*MapStructSet)(nil)) |
| __VDLType_map_67 = vdl.TypeOf((*SetOnlyMap)(nil)) |
| __VDLType_map_68 = vdl.TypeOf((*SometimesSetMap)(nil)) |
| __VDLType_set_69 = vdl.TypeOf((*MapOnlySet)(nil)) |
| __VDLType_set_70 = vdl.TypeOf((*SetOnlyA)(nil)) |
| __VDLType_set_71 = vdl.TypeOf((*SetOnlyA2)(nil)) |
| __VDLType_set_72 = vdl.TypeOf((*SetOnlyB)(nil)) |
| __VDLType_set_73 = vdl.TypeOf((*SetOnlyB2)(nil)) |
| __VDLType_map_74 = vdl.TypeOf((*MapOnlyA)(nil)) |
| __VDLType_map_75 = vdl.TypeOf((*MapOnlyA2)(nil)) |
| __VDLType_map_76 = vdl.TypeOf((*MapOnlyB)(nil)) |
| __VDLType_map_77 = vdl.TypeOf((*MapOnlyB2)(nil)) |
| __VDLType_union_78 = vdl.TypeOf((*BdeUnion)(nil)) |
| __VDLType_enum_79 = vdl.TypeOf((*BrieEnum)(nil)) |
| __VDLType_enum_80 = vdl.TypeOf((*BeanEnum)(nil)) |
| __VDLType_enum_81 = vdl.TypeOf((*FoodEnum)(nil)) |
| __VDLType_struct_82 = vdl.TypeOf((*StructAny)(nil)).Elem() |
| __VDLType_struct_83 = vdl.TypeOf((*StructMap)(nil)).Elem() |
| __VDLType_map_84 = vdl.TypeOf((*map[int64]int64)(nil)) |
| __VDLType_struct_85 = vdl.TypeOf((*StructManyTypes)(nil)).Elem() |
| __VDLType_list_86 = vdl.TypeOf((*[]byte)(nil)) |
| __VDLType_list_87 = vdl.TypeOf((*AnySlice)(nil)) |
| __VDLType_struct_88 = vdl.TypeOf((*LargeMessageType)(nil)).Elem() |
| __VDLType_optional_89 = vdl.TypeOf((*LargeMessageType)(nil)) |
| __VDLType_struct_90 = vdl.TypeOf((*LargeAnyMessageType)(nil)).Elem() |
| __VDLType_optional_91 = vdl.TypeOf((*LargeAnyMessageType)(nil)) |
| |
| return struct{}{} |
| } |