| // 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: testtypes |
| |
| package testtypes |
| |
| import ( |
| "fmt" |
| "v.io/v23/vdl" |
| ) |
| |
| var _ = __VDLInit() // Must be first; see __VDLInit comments for details. |
| |
| ////////////////////////////////////////////////// |
| // Type definitions |
| |
| type AnEnum int |
| |
| const ( |
| AnEnumFirst AnEnum = iota |
| AnEnumSecond |
| ) |
| |
| // AnEnumAll holds all labels for AnEnum. |
| var AnEnumAll = [...]AnEnum{AnEnumFirst, AnEnumSecond} |
| |
| // AnEnumFromString creates a AnEnum from a string label. |
| func AnEnumFromString(label string) (x AnEnum, err error) { |
| err = x.Set(label) |
| return |
| } |
| |
| // Set assigns label to x. |
| func (x *AnEnum) Set(label string) error { |
| switch label { |
| case "First", "first": |
| *x = AnEnumFirst |
| return nil |
| case "Second", "second": |
| *x = AnEnumSecond |
| return nil |
| } |
| *x = -1 |
| return fmt.Errorf("unknown label %q in testtypes.AnEnum", label) |
| } |
| |
| // String returns the string label of x. |
| func (x AnEnum) String() string { |
| switch x { |
| case AnEnumFirst: |
| return "First" |
| case AnEnumSecond: |
| return "Second" |
| } |
| return "" |
| } |
| |
| func (AnEnum) __VDLReflect(struct { |
| Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.AnEnum"` |
| Enum struct{ First, Second string } |
| }) { |
| } |
| |
| func (m *AnEnum) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| if err := t.FromEnumLabel((*m).String(), tt); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (m *AnEnum) MakeVDLTarget() vdl.Target { |
| return &AnEnumTarget{Value: m} |
| } |
| |
| type AnEnumTarget struct { |
| Value *AnEnum |
| vdl.TargetBase |
| } |
| |
| func (t *AnEnumTarget) FromEnumLabel(src string, tt *vdl.Type) error { |
| |
| if ttWant := vdl.TypeOf((*AnEnum)(nil)); !vdl.Compatible(tt, ttWant) { |
| return fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| switch src { |
| case "First": |
| *t.Value = 0 |
| case "Second": |
| *t.Value = 1 |
| default: |
| return fmt.Errorf("label %s not in enum AnEnum", src) |
| } |
| |
| return nil |
| } |
| |
| func (x AnEnum) VDLIsZero() bool { |
| return x == AnEnumFirst |
| } |
| |
| func (x AnEnum) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*AnEnum)(nil))); err != nil { |
| return err |
| } |
| if err := enc.EncodeString(x.String()); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *AnEnum) 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 ( |
| // PodUnion represents any single field of the PodUnion union type. |
| PodUnion 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 PodUnion union type. |
| __VDLReflect(__PodUnionReflect) |
| FillVDLTarget(vdl.Target, *vdl.Type) error |
| VDLIsZero() bool |
| VDLWrite(vdl.Encoder) error |
| } |
| // PodUnionFInt8 represents field FInt8 of the PodUnion union type. |
| PodUnionFInt8 struct{ Value int8 } |
| // PodUnionFInt8Other represents field FInt8Other of the PodUnion union type. |
| PodUnionFInt8Other struct{ Value int8 } |
| // PodUnionFUint8 represents field FUint8 of the PodUnion union type. |
| PodUnionFUint8 struct{ Value byte } |
| // PodUnionFInt16 represents field FInt16 of the PodUnion union type. |
| PodUnionFInt16 struct{ Value int16 } |
| // PodUnionFUint16 represents field FUint16 of the PodUnion union type. |
| PodUnionFUint16 struct{ Value uint16 } |
| // PodUnionFint32 represents field Fint32 of the PodUnion union type. |
| PodUnionFint32 struct{ Value int32 } |
| // PodUnionFuint32 represents field Fuint32 of the PodUnion union type. |
| PodUnionFuint32 struct{ Value uint32 } |
| // PodUnionFInt64 represents field FInt64 of the PodUnion union type. |
| PodUnionFInt64 struct{ Value int64 } |
| // PodUnionFUint64 represents field FUint64 of the PodUnion union type. |
| PodUnionFUint64 struct{ Value uint64 } |
| // PodUnionFFloat represents field FFloat of the PodUnion union type. |
| PodUnionFFloat struct{ Value float32 } |
| // PodUnionFDouble represents field FDouble of the PodUnion union type. |
| PodUnionFDouble struct{ Value float64 } |
| // PodUnionFBool represents field FBool of the PodUnion union type. |
| PodUnionFBool struct{ Value bool } |
| // PodUnionFEnum represents field FEnum of the PodUnion union type. |
| PodUnionFEnum struct{ Value AnEnum } |
| // __PodUnionReflect describes the PodUnion union type. |
| __PodUnionReflect struct { |
| Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.PodUnion"` |
| Type PodUnion |
| UnionTargetFactory podUnionTargetFactory |
| Union struct { |
| FInt8 PodUnionFInt8 |
| FInt8Other PodUnionFInt8Other |
| FUint8 PodUnionFUint8 |
| FInt16 PodUnionFInt16 |
| FUint16 PodUnionFUint16 |
| Fint32 PodUnionFint32 |
| Fuint32 PodUnionFuint32 |
| FInt64 PodUnionFInt64 |
| FUint64 PodUnionFUint64 |
| FFloat PodUnionFFloat |
| FDouble PodUnionFDouble |
| FBool PodUnionFBool |
| FEnum PodUnionFEnum |
| } |
| } |
| ) |
| |
| func (x PodUnionFInt8) Index() int { return 0 } |
| func (x PodUnionFInt8) Interface() interface{} { return x.Value } |
| func (x PodUnionFInt8) Name() string { return "FInt8" } |
| func (x PodUnionFInt8) __VDLReflect(__PodUnionReflect) {} |
| |
| func (m PodUnionFInt8) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt8") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromInt(int64(m.Value), tt.NonOptional().Field(0).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m PodUnionFInt8) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x PodUnionFInt8Other) Index() int { return 1 } |
| func (x PodUnionFInt8Other) Interface() interface{} { return x.Value } |
| func (x PodUnionFInt8Other) Name() string { return "FInt8Other" } |
| func (x PodUnionFInt8Other) __VDLReflect(__PodUnionReflect) {} |
| |
| func (m PodUnionFInt8Other) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt8Other") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromInt(int64(m.Value), tt.NonOptional().Field(1).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m PodUnionFInt8Other) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x PodUnionFUint8) Index() int { return 2 } |
| func (x PodUnionFUint8) Interface() interface{} { return x.Value } |
| func (x PodUnionFUint8) Name() string { return "FUint8" } |
| func (x PodUnionFUint8) __VDLReflect(__PodUnionReflect) {} |
| |
| func (m PodUnionFUint8) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FUint8") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromUint(uint64(m.Value), tt.NonOptional().Field(2).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m PodUnionFUint8) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x PodUnionFInt16) Index() int { return 3 } |
| func (x PodUnionFInt16) Interface() interface{} { return x.Value } |
| func (x PodUnionFInt16) Name() string { return "FInt16" } |
| func (x PodUnionFInt16) __VDLReflect(__PodUnionReflect) {} |
| |
| func (m PodUnionFInt16) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt16") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromInt(int64(m.Value), tt.NonOptional().Field(3).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m PodUnionFInt16) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x PodUnionFUint16) Index() int { return 4 } |
| func (x PodUnionFUint16) Interface() interface{} { return x.Value } |
| func (x PodUnionFUint16) Name() string { return "FUint16" } |
| func (x PodUnionFUint16) __VDLReflect(__PodUnionReflect) {} |
| |
| func (m PodUnionFUint16) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FUint16") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromUint(uint64(m.Value), tt.NonOptional().Field(4).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m PodUnionFUint16) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x PodUnionFint32) Index() int { return 5 } |
| func (x PodUnionFint32) Interface() interface{} { return x.Value } |
| func (x PodUnionFint32) Name() string { return "Fint32" } |
| func (x PodUnionFint32) __VDLReflect(__PodUnionReflect) {} |
| |
| func (m PodUnionFint32) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Fint32") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromInt(int64(m.Value), tt.NonOptional().Field(5).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m PodUnionFint32) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x PodUnionFuint32) Index() int { return 6 } |
| func (x PodUnionFuint32) Interface() interface{} { return x.Value } |
| func (x PodUnionFuint32) Name() string { return "Fuint32" } |
| func (x PodUnionFuint32) __VDLReflect(__PodUnionReflect) {} |
| |
| func (m PodUnionFuint32) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Fuint32") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromUint(uint64(m.Value), tt.NonOptional().Field(6).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m PodUnionFuint32) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x PodUnionFInt64) Index() int { return 7 } |
| func (x PodUnionFInt64) Interface() interface{} { return x.Value } |
| func (x PodUnionFInt64) Name() string { return "FInt64" } |
| func (x PodUnionFInt64) __VDLReflect(__PodUnionReflect) {} |
| |
| func (m PodUnionFInt64) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt64") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromInt(int64(m.Value), tt.NonOptional().Field(7).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m PodUnionFInt64) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x PodUnionFUint64) Index() int { return 8 } |
| func (x PodUnionFUint64) Interface() interface{} { return x.Value } |
| func (x PodUnionFUint64) Name() string { return "FUint64" } |
| func (x PodUnionFUint64) __VDLReflect(__PodUnionReflect) {} |
| |
| func (m PodUnionFUint64) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FUint64") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromUint(uint64(m.Value), tt.NonOptional().Field(8).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m PodUnionFUint64) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x PodUnionFFloat) Index() int { return 9 } |
| func (x PodUnionFFloat) Interface() interface{} { return x.Value } |
| func (x PodUnionFFloat) Name() string { return "FFloat" } |
| func (x PodUnionFFloat) __VDLReflect(__PodUnionReflect) {} |
| |
| func (m PodUnionFFloat) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FFloat") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromFloat(float64(m.Value), tt.NonOptional().Field(9).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m PodUnionFFloat) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x PodUnionFDouble) Index() int { return 10 } |
| func (x PodUnionFDouble) Interface() interface{} { return x.Value } |
| func (x PodUnionFDouble) Name() string { return "FDouble" } |
| func (x PodUnionFDouble) __VDLReflect(__PodUnionReflect) {} |
| |
| func (m PodUnionFDouble) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FDouble") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromFloat(float64(m.Value), tt.NonOptional().Field(10).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m PodUnionFDouble) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x PodUnionFBool) Index() int { return 11 } |
| func (x PodUnionFBool) Interface() interface{} { return x.Value } |
| func (x PodUnionFBool) Name() string { return "FBool" } |
| func (x PodUnionFBool) __VDLReflect(__PodUnionReflect) {} |
| |
| func (m PodUnionFBool) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FBool") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromBool(bool(m.Value), tt.NonOptional().Field(11).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m PodUnionFBool) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x PodUnionFEnum) Index() int { return 12 } |
| func (x PodUnionFEnum) Interface() interface{} { return x.Value } |
| func (x PodUnionFEnum) Name() string { return "FEnum" } |
| func (x PodUnionFEnum) __VDLReflect(__PodUnionReflect) {} |
| |
| func (m PodUnionFEnum) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FEnum") |
| if err != nil { |
| return err |
| } |
| |
| if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(12).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m PodUnionFEnum) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| type PodUnionTarget struct { |
| Value *PodUnion |
| fieldName string |
| |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *PodUnionTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| if ttWant := vdl.TypeOf((*PodUnion)(nil)); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| |
| return t, nil |
| } |
| func (t *PodUnionTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| t.fieldName = name |
| switch name { |
| case "FInt8": |
| val := int8(0) |
| return nil, &vdl.Int8Target{Value: &val}, nil |
| case "FInt8Other": |
| val := int8(0) |
| return nil, &vdl.Int8Target{Value: &val}, nil |
| case "FUint8": |
| val := byte(0) |
| return nil, &vdl.ByteTarget{Value: &val}, nil |
| case "FInt16": |
| val := int16(0) |
| return nil, &vdl.Int16Target{Value: &val}, nil |
| case "FUint16": |
| val := uint16(0) |
| return nil, &vdl.Uint16Target{Value: &val}, nil |
| case "Fint32": |
| val := int32(0) |
| return nil, &vdl.Int32Target{Value: &val}, nil |
| case "Fuint32": |
| val := uint32(0) |
| return nil, &vdl.Uint32Target{Value: &val}, nil |
| case "FInt64": |
| val := int64(0) |
| return nil, &vdl.Int64Target{Value: &val}, nil |
| case "FUint64": |
| val := uint64(0) |
| return nil, &vdl.Uint64Target{Value: &val}, nil |
| case "FFloat": |
| val := float32(0) |
| return nil, &vdl.Float32Target{Value: &val}, nil |
| case "FDouble": |
| val := float64(0) |
| return nil, &vdl.Float64Target{Value: &val}, nil |
| case "FBool": |
| val := false |
| return nil, &vdl.BoolTarget{Value: &val}, nil |
| case "FEnum": |
| val := AnEnumFirst |
| return nil, &AnEnumTarget{Value: &val}, nil |
| default: |
| return nil, nil, fmt.Errorf("field %s not in union src/v.io/x/mojo/transcoder/testtypes.PodUnion", name) |
| } |
| } |
| func (t *PodUnionTarget) FinishField(_, fieldTarget vdl.Target) error { |
| switch t.fieldName { |
| case "FInt8": |
| *t.Value = PodUnionFInt8{*(fieldTarget.(*vdl.Int8Target)).Value} |
| case "FInt8Other": |
| *t.Value = PodUnionFInt8Other{*(fieldTarget.(*vdl.Int8Target)).Value} |
| case "FUint8": |
| *t.Value = PodUnionFUint8{*(fieldTarget.(*vdl.ByteTarget)).Value} |
| case "FInt16": |
| *t.Value = PodUnionFInt16{*(fieldTarget.(*vdl.Int16Target)).Value} |
| case "FUint16": |
| *t.Value = PodUnionFUint16{*(fieldTarget.(*vdl.Uint16Target)).Value} |
| case "Fint32": |
| *t.Value = PodUnionFint32{*(fieldTarget.(*vdl.Int32Target)).Value} |
| case "Fuint32": |
| *t.Value = PodUnionFuint32{*(fieldTarget.(*vdl.Uint32Target)).Value} |
| case "FInt64": |
| *t.Value = PodUnionFInt64{*(fieldTarget.(*vdl.Int64Target)).Value} |
| case "FUint64": |
| *t.Value = PodUnionFUint64{*(fieldTarget.(*vdl.Uint64Target)).Value} |
| case "FFloat": |
| *t.Value = PodUnionFFloat{*(fieldTarget.(*vdl.Float32Target)).Value} |
| case "FDouble": |
| *t.Value = PodUnionFDouble{*(fieldTarget.(*vdl.Float64Target)).Value} |
| case "FBool": |
| *t.Value = PodUnionFBool{*(fieldTarget.(*vdl.BoolTarget)).Value} |
| case "FEnum": |
| *t.Value = PodUnionFEnum{*(fieldTarget.(*AnEnumTarget)).Value} |
| } |
| return nil |
| } |
| func (t *PodUnionTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| type podUnionTargetFactory struct{} |
| |
| func (t podUnionTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) { |
| if typedUnion, ok := union.(*PodUnion); ok { |
| return &PodUnionTarget{Value: typedUnion}, nil |
| } |
| return nil, fmt.Errorf("got %T, want *PodUnion", union) |
| } |
| |
| func (x PodUnionFInt8) VDLIsZero() bool { |
| return x.Value == 0 |
| } |
| |
| func (x PodUnionFInt8Other) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x PodUnionFUint8) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x PodUnionFInt16) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x PodUnionFUint16) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x PodUnionFint32) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x PodUnionFuint32) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x PodUnionFInt64) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x PodUnionFUint64) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x PodUnionFFloat) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x PodUnionFDouble) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x PodUnionFBool) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x PodUnionFEnum) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x PodUnionFInt8) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FInt8"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int8Type); 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 PodUnionFInt8Other) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FInt8Other"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int8Type); 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 PodUnionFUint8) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FUint8"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.ByteType); err != nil { |
| return err |
| } |
| if err := enc.EncodeUint(uint64(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 PodUnionFInt16) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FInt16"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int16Type); 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 PodUnionFUint16) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FUint16"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Uint16Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeUint(uint64(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 PodUnionFint32) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("Fint32"); 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 PodUnionFuint32) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("Fuint32"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Uint32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeUint(uint64(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 PodUnionFInt64) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FInt64"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int64Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(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 PodUnionFUint64) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FUint64"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Uint64Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeUint(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 PodUnionFFloat) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FFloat"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Float32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeFloat(float64(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 PodUnionFDouble) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FDouble"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Float64Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeFloat(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 PodUnionFBool) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FBool"); 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 (x PodUnionFEnum) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FEnum"); err != nil { |
| return err |
| } |
| if err := x.Value.VDLWrite(enc); err != nil { |
| return err |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func VDLReadPodUnion(dec vdl.Decoder, x *PodUnion) 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 "FInt8": |
| var field PodUnionFInt8 |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(8) |
| if err != nil { |
| return err |
| } |
| field.Value = int8(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = field |
| case "FInt8Other": |
| var field PodUnionFInt8Other |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(8) |
| if err != nil { |
| return err |
| } |
| field.Value = int8(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = field |
| case "FUint8": |
| var field PodUnionFUint8 |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeUint(8) |
| if err != nil { |
| return err |
| } |
| field.Value = byte(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = field |
| case "FInt16": |
| var field PodUnionFInt16 |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(16) |
| if err != nil { |
| return err |
| } |
| field.Value = int16(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = field |
| case "FUint16": |
| var field PodUnionFUint16 |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeUint(16) |
| if err != nil { |
| return err |
| } |
| field.Value = uint16(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = field |
| case "Fint32": |
| var field PodUnionFint32 |
| 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 "Fuint32": |
| var field PodUnionFuint32 |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeUint(32) |
| if err != nil { |
| return err |
| } |
| field.Value = uint32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = field |
| case "FInt64": |
| var field PodUnionFInt64 |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var err error |
| if field.Value, err = dec.DecodeInt(64); err != nil { |
| return err |
| } |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = field |
| case "FUint64": |
| var field PodUnionFUint64 |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var err error |
| if field.Value, err = dec.DecodeUint(64); err != nil { |
| return err |
| } |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = field |
| case "FFloat": |
| var field PodUnionFFloat |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeFloat(32) |
| if err != nil { |
| return err |
| } |
| field.Value = float32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = field |
| case "FDouble": |
| var field PodUnionFDouble |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var err error |
| if field.Value, err = dec.DecodeFloat(64); err != nil { |
| return err |
| } |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = field |
| case "FBool": |
| var field PodUnionFBool |
| 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 "FEnum": |
| var field PodUnionFEnum |
| if err := field.Value.VDLRead(dec); 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() |
| } |
| |
| type PodUnionWrapper struct { |
| PodUnion PodUnion |
| } |
| |
| func (PodUnionWrapper) __VDLReflect(struct { |
| Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.PodUnionWrapper"` |
| }) { |
| } |
| |
| func (m *PodUnionWrapper) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| var var4 bool |
| if field, ok := m.PodUnion.(PodUnionFInt8); ok { |
| |
| var5 := (field.Value == int8(0)) |
| var4 = var5 |
| } |
| if var4 { |
| if err := fieldsTarget1.ZeroField("PodUnion"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("PodUnion") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| |
| unionValue6 := m.PodUnion |
| if unionValue6 == nil { |
| unionValue6 = PodUnionFInt8{} |
| } |
| if err := unionValue6.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| } |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (m *PodUnionWrapper) MakeVDLTarget() vdl.Target { |
| return &PodUnionWrapperTarget{Value: m} |
| } |
| |
| type PodUnionWrapperTarget struct { |
| Value *PodUnionWrapper |
| podUnionTarget PodUnionTarget |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *PodUnionWrapperTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*PodUnionWrapper)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *PodUnionWrapperTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| switch name { |
| case "PodUnion": |
| t.podUnionTarget.Value = &t.Value.PodUnion |
| target, err := &t.podUnionTarget, error(nil) |
| return nil, target, err |
| default: |
| return nil, nil, vdl.ErrFieldNoExist |
| } |
| } |
| func (t *PodUnionWrapperTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *PodUnionWrapperTarget) ZeroField(name string) error { |
| switch name { |
| case "PodUnion": |
| t.Value.PodUnion = PodUnion(PodUnionFInt8{}) |
| return nil |
| default: |
| return vdl.ErrFieldNoExist |
| } |
| } |
| func (t *PodUnionWrapperTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| func (x PodUnionWrapper) VDLIsZero() bool { |
| if x.PodUnion != nil && !x.PodUnion.VDLIsZero() { |
| return false |
| } |
| return true |
| } |
| |
| func (x PodUnionWrapper) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*PodUnionWrapper)(nil)).Elem()); err != nil { |
| return err |
| } |
| if x.PodUnion != nil && !x.PodUnion.VDLIsZero() { |
| if err := enc.NextField("PodUnion"); err != nil { |
| return err |
| } |
| if err := x.PodUnion.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *PodUnionWrapper) VDLRead(dec vdl.Decoder) error { |
| *x = PodUnionWrapper{ |
| PodUnion: PodUnionFInt8{}, |
| } |
| 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 "PodUnion": |
| if err := VDLReadPodUnion(dec, &x.PodUnion); err != nil { |
| return err |
| } |
| default: |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| type DummyStruct struct { |
| FInt8 int8 |
| } |
| |
| func (DummyStruct) __VDLReflect(struct { |
| Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.DummyStruct"` |
| }) { |
| } |
| |
| func (m *DummyStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| var4 := (m.FInt8 == int8(0)) |
| if var4 { |
| if err := fieldsTarget1.ZeroField("FInt8"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt8") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromInt(int64(m.FInt8), tt.NonOptional().Field(0).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| } |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (m *DummyStruct) MakeVDLTarget() vdl.Target { |
| return &DummyStructTarget{Value: m} |
| } |
| |
| type DummyStructTarget struct { |
| Value *DummyStruct |
| fInt8Target vdl.Int8Target |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *DummyStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*DummyStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *DummyStructTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| switch name { |
| case "FInt8": |
| t.fInt8Target.Value = &t.Value.FInt8 |
| target, err := &t.fInt8Target, error(nil) |
| return nil, target, err |
| default: |
| return nil, nil, vdl.ErrFieldNoExist |
| } |
| } |
| func (t *DummyStructTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *DummyStructTarget) ZeroField(name string) error { |
| switch name { |
| case "FInt8": |
| t.Value.FInt8 = int8(0) |
| return nil |
| default: |
| return vdl.ErrFieldNoExist |
| } |
| } |
| func (t *DummyStructTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| func (x DummyStruct) VDLIsZero() bool { |
| return x == DummyStruct{} |
| } |
| |
| func (x DummyStruct) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*DummyStruct)(nil)).Elem()); err != nil { |
| return err |
| } |
| if x.FInt8 != 0 { |
| if err := enc.NextField("FInt8"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int8Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.FInt8)); 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 *DummyStruct) VDLRead(dec vdl.Decoder) error { |
| *x = DummyStruct{} |
| 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 "FInt8": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(8) |
| if err != nil { |
| return err |
| } |
| x.FInt8 = int8(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| default: |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| type ( |
| // ObjectUnion represents any single field of the ObjectUnion union type. |
| ObjectUnion 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 ObjectUnion union type. |
| __VDLReflect(__ObjectUnionReflect) |
| FillVDLTarget(vdl.Target, *vdl.Type) error |
| VDLIsZero() bool |
| VDLWrite(vdl.Encoder) error |
| } |
| // ObjectUnionFInt8 represents field FInt8 of the ObjectUnion union type. |
| ObjectUnionFInt8 struct{ Value int8 } |
| // ObjectUnionFString represents field FString of the ObjectUnion union type. |
| ObjectUnionFString struct{ Value string } |
| // ObjectUnionFDummy represents field FDummy of the ObjectUnion union type. |
| ObjectUnionFDummy struct{ Value DummyStruct } |
| // ObjectUnionFNullable represents field FNullable of the ObjectUnion union type. |
| ObjectUnionFNullable struct{ Value *DummyStruct } |
| // ObjectUnionFArrayInt8 represents field FArrayInt8 of the ObjectUnion union type. |
| ObjectUnionFArrayInt8 struct{ Value []int8 } |
| // ObjectUnionFMapInt8 represents field FMapInt8 of the ObjectUnion union type. |
| ObjectUnionFMapInt8 struct{ Value map[string]int8 } |
| // ObjectUnionFPodUnion represents field FPodUnion of the ObjectUnion union type. |
| ObjectUnionFPodUnion struct{ Value PodUnion } |
| // __ObjectUnionReflect describes the ObjectUnion union type. |
| __ObjectUnionReflect struct { |
| Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.ObjectUnion"` |
| Type ObjectUnion |
| UnionTargetFactory objectUnionTargetFactory |
| Union struct { |
| FInt8 ObjectUnionFInt8 |
| FString ObjectUnionFString |
| FDummy ObjectUnionFDummy |
| FNullable ObjectUnionFNullable |
| FArrayInt8 ObjectUnionFArrayInt8 |
| FMapInt8 ObjectUnionFMapInt8 |
| FPodUnion ObjectUnionFPodUnion |
| } |
| } |
| ) |
| |
| func (x ObjectUnionFInt8) Index() int { return 0 } |
| func (x ObjectUnionFInt8) Interface() interface{} { return x.Value } |
| func (x ObjectUnionFInt8) Name() string { return "FInt8" } |
| func (x ObjectUnionFInt8) __VDLReflect(__ObjectUnionReflect) {} |
| |
| func (m ObjectUnionFInt8) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt8") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromInt(int64(m.Value), tt.NonOptional().Field(0).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m ObjectUnionFInt8) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x ObjectUnionFString) Index() int { return 1 } |
| func (x ObjectUnionFString) Interface() interface{} { return x.Value } |
| func (x ObjectUnionFString) Name() string { return "FString" } |
| func (x ObjectUnionFString) __VDLReflect(__ObjectUnionReflect) {} |
| |
| func (m ObjectUnionFString) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FString") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromString(string(m.Value), tt.NonOptional().Field(1).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m ObjectUnionFString) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x ObjectUnionFDummy) Index() int { return 2 } |
| func (x ObjectUnionFDummy) Interface() interface{} { return x.Value } |
| func (x ObjectUnionFDummy) Name() string { return "FDummy" } |
| func (x ObjectUnionFDummy) __VDLReflect(__ObjectUnionReflect) {} |
| |
| func (m ObjectUnionFDummy) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FDummy") |
| if err != nil { |
| return err |
| } |
| |
| if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(2).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m ObjectUnionFDummy) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x ObjectUnionFNullable) Index() int { return 3 } |
| func (x ObjectUnionFNullable) Interface() interface{} { return x.Value } |
| func (x ObjectUnionFNullable) Name() string { return "FNullable" } |
| func (x ObjectUnionFNullable) __VDLReflect(__ObjectUnionReflect) {} |
| |
| func (m ObjectUnionFNullable) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FNullable") |
| if err != nil { |
| return err |
| } |
| |
| if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(3).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m ObjectUnionFNullable) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x ObjectUnionFArrayInt8) Index() int { return 4 } |
| func (x ObjectUnionFArrayInt8) Interface() interface{} { return x.Value } |
| func (x ObjectUnionFArrayInt8) Name() string { return "FArrayInt8" } |
| func (x ObjectUnionFArrayInt8) __VDLReflect(__ObjectUnionReflect) {} |
| |
| func (m ObjectUnionFArrayInt8) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FArrayInt8") |
| if err != nil { |
| return err |
| } |
| |
| listTarget4, err := fieldTarget3.StartList(tt.NonOptional().Field(4).Type, len(m.Value)) |
| if err != nil { |
| return err |
| } |
| for i, elem6 := range m.Value { |
| elemTarget5, err := listTarget4.StartElem(i) |
| if err != nil { |
| return err |
| } |
| if err := elemTarget5.FromInt(int64(elem6), tt.NonOptional().Field(4).Type.Elem()); err != nil { |
| return err |
| } |
| if err := listTarget4.FinishElem(elemTarget5); err != nil { |
| return err |
| } |
| } |
| if err := fieldTarget3.FinishList(listTarget4); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m ObjectUnionFArrayInt8) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x ObjectUnionFMapInt8) Index() int { return 5 } |
| func (x ObjectUnionFMapInt8) Interface() interface{} { return x.Value } |
| func (x ObjectUnionFMapInt8) Name() string { return "FMapInt8" } |
| func (x ObjectUnionFMapInt8) __VDLReflect(__ObjectUnionReflect) {} |
| |
| func (m ObjectUnionFMapInt8) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FMapInt8") |
| if err != nil { |
| return err |
| } |
| |
| mapTarget4, err := fieldTarget3.StartMap(tt.NonOptional().Field(5).Type, len(m.Value)) |
| if err != nil { |
| return err |
| } |
| for key6, value8 := range m.Value { |
| keyTarget5, err := mapTarget4.StartKey() |
| if err != nil { |
| return err |
| } |
| if err := keyTarget5.FromString(string(key6), tt.NonOptional().Field(5).Type.Key()); err != nil { |
| return err |
| } |
| valueTarget7, err := mapTarget4.FinishKeyStartField(keyTarget5) |
| if err != nil { |
| return err |
| } |
| if err := valueTarget7.FromInt(int64(value8), tt.NonOptional().Field(5).Type.Elem()); err != nil { |
| return err |
| } |
| if err := mapTarget4.FinishField(keyTarget5, valueTarget7); err != nil { |
| return err |
| } |
| } |
| if err := fieldTarget3.FinishMap(mapTarget4); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m ObjectUnionFMapInt8) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x ObjectUnionFPodUnion) Index() int { return 6 } |
| func (x ObjectUnionFPodUnion) Interface() interface{} { return x.Value } |
| func (x ObjectUnionFPodUnion) Name() string { return "FPodUnion" } |
| func (x ObjectUnionFPodUnion) __VDLReflect(__ObjectUnionReflect) {} |
| |
| func (m ObjectUnionFPodUnion) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FPodUnion") |
| if err != nil { |
| return err |
| } |
| |
| unionValue4 := m.Value |
| if unionValue4 == nil { |
| unionValue4 = PodUnionFInt8{} |
| } |
| if err := unionValue4.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(6).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m ObjectUnionFPodUnion) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| type ObjectUnionTarget struct { |
| Value *ObjectUnion |
| fieldName string |
| |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *ObjectUnionTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| if ttWant := vdl.TypeOf((*ObjectUnion)(nil)); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| |
| return t, nil |
| } |
| func (t *ObjectUnionTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| t.fieldName = name |
| switch name { |
| case "FInt8": |
| val := int8(0) |
| return nil, &vdl.Int8Target{Value: &val}, nil |
| case "FString": |
| val := "" |
| return nil, &vdl.StringTarget{Value: &val}, nil |
| case "FDummy": |
| val := DummyStruct{} |
| return nil, &DummyStructTarget{Value: &val}, nil |
| case "FNullable": |
| val := (*DummyStruct)(nil) |
| return nil, &__VDLTarget1_optional{Value: &val}, nil |
| case "FArrayInt8": |
| val := []int8(nil) |
| return nil, &__VDLTarget2_list{Value: &val}, nil |
| case "FMapInt8": |
| val := map[string]int8(nil) |
| return nil, &__VDLTarget3_map{Value: &val}, nil |
| case "FPodUnion": |
| val := PodUnion(PodUnionFInt8{}) |
| return nil, &PodUnionTarget{Value: &val}, nil |
| default: |
| return nil, nil, fmt.Errorf("field %s not in union src/v.io/x/mojo/transcoder/testtypes.ObjectUnion", name) |
| } |
| } |
| func (t *ObjectUnionTarget) FinishField(_, fieldTarget vdl.Target) error { |
| switch t.fieldName { |
| case "FInt8": |
| *t.Value = ObjectUnionFInt8{*(fieldTarget.(*vdl.Int8Target)).Value} |
| case "FString": |
| *t.Value = ObjectUnionFString{*(fieldTarget.(*vdl.StringTarget)).Value} |
| case "FDummy": |
| *t.Value = ObjectUnionFDummy{*(fieldTarget.(*DummyStructTarget)).Value} |
| case "FNullable": |
| *t.Value = ObjectUnionFNullable{*(fieldTarget.(*__VDLTarget1_optional)).Value} |
| case "FArrayInt8": |
| *t.Value = ObjectUnionFArrayInt8{*(fieldTarget.(*__VDLTarget2_list)).Value} |
| case "FMapInt8": |
| *t.Value = ObjectUnionFMapInt8{*(fieldTarget.(*__VDLTarget3_map)).Value} |
| case "FPodUnion": |
| *t.Value = ObjectUnionFPodUnion{*(fieldTarget.(*PodUnionTarget)).Value} |
| } |
| return nil |
| } |
| func (t *ObjectUnionTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| type objectUnionTargetFactory struct{} |
| |
| func (t objectUnionTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) { |
| if typedUnion, ok := union.(*ObjectUnion); ok { |
| return &ObjectUnionTarget{Value: typedUnion}, nil |
| } |
| return nil, fmt.Errorf("got %T, want *ObjectUnion", union) |
| } |
| |
| // Optional DummyStruct |
| type __VDLTarget1_optional struct { |
| Value **DummyStruct |
| elemTarget DummyStructTarget |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *__VDLTarget1_optional) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if *t.Value == nil { |
| *t.Value = &DummyStruct{} |
| } |
| t.elemTarget.Value = *t.Value |
| target, err := &t.elemTarget, error(nil) |
| if err != nil { |
| return nil, err |
| } |
| return target.StartFields(tt) |
| } |
| func (t *__VDLTarget1_optional) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| func (t *__VDLTarget1_optional) FromNil(tt *vdl.Type) error { |
| *t.Value = (*DummyStruct)(nil) |
| return nil |
| } |
| |
| // []int8 |
| type __VDLTarget2_list struct { |
| Value *[]int8 |
| elemTarget vdl.Int8Target |
| vdl.TargetBase |
| vdl.ListTargetBase |
| } |
| |
| func (t *__VDLTarget2_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*[]int8)(nil)); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| if cap(*t.Value) < len { |
| *t.Value = make([]int8, len) |
| } else { |
| *t.Value = (*t.Value)[:len] |
| } |
| return t, nil |
| } |
| func (t *__VDLTarget2_list) StartElem(index int) (elem vdl.Target, _ error) { |
| t.elemTarget.Value = &(*t.Value)[index] |
| target, err := &t.elemTarget, error(nil) |
| return target, err |
| } |
| func (t *__VDLTarget2_list) FinishElem(elem vdl.Target) error { |
| return nil |
| } |
| func (t *__VDLTarget2_list) FinishList(elem vdl.ListTarget) error { |
| |
| return nil |
| } |
| |
| // map[string]int8 |
| type __VDLTarget3_map struct { |
| Value *map[string]int8 |
| currKey string |
| currElem int8 |
| keyTarget vdl.StringTarget |
| elemTarget vdl.Int8Target |
| vdl.TargetBase |
| vdl.MapTargetBase |
| } |
| |
| func (t *__VDLTarget3_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*map[string]int8)(nil)); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| *t.Value = make(map[string]int8) |
| return t, nil |
| } |
| func (t *__VDLTarget3_map) StartKey() (key vdl.Target, _ error) { |
| t.currKey = "" |
| t.keyTarget.Value = &t.currKey |
| target, err := &t.keyTarget, error(nil) |
| return target, err |
| } |
| func (t *__VDLTarget3_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) { |
| t.currElem = int8(0) |
| t.elemTarget.Value = &t.currElem |
| target, err := &t.elemTarget, error(nil) |
| return target, err |
| } |
| func (t *__VDLTarget3_map) FinishField(key, field vdl.Target) error { |
| (*t.Value)[t.currKey] = t.currElem |
| return nil |
| } |
| func (t *__VDLTarget3_map) FinishMap(elem vdl.MapTarget) error { |
| if len(*t.Value) == 0 { |
| *t.Value = nil |
| } |
| |
| return nil |
| } |
| |
| func (x ObjectUnionFInt8) VDLIsZero() bool { |
| return x.Value == 0 |
| } |
| |
| func (x ObjectUnionFString) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x ObjectUnionFDummy) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x ObjectUnionFNullable) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x ObjectUnionFArrayInt8) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x ObjectUnionFMapInt8) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x ObjectUnionFPodUnion) VDLIsZero() bool { |
| return false |
| } |
| |
| func (x ObjectUnionFInt8) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FInt8"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int8Type); 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 ObjectUnionFString) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FString"); 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 ObjectUnionFDummy) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FDummy"); err != nil { |
| return err |
| } |
| if err := x.Value.VDLWrite(enc); err != nil { |
| return err |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x ObjectUnionFNullable) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FNullable"); err != nil { |
| return err |
| } |
| if x.Value == nil { |
| if err := enc.NilValue(vdl.TypeOf((**DummyStruct)(nil))); err != nil { |
| return err |
| } |
| } else { |
| enc.SetNextStartValueIsOptional() |
| |
| if err := x.Value.VDLWrite(enc); err != nil { |
| return err |
| } |
| |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x ObjectUnionFArrayInt8) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FArrayInt8"); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_list_1(enc, x.Value); err != nil { |
| return err |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x ObjectUnionFMapInt8) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FMapInt8"); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_map_2(enc, x.Value); err != nil { |
| return err |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x ObjectUnionFPodUnion) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil { |
| return err |
| } |
| if err := enc.NextField("FPodUnion"); err != nil { |
| return err |
| } |
| switch { |
| case x.Value == nil: |
| // Write the zero value of the union type. |
| if err := vdl.ZeroValue(vdl.TypeOf((*PodUnion)(nil))).VDLWrite(enc); err != nil { |
| return err |
| } |
| default: |
| if err := x.Value.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func __VDLWriteAnon_list_1(enc vdl.Encoder, x []int8) error { |
| if err := enc.StartValue(vdl.TypeOf((*[]int8)(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.Int8Type); 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 __VDLWriteAnon_map_2(enc vdl.Encoder, x map[string]int8) error { |
| if err := enc.StartValue(vdl.TypeOf((*map[string]int8)(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.Int8Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(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 VDLReadObjectUnion(dec vdl.Decoder, x *ObjectUnion) 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 "FInt8": |
| var field ObjectUnionFInt8 |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(8) |
| if err != nil { |
| return err |
| } |
| field.Value = int8(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = field |
| case "FString": |
| var field ObjectUnionFString |
| 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 "FDummy": |
| var field ObjectUnionFDummy |
| if err := field.Value.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = field |
| case "FNullable": |
| var field ObjectUnionFNullable |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if dec.IsNil() { |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(field.Value), dec.Type()) { |
| return fmt.Errorf("incompatible optional %T, from %v", field.Value, dec.Type()) |
| } |
| field.Value = nil |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| } else { |
| field.Value = new(DummyStruct) |
| dec.IgnoreNextStartValue() |
| if err := field.Value.VDLRead(dec); err != nil { |
| return err |
| } |
| } |
| *x = field |
| case "FArrayInt8": |
| var field ObjectUnionFArrayInt8 |
| if err := __VDLReadAnon_list_1(dec, &field.Value); err != nil { |
| return err |
| } |
| *x = field |
| case "FMapInt8": |
| var field ObjectUnionFMapInt8 |
| if err := __VDLReadAnon_map_2(dec, &field.Value); err != nil { |
| return err |
| } |
| *x = field |
| case "FPodUnion": |
| var field ObjectUnionFPodUnion |
| if err := VDLReadPodUnion(dec, &field.Value); 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() |
| } |
| |
| func __VDLReadAnon_list_1(dec vdl.Decoder, x *[]int8) 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([]int8, 0, len) |
| default: |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| } |
| var elem int8 |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(8) |
| if err != nil { |
| return err |
| } |
| elem = int8(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| |
| func __VDLReadAnon_map_2(dec vdl.Decoder, x *map[string]int8) 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 map[string]int8 |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(map[string]int8, 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 int8 |
| { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(8) |
| if err != nil { |
| return err |
| } |
| elem = int8(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if tmpMap == nil { |
| tmpMap = make(map[string]int8) |
| } |
| tmpMap[key] = elem |
| } |
| } |
| |
| type ObjectUnionWrapper struct { |
| ObjectUnion ObjectUnion |
| } |
| |
| func (ObjectUnionWrapper) __VDLReflect(struct { |
| Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.ObjectUnionWrapper"` |
| }) { |
| } |
| |
| func (m *ObjectUnionWrapper) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| var var4 bool |
| if field, ok := m.ObjectUnion.(ObjectUnionFInt8); ok { |
| |
| var5 := (field.Value == int8(0)) |
| var4 = var5 |
| } |
| if var4 { |
| if err := fieldsTarget1.ZeroField("ObjectUnion"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("ObjectUnion") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| |
| unionValue6 := m.ObjectUnion |
| if unionValue6 == nil { |
| unionValue6 = ObjectUnionFInt8{} |
| } |
| if err := unionValue6.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| } |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (m *ObjectUnionWrapper) MakeVDLTarget() vdl.Target { |
| return &ObjectUnionWrapperTarget{Value: m} |
| } |
| |
| type ObjectUnionWrapperTarget struct { |
| Value *ObjectUnionWrapper |
| objectUnionTarget ObjectUnionTarget |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *ObjectUnionWrapperTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*ObjectUnionWrapper)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *ObjectUnionWrapperTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| switch name { |
| case "ObjectUnion": |
| t.objectUnionTarget.Value = &t.Value.ObjectUnion |
| target, err := &t.objectUnionTarget, error(nil) |
| return nil, target, err |
| default: |
| return nil, nil, vdl.ErrFieldNoExist |
| } |
| } |
| func (t *ObjectUnionWrapperTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *ObjectUnionWrapperTarget) ZeroField(name string) error { |
| switch name { |
| case "ObjectUnion": |
| t.Value.ObjectUnion = ObjectUnion(ObjectUnionFInt8{}) |
| return nil |
| default: |
| return vdl.ErrFieldNoExist |
| } |
| } |
| func (t *ObjectUnionWrapperTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| func (x ObjectUnionWrapper) VDLIsZero() bool { |
| if x.ObjectUnion != nil && !x.ObjectUnion.VDLIsZero() { |
| return false |
| } |
| return true |
| } |
| |
| func (x ObjectUnionWrapper) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*ObjectUnionWrapper)(nil)).Elem()); err != nil { |
| return err |
| } |
| if x.ObjectUnion != nil && !x.ObjectUnion.VDLIsZero() { |
| if err := enc.NextField("ObjectUnion"); err != nil { |
| return err |
| } |
| if err := x.ObjectUnion.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *ObjectUnionWrapper) VDLRead(dec vdl.Decoder) error { |
| *x = ObjectUnionWrapper{ |
| ObjectUnion: ObjectUnionFInt8{}, |
| } |
| 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 "ObjectUnion": |
| if err := VDLReadObjectUnion(dec, &x.ObjectUnion); err != nil { |
| return err |
| } |
| default: |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| type Rect struct { |
| X int32 |
| Y int32 |
| Width int32 |
| Height int32 |
| } |
| |
| func (Rect) __VDLReflect(struct { |
| Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.Rect"` |
| }) { |
| } |
| |
| func (m *Rect) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| var4 := (m.X == int32(0)) |
| if var4 { |
| if err := fieldsTarget1.ZeroField("X"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("X") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromInt(int64(m.X), tt.NonOptional().Field(0).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| } |
| } |
| var7 := (m.Y == int32(0)) |
| if var7 { |
| if err := fieldsTarget1.ZeroField("Y"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Y") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget6.FromInt(int64(m.Y), tt.NonOptional().Field(1).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil { |
| return err |
| } |
| } |
| } |
| var10 := (m.Width == int32(0)) |
| if var10 { |
| if err := fieldsTarget1.ZeroField("Width"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Width") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget9.FromInt(int64(m.Width), tt.NonOptional().Field(2).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil { |
| return err |
| } |
| } |
| } |
| var13 := (m.Height == int32(0)) |
| if var13 { |
| if err := fieldsTarget1.ZeroField("Height"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Height") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget12.FromInt(int64(m.Height), tt.NonOptional().Field(3).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil { |
| return err |
| } |
| } |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (m *Rect) MakeVDLTarget() vdl.Target { |
| return &RectTarget{Value: m} |
| } |
| |
| type RectTarget struct { |
| Value *Rect |
| xTarget vdl.Int32Target |
| yTarget vdl.Int32Target |
| widthTarget vdl.Int32Target |
| heightTarget vdl.Int32Target |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *RectTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*Rect)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *RectTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| switch name { |
| case "X": |
| t.xTarget.Value = &t.Value.X |
| target, err := &t.xTarget, error(nil) |
| return nil, target, err |
| case "Y": |
| t.yTarget.Value = &t.Value.Y |
| target, err := &t.yTarget, error(nil) |
| return nil, target, err |
| case "Width": |
| t.widthTarget.Value = &t.Value.Width |
| target, err := &t.widthTarget, error(nil) |
| return nil, target, err |
| case "Height": |
| t.heightTarget.Value = &t.Value.Height |
| target, err := &t.heightTarget, error(nil) |
| return nil, target, err |
| default: |
| return nil, nil, vdl.ErrFieldNoExist |
| } |
| } |
| func (t *RectTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *RectTarget) ZeroField(name string) error { |
| switch name { |
| case "X": |
| t.Value.X = int32(0) |
| return nil |
| case "Y": |
| t.Value.Y = int32(0) |
| return nil |
| case "Width": |
| t.Value.Width = int32(0) |
| return nil |
| case "Height": |
| t.Value.Height = int32(0) |
| return nil |
| default: |
| return vdl.ErrFieldNoExist |
| } |
| } |
| func (t *RectTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| func (x Rect) VDLIsZero() bool { |
| return x == Rect{} |
| } |
| |
| func (x Rect) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*Rect)(nil)).Elem()); err != nil { |
| return err |
| } |
| if x.X != 0 { |
| if err := enc.NextField("X"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.X)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.Y != 0 { |
| if err := enc.NextField("Y"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.Y)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.Width != 0 { |
| if err := enc.NextField("Width"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.Width)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.Height != 0 { |
| if err := enc.NextField("Height"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.Height)); 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 *Rect) VDLRead(dec vdl.Decoder) error { |
| *x = Rect{} |
| 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 "X": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.X = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "Y": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.Y = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "Width": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.Width = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "Height": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.Height = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| default: |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| type MultiVersionStruct struct { |
| FInt32 int32 |
| FRect Rect |
| FString string |
| FArray []int8 |
| FBool bool |
| FInt16 int16 |
| } |
| |
| func (MultiVersionStruct) __VDLReflect(struct { |
| Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.MultiVersionStruct"` |
| }) { |
| } |
| |
| func (m *MultiVersionStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| var4 := (m.FInt32 == int32(0)) |
| if var4 { |
| if err := fieldsTarget1.ZeroField("FInt32"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt32") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromInt(int64(m.FInt32), tt.NonOptional().Field(0).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| } |
| } |
| var7 := (m.FRect == Rect{}) |
| if var7 { |
| if err := fieldsTarget1.ZeroField("FRect"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("FRect") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| |
| if err := m.FRect.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil { |
| return err |
| } |
| } |
| } |
| var10 := (m.FString == "") |
| if var10 { |
| if err := fieldsTarget1.ZeroField("FString"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("FString") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget9.FromString(string(m.FString), tt.NonOptional().Field(2).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil { |
| return err |
| } |
| } |
| } |
| var var13 bool |
| if len(m.FArray) == 0 { |
| var13 = true |
| } |
| if var13 { |
| if err := fieldsTarget1.ZeroField("FArray"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("FArray") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| |
| listTarget14, err := fieldTarget12.StartList(tt.NonOptional().Field(3).Type, len(m.FArray)) |
| if err != nil { |
| return err |
| } |
| for i, elem16 := range m.FArray { |
| elemTarget15, err := listTarget14.StartElem(i) |
| if err != nil { |
| return err |
| } |
| if err := elemTarget15.FromInt(int64(elem16), tt.NonOptional().Field(3).Type.Elem()); err != nil { |
| return err |
| } |
| if err := listTarget14.FinishElem(elemTarget15); err != nil { |
| return err |
| } |
| } |
| if err := fieldTarget12.FinishList(listTarget14); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil { |
| return err |
| } |
| } |
| } |
| var19 := (m.FBool == false) |
| if var19 { |
| if err := fieldsTarget1.ZeroField("FBool"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget17, fieldTarget18, err := fieldsTarget1.StartField("FBool") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget18.FromBool(bool(m.FBool), tt.NonOptional().Field(4).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget17, fieldTarget18); err != nil { |
| return err |
| } |
| } |
| } |
| var22 := (m.FInt16 == int16(0)) |
| if var22 { |
| if err := fieldsTarget1.ZeroField("FInt16"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("FInt16") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget21.FromInt(int64(m.FInt16), tt.NonOptional().Field(5).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil { |
| return err |
| } |
| } |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (m *MultiVersionStruct) MakeVDLTarget() vdl.Target { |
| return &MultiVersionStructTarget{Value: m} |
| } |
| |
| type MultiVersionStructTarget struct { |
| Value *MultiVersionStruct |
| fInt32Target vdl.Int32Target |
| fRectTarget RectTarget |
| fStringTarget vdl.StringTarget |
| fArrayTarget __VDLTarget2_list |
| fBoolTarget vdl.BoolTarget |
| fInt16Target vdl.Int16Target |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *MultiVersionStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*MultiVersionStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *MultiVersionStructTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| switch name { |
| case "FInt32": |
| t.fInt32Target.Value = &t.Value.FInt32 |
| target, err := &t.fInt32Target, error(nil) |
| return nil, target, err |
| case "FRect": |
| t.fRectTarget.Value = &t.Value.FRect |
| target, err := &t.fRectTarget, error(nil) |
| return nil, target, err |
| case "FString": |
| t.fStringTarget.Value = &t.Value.FString |
| target, err := &t.fStringTarget, error(nil) |
| return nil, target, err |
| case "FArray": |
| t.fArrayTarget.Value = &t.Value.FArray |
| target, err := &t.fArrayTarget, error(nil) |
| return nil, target, err |
| case "FBool": |
| t.fBoolTarget.Value = &t.Value.FBool |
| target, err := &t.fBoolTarget, error(nil) |
| return nil, target, err |
| case "FInt16": |
| t.fInt16Target.Value = &t.Value.FInt16 |
| target, err := &t.fInt16Target, error(nil) |
| return nil, target, err |
| default: |
| return nil, nil, vdl.ErrFieldNoExist |
| } |
| } |
| func (t *MultiVersionStructTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *MultiVersionStructTarget) ZeroField(name string) error { |
| switch name { |
| case "FInt32": |
| t.Value.FInt32 = int32(0) |
| return nil |
| case "FRect": |
| t.Value.FRect = Rect{} |
| return nil |
| case "FString": |
| t.Value.FString = "" |
| return nil |
| case "FArray": |
| t.Value.FArray = []int8(nil) |
| return nil |
| case "FBool": |
| t.Value.FBool = false |
| return nil |
| case "FInt16": |
| t.Value.FInt16 = int16(0) |
| return nil |
| default: |
| return vdl.ErrFieldNoExist |
| } |
| } |
| func (t *MultiVersionStructTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| func (x MultiVersionStruct) VDLIsZero() bool { |
| if x.FInt32 != 0 { |
| return false |
| } |
| if x.FRect != (Rect{}) { |
| return false |
| } |
| if x.FString != "" { |
| return false |
| } |
| if len(x.FArray) != 0 { |
| return false |
| } |
| if x.FBool { |
| return false |
| } |
| if x.FInt16 != 0 { |
| return false |
| } |
| return true |
| } |
| |
| func (x MultiVersionStruct) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*MultiVersionStruct)(nil)).Elem()); err != nil { |
| return err |
| } |
| if x.FInt32 != 0 { |
| if err := enc.NextField("FInt32"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.FInt32)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.FRect != (Rect{}) { |
| if err := enc.NextField("FRect"); err != nil { |
| return err |
| } |
| if err := x.FRect.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.FString != "" { |
| if err := enc.NextField("FString"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.StringType); err != nil { |
| return err |
| } |
| if err := enc.EncodeString(x.FString); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if len(x.FArray) != 0 { |
| if err := enc.NextField("FArray"); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_list_1(enc, x.FArray); err != nil { |
| return err |
| } |
| } |
| if x.FBool { |
| if err := enc.NextField("FBool"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.BoolType); err != nil { |
| return err |
| } |
| if err := enc.EncodeBool(x.FBool); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.FInt16 != 0 { |
| if err := enc.NextField("FInt16"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int16Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.FInt16)); 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 *MultiVersionStruct) VDLRead(dec vdl.Decoder) error { |
| *x = MultiVersionStruct{} |
| 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 "FInt32": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.FInt32 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "FRect": |
| if err := x.FRect.VDLRead(dec); err != nil { |
| return err |
| } |
| case "FString": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var err error |
| if x.FString, err = dec.DecodeString(); err != nil { |
| return err |
| } |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "FArray": |
| if err := __VDLReadAnon_list_1(dec, &x.FArray); err != nil { |
| return err |
| } |
| case "FBool": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var err error |
| if x.FBool, err = dec.DecodeBool(); err != nil { |
| return err |
| } |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "FInt16": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(16) |
| if err != nil { |
| return err |
| } |
| x.FInt16 = int16(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| default: |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| type MultiVersionStructV3 struct { |
| FInt32 int32 |
| FRect Rect |
| FString string |
| } |
| |
| func (MultiVersionStructV3) __VDLReflect(struct { |
| Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.MultiVersionStructV3"` |
| }) { |
| } |
| |
| func (m *MultiVersionStructV3) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| var4 := (m.FInt32 == int32(0)) |
| if var4 { |
| if err := fieldsTarget1.ZeroField("FInt32"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt32") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromInt(int64(m.FInt32), tt.NonOptional().Field(0).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| } |
| } |
| var7 := (m.FRect == Rect{}) |
| if var7 { |
| if err := fieldsTarget1.ZeroField("FRect"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("FRect") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| |
| if err := m.FRect.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil { |
| return err |
| } |
| } |
| } |
| var10 := (m.FString == "") |
| if var10 { |
| if err := fieldsTarget1.ZeroField("FString"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("FString") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget9.FromString(string(m.FString), tt.NonOptional().Field(2).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil { |
| return err |
| } |
| } |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (m *MultiVersionStructV3) MakeVDLTarget() vdl.Target { |
| return &MultiVersionStructV3Target{Value: m} |
| } |
| |
| type MultiVersionStructV3Target struct { |
| Value *MultiVersionStructV3 |
| fInt32Target vdl.Int32Target |
| fRectTarget RectTarget |
| fStringTarget vdl.StringTarget |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *MultiVersionStructV3Target) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*MultiVersionStructV3)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *MultiVersionStructV3Target) StartField(name string) (key, field vdl.Target, _ error) { |
| switch name { |
| case "FInt32": |
| t.fInt32Target.Value = &t.Value.FInt32 |
| target, err := &t.fInt32Target, error(nil) |
| return nil, target, err |
| case "FRect": |
| t.fRectTarget.Value = &t.Value.FRect |
| target, err := &t.fRectTarget, error(nil) |
| return nil, target, err |
| case "FString": |
| t.fStringTarget.Value = &t.Value.FString |
| target, err := &t.fStringTarget, error(nil) |
| return nil, target, err |
| default: |
| return nil, nil, vdl.ErrFieldNoExist |
| } |
| } |
| func (t *MultiVersionStructV3Target) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *MultiVersionStructV3Target) ZeroField(name string) error { |
| switch name { |
| case "FInt32": |
| t.Value.FInt32 = int32(0) |
| return nil |
| case "FRect": |
| t.Value.FRect = Rect{} |
| return nil |
| case "FString": |
| t.Value.FString = "" |
| return nil |
| default: |
| return vdl.ErrFieldNoExist |
| } |
| } |
| func (t *MultiVersionStructV3Target) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| func (x MultiVersionStructV3) VDLIsZero() bool { |
| return x == MultiVersionStructV3{} |
| } |
| |
| func (x MultiVersionStructV3) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*MultiVersionStructV3)(nil)).Elem()); err != nil { |
| return err |
| } |
| if x.FInt32 != 0 { |
| if err := enc.NextField("FInt32"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.FInt32)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if x.FRect != (Rect{}) { |
| if err := enc.NextField("FRect"); err != nil { |
| return err |
| } |
| if err := x.FRect.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.FString != "" { |
| if err := enc.NextField("FString"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.StringType); err != nil { |
| return err |
| } |
| if err := enc.EncodeString(x.FString); 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 *MultiVersionStructV3) VDLRead(dec vdl.Decoder) error { |
| *x = MultiVersionStructV3{} |
| 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 "FInt32": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.FInt32 = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "FRect": |
| if err := x.FRect.VDLRead(dec); err != nil { |
| return err |
| } |
| case "FString": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var err error |
| if x.FString, err = dec.DecodeString(); err != nil { |
| return err |
| } |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| default: |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| 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((*AnEnum)(nil)) |
| vdl.Register((*PodUnion)(nil)) |
| vdl.Register((*PodUnionWrapper)(nil)) |
| vdl.Register((*DummyStruct)(nil)) |
| vdl.Register((*ObjectUnion)(nil)) |
| vdl.Register((*ObjectUnionWrapper)(nil)) |
| vdl.Register((*Rect)(nil)) |
| vdl.Register((*MultiVersionStruct)(nil)) |
| vdl.Register((*MultiVersionStructV3)(nil)) |
| |
| return struct{}{} |
| } |
