| // Copyright 2016 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // This file was auto-generated by the vanadium vdl tool. |
| // Package: internal |
| |
| package internal |
| |
| import ( |
| "fmt" |
| "v.io/v23/vdl" |
| "v.io/v23/vom" |
| ) |
| |
| var _ = __VDLInit() // Must be first; see __VDLInit comments for details. |
| |
| ////////////////////////////////////////////////// |
| // Type definitions |
| |
| type VNumber int32 |
| |
| func (VNumber) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/internal.VNumber"` |
| }) { |
| } |
| |
| func (x VNumber) VDLIsZero() bool { |
| return x == 0 |
| } |
| |
| func (x VNumber) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*VNumber)(nil))); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x)); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *VNumber) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| *x = VNumber(tmp) |
| return dec.FinishValue() |
| } |
| |
| type VString string |
| |
| func (VString) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/internal.VString"` |
| }) { |
| } |
| |
| func (x VString) VDLIsZero() bool { |
| return x == "" |
| } |
| |
| func (x VString) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*VString)(nil))); err != nil { |
| return err |
| } |
| if err := enc.EncodeString(string(x)); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *VString) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeString() |
| if err != nil { |
| return err |
| } |
| *x = VString(tmp) |
| return dec.FinishValue() |
| } |
| |
| type VEnum int |
| |
| const ( |
| VEnumA VEnum = iota |
| VEnumB |
| VEnumC |
| ) |
| |
| // VEnumAll holds all labels for VEnum. |
| var VEnumAll = [...]VEnum{VEnumA, VEnumB, VEnumC} |
| |
| // VEnumFromString creates a VEnum from a string label. |
| func VEnumFromString(label string) (x VEnum, err error) { |
| err = x.Set(label) |
| return |
| } |
| |
| // Set assigns label to x. |
| func (x *VEnum) Set(label string) error { |
| switch label { |
| case "A", "a": |
| *x = VEnumA |
| return nil |
| case "B", "b": |
| *x = VEnumB |
| return nil |
| case "C", "c": |
| *x = VEnumC |
| return nil |
| } |
| *x = -1 |
| return fmt.Errorf("unknown label %q in internal.VEnum", label) |
| } |
| |
| // String returns the string label of x. |
| func (x VEnum) String() string { |
| switch x { |
| case VEnumA: |
| return "A" |
| case VEnumB: |
| return "B" |
| case VEnumC: |
| return "C" |
| } |
| return "" |
| } |
| |
| func (VEnum) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/internal.VEnum"` |
| Enum struct{ A, B, C string } |
| }) { |
| } |
| |
| func (x VEnum) VDLIsZero() bool { |
| return x == VEnumA |
| } |
| |
| func (x VEnum) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*VEnum)(nil))); err != nil { |
| return err |
| } |
| if err := enc.EncodeString(x.String()); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *VEnum) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| enum, err := dec.DecodeString() |
| if err != nil { |
| return err |
| } |
| if err := x.Set(enum); err != nil { |
| return err |
| } |
| return dec.FinishValue() |
| } |
| |
| type VByteList []byte |
| |
| func (VByteList) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/internal.VByteList"` |
| }) { |
| } |
| |
| func (x VByteList) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x VByteList) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*VByteList)(nil))); err != nil { |
| return err |
| } |
| if err := enc.EncodeBytes([]byte(x)); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *VByteList) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var bytes []byte |
| if err := dec.DecodeBytes(-1, &bytes); err != nil { |
| return err |
| } |
| *x = bytes |
| return dec.FinishValue() |
| } |
| |
| type VByteArray [3]byte |
| |
| func (VByteArray) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/internal.VByteArray"` |
| }) { |
| } |
| |
| func (x VByteArray) VDLIsZero() bool { |
| return x == VByteArray{} |
| } |
| |
| func (x VByteArray) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*VByteArray)(nil))); err != nil { |
| return err |
| } |
| if err := enc.EncodeBytes([]byte(x[:])); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *VByteArray) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| bytes := x[:] |
| if err := dec.DecodeBytes(3, &bytes); err != nil { |
| return err |
| } |
| return dec.FinishValue() |
| } |
| |
| type VArray [3]int32 |
| |
| func (VArray) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/internal.VArray"` |
| }) { |
| } |
| |
| func (x VArray) VDLIsZero() bool { |
| return x == VArray{} |
| } |
| |
| func (x VArray) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*VArray)(nil))); err != nil { |
| return err |
| } |
| for i := 0; i < 3; i++ { |
| if err := enc.NextEntry(false); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x[i])); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *VArray) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) { |
| return fmt.Errorf("incompatible array %T, from %v", *x, dec.Type()) |
| } |
| index := 0 |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done != (index >= len(*x)): |
| return fmt.Errorf("array len mismatch, done:%v index:%d len:%d %T)", done, index, len(*x), *x) |
| case done: |
| return dec.FinishValue() |
| } |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x[index] = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| index++ |
| } |
| } |
| |
| type VList []int32 |
| |
| func (VList) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/internal.VList"` |
| }) { |
| } |
| |
| func (x VList) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x VList) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*VList)(nil))); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for i := 0; i < len(x); i++ { |
| if err := enc.NextEntry(false); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x[i])); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *VList) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) { |
| return fmt.Errorf("incompatible list %T, from %v", *x, dec.Type()) |
| } |
| switch len := dec.LenHint(); { |
| case len > 0: |
| *x = make(VList, 0, len) |
| default: |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| } |
| var elem int32 |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| elem = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| |
| type VListAny []*vom.RawBytes |
| |
| func (VListAny) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/internal.VListAny"` |
| }) { |
| } |
| |
| func (x VListAny) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x VListAny) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*VListAny)(nil))); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for i := 0; i < len(x); i++ { |
| if err := enc.NextEntry(false); err != nil { |
| return err |
| } |
| if x[i] == nil { |
| if err := enc.NilValue(vdl.AnyType); err != nil { |
| return err |
| } |
| } else { |
| if err := x[i].VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *VListAny) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) { |
| return fmt.Errorf("incompatible list %T, from %v", *x, dec.Type()) |
| } |
| switch len := dec.LenHint(); { |
| case len > 0: |
| *x = make(VListAny, 0, len) |
| default: |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| } |
| var elem *vom.RawBytes |
| elem = new(vom.RawBytes) |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| |
| type VSet map[string]struct{} |
| |
| func (VSet) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/internal.VSet"` |
| }) { |
| } |
| |
| func (x VSet) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x VSet) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*VSet)(nil))); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key := range x { |
| if err := enc.NextEntry(false); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.StringType); err != nil { |
| return err |
| } |
| if err := enc.EncodeString(key); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *VSet) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) { |
| return fmt.Errorf("incompatible set %T, from %v", *x, dec.Type()) |
| } |
| var tmpMap VSet |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(VSet, len) |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| } |
| var key string |
| { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var err error |
| if key, err = dec.DecodeString(); err != nil { |
| return err |
| } |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if tmpMap == nil { |
| tmpMap = make(VSet) |
| } |
| tmpMap[key] = struct{}{} |
| } |
| } |
| |
| type VMap map[string]bool |
| |
| func (VMap) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/internal.VMap"` |
| }) { |
| } |
| |
| func (x VMap) VDLIsZero() bool { |
| return len(x) == 0 |
| } |
| |
| func (x VMap) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*VMap)(nil))); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for key, elem := range x { |
| if err := enc.NextEntry(false); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.StringType); err != nil { |
| return err |
| } |
| if err := enc.EncodeString(key); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.BoolType); err != nil { |
| return err |
| } |
| if err := enc.EncodeBool(elem); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *VMap) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) { |
| return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type()) |
| } |
| var tmpMap VMap |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(VMap, len) |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| } |
| var key string |
| { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var err error |
| if key, err = dec.DecodeString(); err != nil { |
| return err |
| } |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| } |
| var elem bool |
| { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var err error |
| if elem, err = dec.DecodeBool(); err != nil { |
| return err |
| } |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if tmpMap == nil { |
| tmpMap = make(VMap) |
| } |
| tmpMap[key] = elem |
| } |
| } |
| |
| type VSmallStruct struct { |
| A int32 |
| B string |
| C bool |
| } |
| |
| func (VSmallStruct) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/internal.VSmallStruct"` |
| }) { |
| } |
| |
| func (x VSmallStruct) VDLIsZero() bool { |
| return x == VSmallStruct{} |
| } |
| |
| func (x VSmallStruct) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*VSmallStruct)(nil)).Elem()); err != nil { |
| return err |
| } |
| if x.A != 0 { |
| if err := enc.NextField("A"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.A)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.B != "" { |
| if err := enc.NextField("B"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.StringType); err != nil { |
| return err |
| } |
| if err := enc.EncodeString(x.B); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.C { |
| if err := enc.NextField("C"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.BoolType); err != nil { |
| return err |
| } |
| if err := enc.EncodeBool(x.C); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *VSmallStruct) VDLRead(dec vdl.Decoder) error { |
| *x = VSmallStruct{} |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) { |
| return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type()) |
| } |
| for { |
| f, err := dec.NextField() |
| if err != nil { |
| return err |
| } |
| switch f { |
| case "": |
| return dec.FinishValue() |
| case "A": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.A = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "B": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var err error |
| if x.B, err = dec.DecodeString(); err != nil { |
| return err |
| } |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "C": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var err error |
| if x.C, err = dec.DecodeBool(); err != nil { |
| return err |
| } |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| default: |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| type VLargeStruct struct { |
| F1 int32 |
| F2 int32 |
| F3 int32 |
| F4 int32 |
| F5 int32 |
| F6 int32 |
| F7 int32 |
| F8 int32 |
| F9 int32 |
| F10 int32 |
| F11 int32 |
| F12 int32 |
| F13 int32 |
| F14 int32 |
| F15 int32 |
| F16 int32 |
| F17 int32 |
| F18 int32 |
| F19 int32 |
| F20 int32 |
| F21 int32 |
| F22 int32 |
| F23 int32 |
| F24 int32 |
| F25 int32 |
| F26 int32 |
| F27 int32 |
| F28 int32 |
| F29 int32 |
| F30 int32 |
| F31 int32 |
| F32 int32 |
| F33 int32 |
| F34 int32 |
| F35 int32 |
| F36 int32 |
| F37 int32 |
| F38 int32 |
| F39 int32 |
| F40 int32 |
| F41 int32 |
| F42 int32 |
| F43 int32 |
| F44 int32 |
| F45 int32 |
| F46 int32 |
| F47 int32 |
| F48 int32 |
| F49 int32 |
| F50 int32 |
| } |
| |
| func (VLargeStruct) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vom/internal.VLargeStruct"` |
| }) { |
| } |
| |
| func (x VLargeStruct) VDLIsZero() bool { |
| return x == VLargeStruct{} |
| } |
| |
| func (x VLargeStruct) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*VLargeStruct)(nil)).Elem()); err != nil { |
| return err |
| } |
| if x.F1 != 0 { |
| if err := enc.NextField("F1"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F1)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F2 != 0 { |
| if err := enc.NextField("F2"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F2)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F3 != 0 { |
| if err := enc.NextField("F3"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F3)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F4 != 0 { |
| if err := enc.NextField("F4"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F4)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F5 != 0 { |
| if err := enc.NextField("F5"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F5)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F6 != 0 { |
| if err := enc.NextField("F6"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F6)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F7 != 0 { |
| if err := enc.NextField("F7"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F7)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F8 != 0 { |
| if err := enc.NextField("F8"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F8)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F9 != 0 { |
| if err := enc.NextField("F9"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F9)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F10 != 0 { |
| if err := enc.NextField("F10"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F10)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F11 != 0 { |
| if err := enc.NextField("F11"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F11)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F12 != 0 { |
| if err := enc.NextField("F12"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F12)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F13 != 0 { |
| if err := enc.NextField("F13"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F13)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F14 != 0 { |
| if err := enc.NextField("F14"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F14)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F15 != 0 { |
| if err := enc.NextField("F15"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F15)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F16 != 0 { |
| if err := enc.NextField("F16"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F16)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F17 != 0 { |
| if err := enc.NextField("F17"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F17)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F18 != 0 { |
| if err := enc.NextField("F18"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F18)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F19 != 0 { |
| if err := enc.NextField("F19"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F19)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F20 != 0 { |
| if err := enc.NextField("F20"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F20)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F21 != 0 { |
| if err := enc.NextField("F21"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F21)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F22 != 0 { |
| if err := enc.NextField("F22"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F22)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F23 != 0 { |
| if err := enc.NextField("F23"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F23)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F24 != 0 { |
| if err := enc.NextField("F24"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F24)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F25 != 0 { |
| if err := enc.NextField("F25"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F25)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F26 != 0 { |
| if err := enc.NextField("F26"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F26)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F27 != 0 { |
| if err := enc.NextField("F27"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F27)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F28 != 0 { |
| if err := enc.NextField("F28"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F28)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F29 != 0 { |
| if err := enc.NextField("F29"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F29)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F30 != 0 { |
| if err := enc.NextField("F30"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F30)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F31 != 0 { |
| if err := enc.NextField("F31"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F31)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F32 != 0 { |
| if err := enc.NextField("F32"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F32)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F33 != 0 { |
| if err := enc.NextField("F33"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F33)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F34 != 0 { |
| if err := enc.NextField("F34"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F34)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F35 != 0 { |
| if err := enc.NextField("F35"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F35)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F36 != 0 { |
| if err := enc.NextField("F36"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F36)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F37 != 0 { |
| if err := enc.NextField("F37"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F37)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F38 != 0 { |
| if err := enc.NextField("F38"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F38)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F39 != 0 { |
| if err := enc.NextField("F39"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F39)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F40 != 0 { |
| if err := enc.NextField("F40"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F40)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F41 != 0 { |
| if err := enc.NextField("F41"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F41)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F42 != 0 { |
| if err := enc.NextField("F42"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F42)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F43 != 0 { |
| if err := enc.NextField("F43"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F43)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F44 != 0 { |
| if err := enc.NextField("F44"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F44)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F45 != 0 { |
| if err := enc.NextField("F45"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F45)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F46 != 0 { |
| if err := enc.NextField("F46"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F46)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F47 != 0 { |
| if err := enc.NextField("F47"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F47)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F48 != 0 { |
| if err := enc.NextField("F48"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F48)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F49 != 0 { |
| if err := enc.NextField("F49"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F49)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.F50 != 0 { |
| if err := enc.NextField("F50"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.F50)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *VLargeStruct) VDLRead(dec vdl.Decoder) error { |
| *x = VLargeStruct{} |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) { |
| return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type()) |
| } |
| for { |
| f, err := dec.NextField() |
| if err != nil { |
| return err |
| } |
| switch f { |
| case "": |
| return dec.FinishValue() |
| case "F1": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F1 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F2": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F2 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F3": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F3 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F4": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F4 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F5": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F5 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F6": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F6 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F7": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F7 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F8": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F8 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F9": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F9 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F10": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F10 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F11": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F11 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F12": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F12 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F13": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F13 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F14": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F14 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F15": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F15 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F16": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F16 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F17": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F17 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F18": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F18 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F19": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F19 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F20": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F20 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F21": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F21 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F22": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F22 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F23": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F23 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F24": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F24 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F25": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F25 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F26": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F26 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F27": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F27 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F28": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F28 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F29": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F29 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F30": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F30 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F31": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F31 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F32": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F32 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F33": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F33 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F34": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F34 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F35": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F35 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F36": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F36 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F37": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F37 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F38": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F38 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F39": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F39 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F40": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F40 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F41": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F41 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F42": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F42 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F43": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F43 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F44": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F44 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F45": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F45 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F46": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F46 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F47": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F47 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F48": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F48 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F49": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F49 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "F50": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.F50 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| default: |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| type ( |
| // VSmallUnion represents any single field of the VSmallUnion union type. |
| VSmallUnion interface { |
| // Index returns the field index. |
| Index() int |
| // Interface returns the field value as an interface. |
| Interface() interface{} |
| // Name returns the field name. |
| Name() string |
| // __VDLReflect describes the VSmallUnion union type. |
| __VDLReflect(__VSmallUnionReflect) |
| VDLIsZero() bool |
| VDLWrite(vdl.Encoder) error |
| } |
| // VSmallUnionA represents field A of the VSmallUnion union type. |
| VSmallUnionA struct{ Value int32 } |
| // VSmallUnionB represents field B of the VSmallUnion union type. |
| VSmallUnionB struct{ Value string } |
| // VSmallUnionC represents field C of the VSmallUnion union type. |
| VSmallUnionC struct{ Value bool } |
| // __VSmallUnionReflect describes the VSmallUnion union type. |
| __VSmallUnionReflect struct { |
| Name string `vdl:"v.io/v23/vom/internal.VSmallUnion"` |
| Type VSmallUnion |
| Union struct { |
| A VSmallUnionA |
| B VSmallUnionB |
| C VSmallUnionC |
| } |
| } |
| ) |
| |
| func (x VSmallUnionA) Index() int { return 0 } |
| func (x VSmallUnionA) Interface() interface{} { return x.Value } |
| func (x VSmallUnionA) Name() string { return "A" } |
| func (x VSmallUnionA) __VDLReflect(__VSmallUnionReflect) {} |
| |
| func (x VSmallUnionB) Index() int { return 1 } |
| func (x VSmallUnionB) Interface() interface{} { return x.Value } |
| func (x VSmallUnionB) Name() string { return "B" } |
| func (x VSmallUnionB) __VDLReflect(__VSmallUnionReflect) {} |
| |
| func (x VSmallUnionC) Index() int { return 2 } |
| func (x VSmallUnionC) Interface() interface{} { return x.Value } |
| func (x VSmallUnionC) Name() string { return "C" } |
| func (x VSmallUnionC) __VDLReflect(__VSmallUnionReflect) {} |
| |
| func (x VSmallUnionA) VDLIsZero() bool { |
| return x.Value == 0 |
| } |
| |
| func (x VSmallUnionB) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x VSmallUnionC) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x VSmallUnionA) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*VSmallUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("A"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.Value)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x VSmallUnionB) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*VSmallUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("B"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.StringType); err != nil { |
| return err |
| } |
| if err := enc.EncodeString(x.Value); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x VSmallUnionC) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*VSmallUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("C"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.BoolType); err != nil { |
| return err |
| } |
| if err := enc.EncodeBool(x.Value); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func VDLReadVSmallUnion(dec vdl.Decoder, x *VSmallUnion) error { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(x), dec.Type()) { |
| return fmt.Errorf("incompatible union %T, from %v", x, dec.Type()) |
| } |
| f, err := dec.NextField() |
| if err != nil { |
| return err |
| } |
| switch f { |
| case "A": |
| var field VSmallUnionA |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| field.Value = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = field |
| case "B": |
| var field VSmallUnionB |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var err error |
| if field.Value, err = dec.DecodeString(); err != nil { |
| return err |
| } |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = field |
| case "C": |
| var field VSmallUnionC |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var err error |
| if field.Value, err = dec.DecodeBool(); err != nil { |
| return err |
| } |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = field |
| case "": |
| return fmt.Errorf("missing field in union %T, from %v", x, dec.Type()) |
| default: |
| return fmt.Errorf("field %q not in union %T, from %v", f, x, dec.Type()) |
| } |
| switch f, err := dec.NextField(); { |
| case err != nil: |
| return err |
| case f != "": |
| return fmt.Errorf("extra field %q in union %T, from %v", f, x, dec.Type()) |
| } |
| return dec.FinishValue() |
| } |
| |
| 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((*VNumber)(nil)) |
| vdl.Register((*VString)(nil)) |
| vdl.Register((*VEnum)(nil)) |
| vdl.Register((*VByteList)(nil)) |
| vdl.Register((*VByteArray)(nil)) |
| vdl.Register((*VArray)(nil)) |
| vdl.Register((*VList)(nil)) |
| vdl.Register((*VListAny)(nil)) |
| vdl.Register((*VSet)(nil)) |
| vdl.Register((*VMap)(nil)) |
| vdl.Register((*VSmallStruct)(nil)) |
| vdl.Register((*VLargeStruct)(nil)) |
| vdl.Register((*VSmallUnion)(nil)) |
| |
| return struct{}{} |
| } |