Google Git
Sign in
vanadium / release.go.x.ref / 1b37b78e5637ba4a1a0ada341a06c8bf2ccdc04d / . / lib / vdl / testdata / base / base.vdl.go
blob: 0f11829466885095370196691ae1130c0b68247d [file] [log] [blame]
// 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: base
// Package base is a simple single-file test of vdl functionality.
package base
import (
"fmt"
"io"
"reflect"
"v.io/v23"
"v.io/v23/context"
"v.io/v23/i18n"
"v.io/v23/rpc"
"v.io/v23/vdl"
"v.io/v23/vdl/vdlconv"
"v.io/v23/verror"
"v.io/v23/vom"
)
var _ = __VDLInit() // Must be first; see __VDLInit comments for details.
//////////////////////////////////////////////////
// Type definitions
type NamedBool bool
func (NamedBool) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedBool"`
}) {
}
func (m *NamedBool) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
if err := t.FromBool(bool((*m)), tt); err != nil {
return err
}
return nil
}
func (m *NamedBool) MakeVDLTarget() vdl.Target {
return &NamedBoolTarget{Value: m}
}
type NamedBoolTarget struct {
Value *NamedBool
vdl.TargetBase
}
func (t *NamedBoolTarget) FromBool(src bool, tt *vdl.Type) error {
if ttWant := vdl.TypeOf((*NamedBool)(nil)); !vdl.Compatible(tt, ttWant) {
return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
*t.Value = NamedBool(src)
return nil
}
type NamedByte byte
func (NamedByte) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedByte"`
}) {
}
func (m *NamedByte) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
if err := t.FromUint(uint64((*m)), tt); err != nil {
return err
}
return nil
}
func (m *NamedByte) MakeVDLTarget() vdl.Target {
return &NamedByteTarget{Value: m}
}
type NamedByteTarget struct {
Value *NamedByte
vdl.TargetBase
}
func (t *NamedByteTarget) FromUint(src uint64, tt *vdl.Type) error {
val, err := vdlconv.Uint64ToUint8(src)
if err != nil {
return err
}
*t.Value = NamedByte(val)
return nil
}
func (t *NamedByteTarget) FromInt(src int64, tt *vdl.Type) error {
val, err := vdlconv.Int64ToUint8(src)
if err != nil {
return err
}
*t.Value = NamedByte(val)
return nil
}
func (t *NamedByteTarget) FromFloat(src float64, tt *vdl.Type) error {
val, err := vdlconv.Float64ToUint8(src)
if err != nil {
return err
}
*t.Value = NamedByte(val)
return nil
}
func (t *NamedByteTarget) FromComplex(src complex128, tt *vdl.Type) error {
val, err := vdlconv.Complex128ToUint8(src)
if err != nil {
return err
}
*t.Value = NamedByte(val)
return nil
}
type NamedUint16 uint16
func (NamedUint16) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedUint16"`
}) {
}
func (m *NamedUint16) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
if err := t.FromUint(uint64((*m)), tt); err != nil {
return err
}
return nil
}
func (m *NamedUint16) MakeVDLTarget() vdl.Target {
return &NamedUint16Target{Value: m}
}
type NamedUint16Target struct {
Value *NamedUint16
vdl.TargetBase
}
func (t *NamedUint16Target) FromUint(src uint64, tt *vdl.Type) error {
val, err := vdlconv.Uint64ToUint16(src)
if err != nil {
return err
}
*t.Value = NamedUint16(val)
return nil
}
func (t *NamedUint16Target) FromInt(src int64, tt *vdl.Type) error {
val, err := vdlconv.Int64ToUint16(src)
if err != nil {
return err
}
*t.Value = NamedUint16(val)
return nil
}
func (t *NamedUint16Target) FromFloat(src float64, tt *vdl.Type) error {
val, err := vdlconv.Float64ToUint16(src)
if err != nil {
return err
}
*t.Value = NamedUint16(val)
return nil
}
func (t *NamedUint16Target) FromComplex(src complex128, tt *vdl.Type) error {
val, err := vdlconv.Complex128ToUint16(src)
if err != nil {
return err
}
*t.Value = NamedUint16(val)
return nil
}
type NamedUint32 uint32
func (NamedUint32) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedUint32"`
}) {
}
func (m *NamedUint32) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
if err := t.FromUint(uint64((*m)), tt); err != nil {
return err
}
return nil
}
func (m *NamedUint32) MakeVDLTarget() vdl.Target {
return &NamedUint32Target{Value: m}
}
type NamedUint32Target struct {
Value *NamedUint32
vdl.TargetBase
}
func (t *NamedUint32Target) FromUint(src uint64, tt *vdl.Type) error {
val, err := vdlconv.Uint64ToUint32(src)
if err != nil {
return err
}
*t.Value = NamedUint32(val)
return nil
}
func (t *NamedUint32Target) FromInt(src int64, tt *vdl.Type) error {
val, err := vdlconv.Int64ToUint32(src)
if err != nil {
return err
}
*t.Value = NamedUint32(val)
return nil
}
func (t *NamedUint32Target) FromFloat(src float64, tt *vdl.Type) error {
val, err := vdlconv.Float64ToUint32(src)
if err != nil {
return err
}
*t.Value = NamedUint32(val)
return nil
}
func (t *NamedUint32Target) FromComplex(src complex128, tt *vdl.Type) error {
val, err := vdlconv.Complex128ToUint32(src)
if err != nil {
return err
}
*t.Value = NamedUint32(val)
return nil
}
type NamedUint64 uint64
func (NamedUint64) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedUint64"`
}) {
}
func (m *NamedUint64) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
if err := t.FromUint(uint64((*m)), tt); err != nil {
return err
}
return nil
}
func (m *NamedUint64) MakeVDLTarget() vdl.Target {
return &NamedUint64Target{Value: m}
}
type NamedUint64Target struct {
Value *NamedUint64
vdl.TargetBase
}
func (t *NamedUint64Target) FromUint(src uint64, tt *vdl.Type) error {
*t.Value = NamedUint64(src)
return nil
}
func (t *NamedUint64Target) FromInt(src int64, tt *vdl.Type) error {
val, err := vdlconv.Int64ToUint64(src)
if err != nil {
return err
}
*t.Value = NamedUint64(val)
return nil
}
func (t *NamedUint64Target) FromFloat(src float64, tt *vdl.Type) error {
val, err := vdlconv.Float64ToUint64(src)
if err != nil {
return err
}
*t.Value = NamedUint64(val)
return nil
}
func (t *NamedUint64Target) FromComplex(src complex128, tt *vdl.Type) error {
val, err := vdlconv.Complex128ToUint64(src)
if err != nil {
return err
}
*t.Value = NamedUint64(val)
return nil
}
type NamedInt8 int8
func (NamedInt8) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedInt8"`
}) {
}
func (m *NamedInt8) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
if err := t.FromInt(int64((*m)), tt); err != nil {
return err
}
return nil
}
func (m *NamedInt8) MakeVDLTarget() vdl.Target {
return &NamedInt8Target{Value: m}
}
type NamedInt8Target struct {
Value *NamedInt8
vdl.TargetBase
}
func (t *NamedInt8Target) FromUint(src uint64, tt *vdl.Type) error {
val, err := vdlconv.Uint64ToInt8(src)
if err != nil {
return err
}
*t.Value = NamedInt8(val)
return nil
}
func (t *NamedInt8Target) FromInt(src int64, tt *vdl.Type) error {
val, err := vdlconv.Int64ToInt8(src)
if err != nil {
return err
}
*t.Value = NamedInt8(val)
return nil
}
func (t *NamedInt8Target) FromFloat(src float64, tt *vdl.Type) error {
val, err := vdlconv.Float64ToInt8(src)
if err != nil {
return err
}
*t.Value = NamedInt8(val)
return nil
}
func (t *NamedInt8Target) FromComplex(src complex128, tt *vdl.Type) error {
val, err := vdlconv.Complex128ToInt8(src)
if err != nil {
return err
}
*t.Value = NamedInt8(val)
return nil
}
type NamedInt16 int16
func (NamedInt16) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedInt16"`
}) {
}
func (m *NamedInt16) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
if err := t.FromInt(int64((*m)), tt); err != nil {
return err
}
return nil
}
func (m *NamedInt16) MakeVDLTarget() vdl.Target {
return &NamedInt16Target{Value: m}
}
type NamedInt16Target struct {
Value *NamedInt16
vdl.TargetBase
}
func (t *NamedInt16Target) FromUint(src uint64, tt *vdl.Type) error {
val, err := vdlconv.Uint64ToInt16(src)
if err != nil {
return err
}
*t.Value = NamedInt16(val)
return nil
}
func (t *NamedInt16Target) FromInt(src int64, tt *vdl.Type) error {
val, err := vdlconv.Int64ToInt16(src)
if err != nil {
return err
}
*t.Value = NamedInt16(val)
return nil
}
func (t *NamedInt16Target) FromFloat(src float64, tt *vdl.Type) error {
val, err := vdlconv.Float64ToInt16(src)
if err != nil {
return err
}
*t.Value = NamedInt16(val)
return nil
}
func (t *NamedInt16Target) FromComplex(src complex128, tt *vdl.Type) error {
val, err := vdlconv.Complex128ToInt16(src)
if err != nil {
return err
}
*t.Value = NamedInt16(val)
return nil
}
type NamedInt32 int32
func (NamedInt32) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedInt32"`
}) {
}
func (m *NamedInt32) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
if err := t.FromInt(int64((*m)), tt); err != nil {
return err
}
return nil
}
func (m *NamedInt32) MakeVDLTarget() vdl.Target {
return &NamedInt32Target{Value: m}
}
type NamedInt32Target struct {
Value *NamedInt32
vdl.TargetBase
}
func (t *NamedInt32Target) FromUint(src uint64, tt *vdl.Type) error {
val, err := vdlconv.Uint64ToInt32(src)
if err != nil {
return err
}
*t.Value = NamedInt32(val)
return nil
}
func (t *NamedInt32Target) FromInt(src int64, tt *vdl.Type) error {
val, err := vdlconv.Int64ToInt32(src)
if err != nil {
return err
}
*t.Value = NamedInt32(val)
return nil
}
func (t *NamedInt32Target) FromFloat(src float64, tt *vdl.Type) error {
val, err := vdlconv.Float64ToInt32(src)
if err != nil {
return err
}
*t.Value = NamedInt32(val)
return nil
}
func (t *NamedInt32Target) FromComplex(src complex128, tt *vdl.Type) error {
val, err := vdlconv.Complex128ToInt32(src)
if err != nil {
return err
}
*t.Value = NamedInt32(val)
return nil
}
type NamedInt64 int64
func (NamedInt64) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedInt64"`
}) {
}
func (m *NamedInt64) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
if err := t.FromInt(int64((*m)), tt); err != nil {
return err
}
return nil
}
func (m *NamedInt64) MakeVDLTarget() vdl.Target {
return &NamedInt64Target{Value: m}
}
type NamedInt64Target struct {
Value *NamedInt64
vdl.TargetBase
}
func (t *NamedInt64Target) FromUint(src uint64, tt *vdl.Type) error {
val, err := vdlconv.Uint64ToInt64(src)
if err != nil {
return err
}
*t.Value = NamedInt64(val)
return nil
}
func (t *NamedInt64Target) FromInt(src int64, tt *vdl.Type) error {
*t.Value = NamedInt64(src)
return nil
}
func (t *NamedInt64Target) FromFloat(src float64, tt *vdl.Type) error {
val, err := vdlconv.Float64ToInt64(src)
if err != nil {
return err
}
*t.Value = NamedInt64(val)
return nil
}
func (t *NamedInt64Target) FromComplex(src complex128, tt *vdl.Type) error {
val, err := vdlconv.Complex128ToInt64(src)
if err != nil {
return err
}
*t.Value = NamedInt64(val)
return nil
}
type NamedFloat32 float32
func (NamedFloat32) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedFloat32"`
}) {
}
func (m *NamedFloat32) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
if err := t.FromFloat(float64((*m)), tt); err != nil {
return err
}
return nil
}
func (m *NamedFloat32) MakeVDLTarget() vdl.Target {
return &NamedFloat32Target{Value: m}
}
type NamedFloat32Target struct {
Value *NamedFloat32
vdl.TargetBase
}
func (t *NamedFloat32Target) FromUint(src uint64, tt *vdl.Type) error {
val, err := vdlconv.Uint64ToFloat32(src)
if err != nil {
return err
}
*t.Value = NamedFloat32(val)
return nil
}
func (t *NamedFloat32Target) FromInt(src int64, tt *vdl.Type) error {
val, err := vdlconv.Int64ToFloat32(src)
if err != nil {
return err
}
*t.Value = NamedFloat32(val)
return nil
}
func (t *NamedFloat32Target) FromFloat(src float64, tt *vdl.Type) error {
val, err := vdlconv.Float64ToFloat32(src)
if err != nil {
return err
}
*t.Value = NamedFloat32(val)
return nil
}
func (t *NamedFloat32Target) FromComplex(src complex128, tt *vdl.Type) error {
val, err := vdlconv.Complex128ToFloat32(src)
if err != nil {
return err
}
*t.Value = NamedFloat32(val)
return nil
}
type NamedFloat64 float64
func (NamedFloat64) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedFloat64"`
}) {
}
func (m *NamedFloat64) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
if err := t.FromFloat(float64((*m)), tt); err != nil {
return err
}
return nil
}
func (m *NamedFloat64) MakeVDLTarget() vdl.Target {
return &NamedFloat64Target{Value: m}
}
type NamedFloat64Target struct {
Value *NamedFloat64
vdl.TargetBase
}
func (t *NamedFloat64Target) FromUint(src uint64, tt *vdl.Type) error {
val, err := vdlconv.Uint64ToFloat64(src)
if err != nil {
return err
}
*t.Value = NamedFloat64(val)
return nil
}
func (t *NamedFloat64Target) FromInt(src int64, tt *vdl.Type) error {
val, err := vdlconv.Int64ToFloat64(src)
if err != nil {
return err
}
*t.Value = NamedFloat64(val)
return nil
}
func (t *NamedFloat64Target) FromFloat(src float64, tt *vdl.Type) error {
*t.Value = NamedFloat64(src)
return nil
}
func (t *NamedFloat64Target) FromComplex(src complex128, tt *vdl.Type) error {
val, err := vdlconv.Complex128ToFloat64(src)
if err != nil {
return err
}
*t.Value = NamedFloat64(val)
return nil
}
type NamedComplex64 complex64
func (NamedComplex64) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedComplex64"`
}) {
}
func (m *NamedComplex64) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
if err := t.FromComplex(complex128((*m)), tt); err != nil {
return err
}
return nil
}
func (m *NamedComplex64) MakeVDLTarget() vdl.Target {
return &NamedComplex64Target{Value: m}
}
type NamedComplex64Target struct {
Value *NamedComplex64
vdl.TargetBase
}
func (t *NamedComplex64Target) FromUint(src uint64, tt *vdl.Type) error {
val, err := vdlconv.Uint64ToComplex64(src)
if err != nil {
return err
}
*t.Value = NamedComplex64(val)
return nil
}
func (t *NamedComplex64Target) FromInt(src int64, tt *vdl.Type) error {
val, err := vdlconv.Int64ToComplex64(src)
if err != nil {
return err
}
*t.Value = NamedComplex64(val)
return nil
}
func (t *NamedComplex64Target) FromFloat(src float64, tt *vdl.Type) error {
val, err := vdlconv.Float64ToComplex64(src)
if err != nil {
return err
}
*t.Value = NamedComplex64(val)
return nil
}
func (t *NamedComplex64Target) FromComplex(src complex128, tt *vdl.Type) error {
val, err := vdlconv.Complex128ToComplex64(src)
if err != nil {
return err
}
*t.Value = NamedComplex64(val)
return nil
}
type NamedComplex128 complex128
func (NamedComplex128) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedComplex128"`
}) {
}
func (m *NamedComplex128) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
if err := t.FromComplex(complex128((*m)), tt); err != nil {
return err
}
return nil
}
func (m *NamedComplex128) MakeVDLTarget() vdl.Target {
return &NamedComplex128Target{Value: m}
}
type NamedComplex128Target struct {
Value *NamedComplex128
vdl.TargetBase
}
func (t *NamedComplex128Target) FromUint(src uint64, tt *vdl.Type) error {
val, err := vdlconv.Uint64ToComplex128(src)
if err != nil {
return err
}
*t.Value = NamedComplex128(val)
return nil
}
func (t *NamedComplex128Target) FromInt(src int64, tt *vdl.Type) error {
val, err := vdlconv.Int64ToComplex128(src)
if err != nil {
return err
}
*t.Value = NamedComplex128(val)
return nil
}
func (t *NamedComplex128Target) FromFloat(src float64, tt *vdl.Type) error {
val, err := vdlconv.Float64ToComplex128(src)
if err != nil {
return err
}
*t.Value = NamedComplex128(val)
return nil
}
func (t *NamedComplex128Target) FromComplex(src complex128, tt *vdl.Type) error {
*t.Value = NamedComplex128(src)
return nil
}
type NamedString string
func (NamedString) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedString"`
}) {
}
func (m *NamedString) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
if err := t.FromString(string((*m)), tt); err != nil {
return err
}
return nil
}
func (m *NamedString) MakeVDLTarget() vdl.Target {
return &NamedStringTarget{Value: m}
}
type NamedStringTarget struct {
Value *NamedString
vdl.TargetBase
}
func (t *NamedStringTarget) FromString(src string, tt *vdl.Type) error {
if ttWant := vdl.TypeOf((*NamedString)(nil)); !vdl.Compatible(tt, ttWant) {
return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
*t.Value = NamedString(src)
return nil
}
type NamedEnum int
const (
NamedEnumA NamedEnum = iota
NamedEnumB
NamedEnumC
)
// NamedEnumAll holds all labels for NamedEnum.
var NamedEnumAll = [...]NamedEnum{NamedEnumA, NamedEnumB, NamedEnumC}
// NamedEnumFromString creates a NamedEnum from a string label.
func NamedEnumFromString(label string) (x NamedEnum, err error) {
err = x.Set(label)
return
}
// Set assigns label to x.
func (x *NamedEnum) Set(label string) error {
switch label {
case "A", "a":
*x = NamedEnumA
return nil
case "B", "b":
*x = NamedEnumB
return nil
case "C", "c":
*x = NamedEnumC
return nil
}
*x = -1
return fmt.Errorf("unknown label %q in base.NamedEnum", label)
}
// String returns the string label of x.
func (x NamedEnum) String() string {
switch x {
case NamedEnumA:
return "A"
case NamedEnumB:
return "B"
case NamedEnumC:
return "C"
}
return ""
}
func (NamedEnum) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedEnum"`
Enum struct{ A, B, C string }
}) {
}
func (m *NamedEnum) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
if err := t.FromEnumLabel((*m).String(), tt); err != nil {
return err
}
return nil
}
func (m *NamedEnum) MakeVDLTarget() vdl.Target {
return &NamedEnumTarget{Value: m}
}
type NamedEnumTarget struct {
Value *NamedEnum
vdl.TargetBase
}
func (t *NamedEnumTarget) FromEnumLabel(src string, tt *vdl.Type) error {
if ttWant := vdl.TypeOf((*NamedEnum)(nil)); !vdl.Compatible(tt, ttWant) {
return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
switch src {
case "A":
*t.Value = 0
case "B":
*t.Value = 1
case "C":
*t.Value = 2
default:
return fmt.Errorf("label %s not in enum v.io/x/ref/lib/vdl/testdata/base.NamedEnum", src)
}
return nil
}
type NamedArray [2]bool
func (NamedArray) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedArray"`
}) {
}
func (m *NamedArray) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
listTarget1, err := t.StartList(tt, 2)
if err != nil {
return err
}
for i, elem3 := range *m {
elemTarget2, err := listTarget1.StartElem(i)
if err != nil {
return err
}
if err := elemTarget2.FromBool(bool(elem3), tt.NonOptional().Elem()); err != nil {
return err
}
if err := listTarget1.FinishElem(elemTarget2); err != nil {
return err
}
}
if err := t.FinishList(listTarget1); err != nil {
return err
}
return nil
}
func (m *NamedArray) MakeVDLTarget() vdl.Target {
return &NamedArrayTarget{Value: m}
}
// NamedArray
type NamedArrayTarget struct {
Value *NamedArray
elemTarget vdl.BoolTarget
vdl.TargetBase
vdl.ListTargetBase
}
func (t *NamedArrayTarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
if ttWant := vdl.TypeOf((*NamedArray)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
return t, nil
}
func (t *NamedArrayTarget) StartElem(index int) (elem vdl.Target, _ error) {
t.elemTarget.Value = &(*t.Value)[index]
target, err := &t.elemTarget, error(nil)
return target, err
}
func (t *NamedArrayTarget) FinishElem(elem vdl.Target) error {
return nil
}
func (t *NamedArrayTarget) FinishList(elem vdl.ListTarget) error {
return nil
}
type NamedList []uint32
func (NamedList) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedList"`
}) {
}
func (m *NamedList) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
listTarget1, err := t.StartList(tt, len((*m)))
if err != nil {
return err
}
for i, elem3 := range *m {
elemTarget2, err := listTarget1.StartElem(i)
if err != nil {
return err
}
if err := elemTarget2.FromUint(uint64(elem3), tt.NonOptional().Elem()); err != nil {
return err
}
if err := listTarget1.FinishElem(elemTarget2); err != nil {
return err
}
}
if err := t.FinishList(listTarget1); err != nil {
return err
}
return nil
}
func (m *NamedList) MakeVDLTarget() vdl.Target {
return &NamedListTarget{Value: m}
}
// NamedList
type NamedListTarget struct {
Value *NamedList
elemTarget vdl.Uint32Target
vdl.TargetBase
vdl.ListTargetBase
}
func (t *NamedListTarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
if ttWant := vdl.TypeOf((*NamedList)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
if cap(*t.Value) < len {
*t.Value = make(NamedList, len)
} else {
*t.Value = (*t.Value)[:len]
}
return t, nil
}
func (t *NamedListTarget) StartElem(index int) (elem vdl.Target, _ error) {
t.elemTarget.Value = &(*t.Value)[index]
target, err := &t.elemTarget, error(nil)
return target, err
}
func (t *NamedListTarget) FinishElem(elem vdl.Target) error {
return nil
}
func (t *NamedListTarget) FinishList(elem vdl.ListTarget) error {
return nil
}
type NamedSet map[string]struct{}
func (NamedSet) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedSet"`
}) {
}
func (m *NamedSet) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
setTarget1, err := t.StartSet(tt, len((*m)))
if err != nil {
return err
}
for key3 := range *m {
keyTarget2, err := setTarget1.StartKey()
if err != nil {
return err
}
if err := keyTarget2.FromString(string(key3), tt.NonOptional().Key()); err != nil {
return err
}
if err := setTarget1.FinishKey(keyTarget2); err != nil {
return err
}
}
if err := t.FinishSet(setTarget1); err != nil {
return err
}
return nil
}
func (m *NamedSet) MakeVDLTarget() vdl.Target {
return &NamedSetTarget{Value: m}
}
type NamedSetTarget struct {
Value *NamedSet
currKey string
keyTarget vdl.StringTarget
vdl.TargetBase
vdl.SetTargetBase
}
func (t *NamedSetTarget) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {
if ttWant := vdl.TypeOf((*NamedSet)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
*t.Value = make(NamedSet)
return t, nil
}
func (t *NamedSetTarget) StartKey() (key vdl.Target, _ error) {
t.currKey = ""
t.keyTarget.Value = &t.currKey
target, err := &t.keyTarget, error(nil)
return target, err
}
func (t *NamedSetTarget) FinishKey(key vdl.Target) error {
(*t.Value)[t.currKey] = struct{}{}
return nil
}
func (t *NamedSetTarget) FinishSet(list vdl.SetTarget) error {
if len(*t.Value) == 0 {
*t.Value = nil
}
return nil
}
type NamedMap map[string]float32
func (NamedMap) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedMap"`
}) {
}
func (m *NamedMap) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
mapTarget1, err := t.StartMap(tt, len((*m)))
if err != nil {
return err
}
for key3, value5 := range *m {
keyTarget2, err := mapTarget1.StartKey()
if err != nil {
return err
}
if err := keyTarget2.FromString(string(key3), tt.NonOptional().Key()); err != nil {
return err
}
valueTarget4, err := mapTarget1.FinishKeyStartField(keyTarget2)
if err != nil {
return err
}
if err := valueTarget4.FromFloat(float64(value5), tt.NonOptional().Elem()); err != nil {
return err
}
if err := mapTarget1.FinishField(keyTarget2, valueTarget4); err != nil {
return err
}
}
if err := t.FinishMap(mapTarget1); err != nil {
return err
}
return nil
}
func (m *NamedMap) MakeVDLTarget() vdl.Target {
return &NamedMapTarget{Value: m}
}
type NamedMapTarget struct {
Value *NamedMap
currKey string
currElem float32
keyTarget vdl.StringTarget
elemTarget vdl.Float32Target
vdl.TargetBase
vdl.MapTargetBase
}
func (t *NamedMapTarget) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {
if ttWant := vdl.TypeOf((*NamedMap)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
*t.Value = make(NamedMap)
return t, nil
}
func (t *NamedMapTarget) StartKey() (key vdl.Target, _ error) {
t.currKey = ""
t.keyTarget.Value = &t.currKey
target, err := &t.keyTarget, error(nil)
return target, err
}
func (t *NamedMapTarget) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
t.currElem = float32(0)
t.elemTarget.Value = &t.currElem
target, err := &t.elemTarget, error(nil)
return target, err
}
func (t *NamedMapTarget) FinishField(key, field vdl.Target) error {
(*t.Value)[t.currKey] = t.currElem
return nil
}
func (t *NamedMapTarget) FinishMap(elem vdl.MapTarget) error {
if len(*t.Value) == 0 {
*t.Value = nil
}
return nil
}
type NamedStruct struct {
A bool
B string
C int32
}
func (NamedStruct) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedStruct"`
}) {
}
func (m *NamedStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
fieldsTarget1, err := t.StartFields(tt)
if err != nil {
return err
}
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget3.FromBool(bool(m.A), tt.NonOptional().Field(0).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("B")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget5.FromString(string(m.B), tt.NonOptional().Field(1).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
return err
}
}
keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("C")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget7.FromInt(int64(m.C), tt.NonOptional().Field(2).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
return err
}
}
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
return nil
}
func (m *NamedStruct) MakeVDLTarget() vdl.Target {
return &NamedStructTarget{Value: m}
}
type NamedStructTarget struct {
Value *NamedStruct
aTarget vdl.BoolTarget
bTarget vdl.StringTarget
cTarget vdl.Int32Target
vdl.TargetBase
vdl.FieldsTargetBase
}
func (t *NamedStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
if ttWant := vdl.TypeOf((*NamedStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
return t, nil
}
func (t *NamedStructTarget) StartField(name string) (key, field vdl.Target, _ error) {
switch name {
case "A":
t.aTarget.Value = &t.Value.A
target, err := &t.aTarget, error(nil)
return nil, target, err
case "B":
t.bTarget.Value = &t.Value.B
target, err := &t.bTarget, error(nil)
return nil, target, err
case "C":
t.cTarget.Value = &t.Value.C
target, err := &t.cTarget, error(nil)
return nil, target, err
default:
return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/lib/vdl/testdata/base.NamedStruct", name)
}
}
func (t *NamedStructTarget) FinishField(_, _ vdl.Target) error {
return nil
}
func (t *NamedStructTarget) FinishFields(_ vdl.FieldsTarget) error {
return nil
}
type (
// NamedUnion represents any single field of the NamedUnion union type.
NamedUnion 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 NamedUnion union type.
__VDLReflect(__NamedUnionReflect)
FillVDLTarget(vdl.Target, *vdl.Type) error
}
// NamedUnionA represents field A of the NamedUnion union type.
NamedUnionA struct{ Value bool }
// NamedUnionB represents field B of the NamedUnion union type.
NamedUnionB struct{ Value string }
// NamedUnionC represents field C of the NamedUnion union type.
NamedUnionC struct{ Value int32 }
// __NamedUnionReflect describes the NamedUnion union type.
__NamedUnionReflect struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedUnion"`
Type NamedUnion
UnionTargetFactory namedUnionTargetFactory
Union struct {
A NamedUnionA
B NamedUnionB
C NamedUnionC
}
}
)
func (x NamedUnionA) Index() int { return 0 }
func (x NamedUnionA) Interface() interface{} { return x.Value }
func (x NamedUnionA) Name() string { return "A" }
func (x NamedUnionA) __VDLReflect(__NamedUnionReflect) {}
func (m NamedUnionA) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
fieldsTarget1, err := t.StartFields(tt)
if err != nil {
return err
}
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
if err != nil {
return err
}
if err := fieldTarget3.FromBool(bool(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 NamedUnionA) MakeVDLTarget() vdl.Target {
return nil
}
func (x NamedUnionB) Index() int { return 1 }
func (x NamedUnionB) Interface() interface{} { return x.Value }
func (x NamedUnionB) Name() string { return "B" }
func (x NamedUnionB) __VDLReflect(__NamedUnionReflect) {}
func (m NamedUnionB) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
fieldsTarget1, err := t.StartFields(tt)
if err != nil {
return err
}
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("B")
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 NamedUnionB) MakeVDLTarget() vdl.Target {
return nil
}
func (x NamedUnionC) Index() int { return 2 }
func (x NamedUnionC) Interface() interface{} { return x.Value }
func (x NamedUnionC) Name() string { return "C" }
func (x NamedUnionC) __VDLReflect(__NamedUnionReflect) {}
func (m NamedUnionC) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
fieldsTarget1, err := t.StartFields(tt)
if err != nil {
return err
}
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("C")
if err != nil {
return err
}
if err := fieldTarget3.FromInt(int64(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 NamedUnionC) MakeVDLTarget() vdl.Target {
return nil
}
type NamedUnionTarget struct {
Value *NamedUnion
fieldName string
vdl.TargetBase
vdl.FieldsTargetBase
}
func (t *NamedUnionTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
if ttWant := vdl.TypeOf((*NamedUnion)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
return t, nil
}
func (t *NamedUnionTarget) StartField(name string) (key, field vdl.Target, _ error) {
t.fieldName = name
switch name {
case "A":
val := false
return nil, &vdl.BoolTarget{Value: &val}, nil
case "B":
val := ""
return nil, &vdl.StringTarget{Value: &val}, nil
case "C":
val := int32(0)
return nil, &vdl.Int32Target{Value: &val}, nil
default:
return nil, nil, fmt.Errorf("field %s not in union v.io/x/ref/lib/vdl/testdata/base.NamedUnion", name)
}
}
func (t *NamedUnionTarget) FinishField(_, fieldTarget vdl.Target) error {
switch t.fieldName {
case "A":
*t.Value = NamedUnionA{*(fieldTarget.(*vdl.BoolTarget)).Value}
case "B":
*t.Value = NamedUnionB{*(fieldTarget.(*vdl.StringTarget)).Value}
case "C":
*t.Value = NamedUnionC{*(fieldTarget.(*vdl.Int32Target)).Value}
}
return nil
}
func (t *NamedUnionTarget) FinishFields(_ vdl.FieldsTarget) error {
return nil
}
type namedUnionTargetFactory struct{}
func (t namedUnionTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) {
if typedUnion, ok := union.(*NamedUnion); ok {
return &NamedUnionTarget{Value: typedUnion}, nil
}
return nil, fmt.Errorf("got %T, want *NamedUnion", union)
}
type Scalars struct {
A0 bool
A1 byte
A2 uint16
A3 uint32
A4 uint64
A5 int8
A6 int16
A7 int32
A8 int64
A9 float32
A10 float64
A11 complex64
A12 complex128
A13 string
A14 error
A15 *vom.RawBytes
A16 *vdl.Type
B0 NamedBool
B1 NamedByte
B2 NamedUint16
B3 NamedUint32
B4 NamedUint64
B5 NamedInt8
B6 NamedInt16
B7 NamedInt32
B8 NamedInt64
B9 NamedFloat32
B10 NamedFloat64
B11 NamedComplex64
B12 NamedComplex128
B13 NamedString
B14 NamedEnum
B15 NamedUnion
}
func (Scalars) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.Scalars"`
}) {
}
func (m *Scalars) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
fieldsTarget1, err := t.StartFields(tt)
if err != nil {
return err
}
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A0")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget3.FromBool(bool(m.A0), tt.NonOptional().Field(0).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("A1")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget5.FromUint(uint64(m.A1), tt.NonOptional().Field(1).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
return err
}
}
keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("A2")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget7.FromUint(uint64(m.A2), tt.NonOptional().Field(2).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
return err
}
}
keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("A3")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget9.FromUint(uint64(m.A3), tt.NonOptional().Field(3).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("A4")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget11.FromUint(uint64(m.A4), tt.NonOptional().Field(4).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
return err
}
}
keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("A5")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget13.FromInt(int64(m.A5), tt.NonOptional().Field(5).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
return err
}
}
keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("A6")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget15.FromInt(int64(m.A6), tt.NonOptional().Field(6).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
}
keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("A7")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget17.FromInt(int64(m.A7), tt.NonOptional().Field(7).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget16, fieldTarget17); err != nil {
return err
}
}
keyTarget18, fieldTarget19, err := fieldsTarget1.StartField("A8")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget19.FromInt(int64(m.A8), tt.NonOptional().Field(8).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget18, fieldTarget19); err != nil {
return err
}
}
keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("A9")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget21.FromFloat(float64(m.A9), tt.NonOptional().Field(9).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
return err
}
}
keyTarget22, fieldTarget23, err := fieldsTarget1.StartField("A10")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget23.FromFloat(float64(m.A10), tt.NonOptional().Field(10).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget22, fieldTarget23); err != nil {
return err
}
}
keyTarget24, fieldTarget25, err := fieldsTarget1.StartField("A11")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget25.FromComplex(complex128(m.A11), tt.NonOptional().Field(11).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget24, fieldTarget25); err != nil {
return err
}
}
keyTarget26, fieldTarget27, err := fieldsTarget1.StartField("A12")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget27.FromComplex(complex128(m.A12), tt.NonOptional().Field(12).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget26, fieldTarget27); err != nil {
return err
}
}
keyTarget28, fieldTarget29, err := fieldsTarget1.StartField("A13")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget29.FromString(string(m.A13), tt.NonOptional().Field(13).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget28, fieldTarget29); err != nil {
return err
}
}
keyTarget30, fieldTarget31, err := fieldsTarget1.StartField("A14")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if m.A14 == nil {
if err := fieldTarget31.FromNil(tt.NonOptional().Field(14).Type); err != nil {
return err
}
} else {
var wireError32 vdl.WireError
if err := verror.WireFromNative(&wireError32, m.A14); err != nil {
return err
}
if err := wireError32.FillVDLTarget(fieldTarget31, vdl.ErrorType); err != nil {
return err
}
}
if err := fieldsTarget1.FinishField(keyTarget30, fieldTarget31); err != nil {
return err
}
}
keyTarget33, fieldTarget34, err := fieldsTarget1.StartField("A15")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if m.A15 == nil {
if err := fieldTarget34.FromNil(tt.NonOptional().Field(15).Type); err != nil {
return err
}
} else {
if err := m.A15.FillVDLTarget(fieldTarget34, tt.NonOptional().Field(15).Type); err != nil {
return err
}
}
if err := fieldsTarget1.FinishField(keyTarget33, fieldTarget34); err != nil {
return err
}
}
keyTarget35, fieldTarget36, err := fieldsTarget1.StartField("A16")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
typeObjectVal37 := m.A16
if typeObjectVal37 == nil {
typeObjectVal37 = vdl.AnyType
}
if err := fieldTarget36.FromTypeObject(typeObjectVal37); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget35, fieldTarget36); err != nil {
return err
}
}
keyTarget38, fieldTarget39, err := fieldsTarget1.StartField("B0")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B0.FillVDLTarget(fieldTarget39, tt.NonOptional().Field(17).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget38, fieldTarget39); err != nil {
return err
}
}
keyTarget40, fieldTarget41, err := fieldsTarget1.StartField("B1")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B1.FillVDLTarget(fieldTarget41, tt.NonOptional().Field(18).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget40, fieldTarget41); err != nil {
return err
}
}
keyTarget42, fieldTarget43, err := fieldsTarget1.StartField("B2")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B2.FillVDLTarget(fieldTarget43, tt.NonOptional().Field(19).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget42, fieldTarget43); err != nil {
return err
}
}
keyTarget44, fieldTarget45, err := fieldsTarget1.StartField("B3")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B3.FillVDLTarget(fieldTarget45, tt.NonOptional().Field(20).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget44, fieldTarget45); err != nil {
return err
}
}
keyTarget46, fieldTarget47, err := fieldsTarget1.StartField("B4")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B4.FillVDLTarget(fieldTarget47, tt.NonOptional().Field(21).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget46, fieldTarget47); err != nil {
return err
}
}
keyTarget48, fieldTarget49, err := fieldsTarget1.StartField("B5")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B5.FillVDLTarget(fieldTarget49, tt.NonOptional().Field(22).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget48, fieldTarget49); err != nil {
return err
}
}
keyTarget50, fieldTarget51, err := fieldsTarget1.StartField("B6")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B6.FillVDLTarget(fieldTarget51, tt.NonOptional().Field(23).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget50, fieldTarget51); err != nil {
return err
}
}
keyTarget52, fieldTarget53, err := fieldsTarget1.StartField("B7")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B7.FillVDLTarget(fieldTarget53, tt.NonOptional().Field(24).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget52, fieldTarget53); err != nil {
return err
}
}
keyTarget54, fieldTarget55, err := fieldsTarget1.StartField("B8")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B8.FillVDLTarget(fieldTarget55, tt.NonOptional().Field(25).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget54, fieldTarget55); err != nil {
return err
}
}
keyTarget56, fieldTarget57, err := fieldsTarget1.StartField("B9")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B9.FillVDLTarget(fieldTarget57, tt.NonOptional().Field(26).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget56, fieldTarget57); err != nil {
return err
}
}
keyTarget58, fieldTarget59, err := fieldsTarget1.StartField("B10")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B10.FillVDLTarget(fieldTarget59, tt.NonOptional().Field(27).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget58, fieldTarget59); err != nil {
return err
}
}
keyTarget60, fieldTarget61, err := fieldsTarget1.StartField("B11")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B11.FillVDLTarget(fieldTarget61, tt.NonOptional().Field(28).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget60, fieldTarget61); err != nil {
return err
}
}
keyTarget62, fieldTarget63, err := fieldsTarget1.StartField("B12")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B12.FillVDLTarget(fieldTarget63, tt.NonOptional().Field(29).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget62, fieldTarget63); err != nil {
return err
}
}
keyTarget64, fieldTarget65, err := fieldsTarget1.StartField("B13")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B13.FillVDLTarget(fieldTarget65, tt.NonOptional().Field(30).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget64, fieldTarget65); err != nil {
return err
}
}
keyTarget66, fieldTarget67, err := fieldsTarget1.StartField("B14")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B14.FillVDLTarget(fieldTarget67, tt.NonOptional().Field(31).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget66, fieldTarget67); err != nil {
return err
}
}
keyTarget68, fieldTarget69, err := fieldsTarget1.StartField("B15")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
unionValue70 := m.B15
if unionValue70 == nil {
unionValue70 = NamedUnionA{}
}
if err := unionValue70.FillVDLTarget(fieldTarget69, tt.NonOptional().Field(32).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget68, fieldTarget69); err != nil {
return err
}
}
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
return nil
}
func (m *Scalars) MakeVDLTarget() vdl.Target {
return &ScalarsTarget{Value: m}
}
type ScalarsTarget struct {
Value *Scalars
a0Target vdl.BoolTarget
a1Target vdl.ByteTarget
a2Target vdl.Uint16Target
a3Target vdl.Uint32Target
a4Target vdl.Uint64Target
a5Target vdl.Int8Target
a6Target vdl.Int16Target
a7Target vdl.Int32Target
a8Target vdl.Int64Target
a9Target vdl.Float32Target
a10Target vdl.Float64Target
a11Target vdl.Complex64Target
a12Target vdl.Complex128Target
a13Target vdl.StringTarget
a14Target verror.ErrorTarget
a16Target vdl.TypeObjectTarget
b0Target NamedBoolTarget
b1Target NamedByteTarget
b2Target NamedUint16Target
b3Target NamedUint32Target
b4Target NamedUint64Target
b5Target NamedInt8Target
b6Target NamedInt16Target
b7Target NamedInt32Target
b8Target NamedInt64Target
b9Target NamedFloat32Target
b10Target NamedFloat64Target
b11Target NamedComplex64Target
b12Target NamedComplex128Target
b13Target NamedStringTarget
b14Target NamedEnumTarget
b15Target NamedUnionTarget
vdl.TargetBase
vdl.FieldsTargetBase
}
func (t *ScalarsTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
if ttWant := vdl.TypeOf((*Scalars)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
return t, nil
}
func (t *ScalarsTarget) StartField(name string) (key, field vdl.Target, _ error) {
switch name {
case "A0":
t.a0Target.Value = &t.Value.A0
target, err := &t.a0Target, error(nil)
return nil, target, err
case "A1":
t.a1Target.Value = &t.Value.A1
target, err := &t.a1Target, error(nil)
return nil, target, err
case "A2":
t.a2Target.Value = &t.Value.A2
target, err := &t.a2Target, error(nil)
return nil, target, err
case "A3":
t.a3Target.Value = &t.Value.A3
target, err := &t.a3Target, error(nil)
return nil, target, err
case "A4":
t.a4Target.Value = &t.Value.A4
target, err := &t.a4Target, error(nil)
return nil, target, err
case "A5":
t.a5Target.Value = &t.Value.A5
target, err := &t.a5Target, error(nil)
return nil, target, err
case "A6":
t.a6Target.Value = &t.Value.A6
target, err := &t.a6Target, error(nil)
return nil, target, err
case "A7":
t.a7Target.Value = &t.Value.A7
target, err := &t.a7Target, error(nil)
return nil, target, err
case "A8":
t.a8Target.Value = &t.Value.A8
target, err := &t.a8Target, error(nil)
return nil, target, err
case "A9":
t.a9Target.Value = &t.Value.A9
target, err := &t.a9Target, error(nil)
return nil, target, err
case "A10":
t.a10Target.Value = &t.Value.A10
target, err := &t.a10Target, error(nil)
return nil, target, err
case "A11":
t.a11Target.Value = &t.Value.A11
target, err := &t.a11Target, error(nil)
return nil, target, err
case "A12":
t.a12Target.Value = &t.Value.A12
target, err := &t.a12Target, error(nil)
return nil, target, err
case "A13":
t.a13Target.Value = &t.Value.A13
target, err := &t.a13Target, error(nil)
return nil, target, err
case "A14":
t.a14Target.Value = &t.Value.A14
target, err := &t.a14Target, error(nil)
return nil, target, err
case "A15":
target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.A15))
return nil, target, err
case "A16":
t.a16Target.Value = &t.Value.A16
target, err := &t.a16Target, error(nil)
return nil, target, err
case "B0":
t.b0Target.Value = &t.Value.B0
target, err := &t.b0Target, error(nil)
return nil, target, err
case "B1":
t.b1Target.Value = &t.Value.B1
target, err := &t.b1Target, error(nil)
return nil, target, err
case "B2":
t.b2Target.Value = &t.Value.B2
target, err := &t.b2Target, error(nil)
return nil, target, err
case "B3":
t.b3Target.Value = &t.Value.B3
target, err := &t.b3Target, error(nil)
return nil, target, err
case "B4":
t.b4Target.Value = &t.Value.B4
target, err := &t.b4Target, error(nil)
return nil, target, err
case "B5":
t.b5Target.Value = &t.Value.B5
target, err := &t.b5Target, error(nil)
return nil, target, err
case "B6":
t.b6Target.Value = &t.Value.B6
target, err := &t.b6Target, error(nil)
return nil, target, err
case "B7":
t.b7Target.Value = &t.Value.B7
target, err := &t.b7Target, error(nil)
return nil, target, err
case "B8":
t.b8Target.Value = &t.Value.B8
target, err := &t.b8Target, error(nil)
return nil, target, err
case "B9":
t.b9Target.Value = &t.Value.B9
target, err := &t.b9Target, error(nil)
return nil, target, err
case "B10":
t.b10Target.Value = &t.Value.B10
target, err := &t.b10Target, error(nil)
return nil, target, err
case "B11":
t.b11Target.Value = &t.Value.B11
target, err := &t.b11Target, error(nil)
return nil, target, err
case "B12":
t.b12Target.Value = &t.Value.B12
target, err := &t.b12Target, error(nil)
return nil, target, err
case "B13":
t.b13Target.Value = &t.Value.B13
target, err := &t.b13Target, error(nil)
return nil, target, err
case "B14":
t.b14Target.Value = &t.Value.B14
target, err := &t.b14Target, error(nil)
return nil, target, err
case "B15":
t.b15Target.Value = &t.Value.B15
target, err := &t.b15Target, error(nil)
return nil, target, err
default:
return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/lib/vdl/testdata/base.Scalars", name)
}
}
func (t *ScalarsTarget) FinishField(_, _ vdl.Target) error {
return nil
}
func (t *ScalarsTarget) FinishFields(_ vdl.FieldsTarget) error {
return nil
}
// These are all scalars that may be used as map or set keys.
type KeyScalars struct {
A0 bool
A1 byte
A2 uint16
A3 uint32
A4 uint64
A5 int8
A6 int16
A7 int32
A8 int64
A9 float32
A10 float64
A11 complex64
A12 complex128
A13 string
B0 NamedBool
B1 NamedByte
B2 NamedUint16
B3 NamedUint32
B4 NamedUint64
B5 NamedInt8
B6 NamedInt16
B7 NamedInt32
B8 NamedInt64
B9 NamedFloat32
B10 NamedFloat64
B11 NamedComplex64
B12 NamedComplex128
B13 NamedString
}
func (KeyScalars) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.KeyScalars"`
}) {
}
func (m *KeyScalars) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
fieldsTarget1, err := t.StartFields(tt)
if err != nil {
return err
}
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A0")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget3.FromBool(bool(m.A0), tt.NonOptional().Field(0).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("A1")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget5.FromUint(uint64(m.A1), tt.NonOptional().Field(1).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
return err
}
}
keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("A2")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget7.FromUint(uint64(m.A2), tt.NonOptional().Field(2).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
return err
}
}
keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("A3")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget9.FromUint(uint64(m.A3), tt.NonOptional().Field(3).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("A4")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget11.FromUint(uint64(m.A4), tt.NonOptional().Field(4).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
return err
}
}
keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("A5")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget13.FromInt(int64(m.A5), tt.NonOptional().Field(5).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
return err
}
}
keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("A6")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget15.FromInt(int64(m.A6), tt.NonOptional().Field(6).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
}
keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("A7")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget17.FromInt(int64(m.A7), tt.NonOptional().Field(7).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget16, fieldTarget17); err != nil {
return err
}
}
keyTarget18, fieldTarget19, err := fieldsTarget1.StartField("A8")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget19.FromInt(int64(m.A8), tt.NonOptional().Field(8).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget18, fieldTarget19); err != nil {
return err
}
}
keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("A9")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget21.FromFloat(float64(m.A9), tt.NonOptional().Field(9).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
return err
}
}
keyTarget22, fieldTarget23, err := fieldsTarget1.StartField("A10")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget23.FromFloat(float64(m.A10), tt.NonOptional().Field(10).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget22, fieldTarget23); err != nil {
return err
}
}
keyTarget24, fieldTarget25, err := fieldsTarget1.StartField("A11")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget25.FromComplex(complex128(m.A11), tt.NonOptional().Field(11).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget24, fieldTarget25); err != nil {
return err
}
}
keyTarget26, fieldTarget27, err := fieldsTarget1.StartField("A12")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget27.FromComplex(complex128(m.A12), tt.NonOptional().Field(12).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget26, fieldTarget27); err != nil {
return err
}
}
keyTarget28, fieldTarget29, err := fieldsTarget1.StartField("A13")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget29.FromString(string(m.A13), tt.NonOptional().Field(13).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget28, fieldTarget29); err != nil {
return err
}
}
keyTarget30, fieldTarget31, err := fieldsTarget1.StartField("B0")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B0.FillVDLTarget(fieldTarget31, tt.NonOptional().Field(14).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget30, fieldTarget31); err != nil {
return err
}
}
keyTarget32, fieldTarget33, err := fieldsTarget1.StartField("B1")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B1.FillVDLTarget(fieldTarget33, tt.NonOptional().Field(15).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget32, fieldTarget33); err != nil {
return err
}
}
keyTarget34, fieldTarget35, err := fieldsTarget1.StartField("B2")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B2.FillVDLTarget(fieldTarget35, tt.NonOptional().Field(16).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget34, fieldTarget35); err != nil {
return err
}
}
keyTarget36, fieldTarget37, err := fieldsTarget1.StartField("B3")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B3.FillVDLTarget(fieldTarget37, tt.NonOptional().Field(17).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget36, fieldTarget37); err != nil {
return err
}
}
keyTarget38, fieldTarget39, err := fieldsTarget1.StartField("B4")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B4.FillVDLTarget(fieldTarget39, tt.NonOptional().Field(18).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget38, fieldTarget39); err != nil {
return err
}
}
keyTarget40, fieldTarget41, err := fieldsTarget1.StartField("B5")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B5.FillVDLTarget(fieldTarget41, tt.NonOptional().Field(19).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget40, fieldTarget41); err != nil {
return err
}
}
keyTarget42, fieldTarget43, err := fieldsTarget1.StartField("B6")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B6.FillVDLTarget(fieldTarget43, tt.NonOptional().Field(20).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget42, fieldTarget43); err != nil {
return err
}
}
keyTarget44, fieldTarget45, err := fieldsTarget1.StartField("B7")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B7.FillVDLTarget(fieldTarget45, tt.NonOptional().Field(21).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget44, fieldTarget45); err != nil {
return err
}
}
keyTarget46, fieldTarget47, err := fieldsTarget1.StartField("B8")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B8.FillVDLTarget(fieldTarget47, tt.NonOptional().Field(22).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget46, fieldTarget47); err != nil {
return err
}
}
keyTarget48, fieldTarget49, err := fieldsTarget1.StartField("B9")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B9.FillVDLTarget(fieldTarget49, tt.NonOptional().Field(23).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget48, fieldTarget49); err != nil {
return err
}
}
keyTarget50, fieldTarget51, err := fieldsTarget1.StartField("B10")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B10.FillVDLTarget(fieldTarget51, tt.NonOptional().Field(24).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget50, fieldTarget51); err != nil {
return err
}
}
keyTarget52, fieldTarget53, err := fieldsTarget1.StartField("B11")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B11.FillVDLTarget(fieldTarget53, tt.NonOptional().Field(25).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget52, fieldTarget53); err != nil {
return err
}
}
keyTarget54, fieldTarget55, err := fieldsTarget1.StartField("B12")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B12.FillVDLTarget(fieldTarget55, tt.NonOptional().Field(26).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget54, fieldTarget55); err != nil {
return err
}
}
keyTarget56, fieldTarget57, err := fieldsTarget1.StartField("B13")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.B13.FillVDLTarget(fieldTarget57, tt.NonOptional().Field(27).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget56, fieldTarget57); err != nil {
return err
}
}
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
return nil
}
func (m *KeyScalars) MakeVDLTarget() vdl.Target {
return &KeyScalarsTarget{Value: m}
}
type KeyScalarsTarget struct {
Value *KeyScalars
a0Target vdl.BoolTarget
a1Target vdl.ByteTarget
a2Target vdl.Uint16Target
a3Target vdl.Uint32Target
a4Target vdl.Uint64Target
a5Target vdl.Int8Target
a6Target vdl.Int16Target
a7Target vdl.Int32Target
a8Target vdl.Int64Target
a9Target vdl.Float32Target
a10Target vdl.Float64Target
a11Target vdl.Complex64Target
a12Target vdl.Complex128Target
a13Target vdl.StringTarget
b0Target NamedBoolTarget
b1Target NamedByteTarget
b2Target NamedUint16Target
b3Target NamedUint32Target
b4Target NamedUint64Target
b5Target NamedInt8Target
b6Target NamedInt16Target
b7Target NamedInt32Target
b8Target NamedInt64Target
b9Target NamedFloat32Target
b10Target NamedFloat64Target
b11Target NamedComplex64Target
b12Target NamedComplex128Target
b13Target NamedStringTarget
vdl.TargetBase
vdl.FieldsTargetBase
}
func (t *KeyScalarsTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
if ttWant := vdl.TypeOf((*KeyScalars)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
return t, nil
}
func (t *KeyScalarsTarget) StartField(name string) (key, field vdl.Target, _ error) {
switch name {
case "A0":
t.a0Target.Value = &t.Value.A0
target, err := &t.a0Target, error(nil)
return nil, target, err
case "A1":
t.a1Target.Value = &t.Value.A1
target, err := &t.a1Target, error(nil)
return nil, target, err
case "A2":
t.a2Target.Value = &t.Value.A2
target, err := &t.a2Target, error(nil)
return nil, target, err
case "A3":
t.a3Target.Value = &t.Value.A3
target, err := &t.a3Target, error(nil)
return nil, target, err
case "A4":
t.a4Target.Value = &t.Value.A4
target, err := &t.a4Target, error(nil)
return nil, target, err
case "A5":
t.a5Target.Value = &t.Value.A5
target, err := &t.a5Target, error(nil)
return nil, target, err
case "A6":
t.a6Target.Value = &t.Value.A6
target, err := &t.a6Target, error(nil)
return nil, target, err
case "A7":
t.a7Target.Value = &t.Value.A7
target, err := &t.a7Target, error(nil)
return nil, target, err
case "A8":
t.a8Target.Value = &t.Value.A8
target, err := &t.a8Target, error(nil)
return nil, target, err
case "A9":
t.a9Target.Value = &t.Value.A9
target, err := &t.a9Target, error(nil)
return nil, target, err
case "A10":
t.a10Target.Value = &t.Value.A10
target, err := &t.a10Target, error(nil)
return nil, target, err
case "A11":
t.a11Target.Value = &t.Value.A11
target, err := &t.a11Target, error(nil)
return nil, target, err
case "A12":
t.a12Target.Value = &t.Value.A12
target, err := &t.a12Target, error(nil)
return nil, target, err
case "A13":
t.a13Target.Value = &t.Value.A13
target, err := &t.a13Target, error(nil)
return nil, target, err
case "B0":
t.b0Target.Value = &t.Value.B0
target, err := &t.b0Target, error(nil)
return nil, target, err
case "B1":
t.b1Target.Value = &t.Value.B1
target, err := &t.b1Target, error(nil)
return nil, target, err
case "B2":
t.b2Target.Value = &t.Value.B2
target, err := &t.b2Target, error(nil)
return nil, target, err
case "B3":
t.b3Target.Value = &t.Value.B3
target, err := &t.b3Target, error(nil)
return nil, target, err
case "B4":
t.b4Target.Value = &t.Value.B4
target, err := &t.b4Target, error(nil)
return nil, target, err
case "B5":
t.b5Target.Value = &t.Value.B5
target, err := &t.b5Target, error(nil)
return nil, target, err
case "B6":
t.b6Target.Value = &t.Value.B6
target, err := &t.b6Target, error(nil)
return nil, target, err
case "B7":
t.b7Target.Value = &t.Value.B7
target, err := &t.b7Target, error(nil)
return nil, target, err
case "B8":
t.b8Target.Value = &t.Value.B8
target, err := &t.b8Target, error(nil)
return nil, target, err
case "B9":
t.b9Target.Value = &t.Value.B9
target, err := &t.b9Target, error(nil)
return nil, target, err
case "B10":
t.b10Target.Value = &t.Value.B10
target, err := &t.b10Target, error(nil)
return nil, target, err
case "B11":
t.b11Target.Value = &t.Value.B11
target, err := &t.b11Target, error(nil)
return nil, target, err
case "B12":
t.b12Target.Value = &t.Value.B12
target, err := &t.b12Target, error(nil)
return nil, target, err
case "B13":
t.b13Target.Value = &t.Value.B13
target, err := &t.b13Target, error(nil)
return nil, target, err
default:
return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/lib/vdl/testdata/base.KeyScalars", name)
}
}
func (t *KeyScalarsTarget) FinishField(_, _ vdl.Target) error {
return nil
}
func (t *KeyScalarsTarget) FinishFields(_ vdl.FieldsTarget) error {
return nil
}
type ScalarsArray [2]Scalars
func (ScalarsArray) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.ScalarsArray"`
}) {
}
func (m *ScalarsArray) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
listTarget1, err := t.StartList(tt, 2)
if err != nil {
return err
}
for i, elem3 := range *m {
elemTarget2, err := listTarget1.StartElem(i)
if err != nil {
return err
}
if err := elem3.FillVDLTarget(elemTarget2, tt.NonOptional().Elem()); err != nil {
return err
}
if err := listTarget1.FinishElem(elemTarget2); err != nil {
return err
}
}
if err := t.FinishList(listTarget1); err != nil {
return err
}
return nil
}
func (m *ScalarsArray) MakeVDLTarget() vdl.Target {
return &ScalarsArrayTarget{Value: m}
}
// ScalarsArray
type ScalarsArrayTarget struct {
Value *ScalarsArray
elemTarget ScalarsTarget
vdl.TargetBase
vdl.ListTargetBase
}
func (t *ScalarsArrayTarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
if ttWant := vdl.TypeOf((*ScalarsArray)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
return t, nil
}
func (t *ScalarsArrayTarget) StartElem(index int) (elem vdl.Target, _ error) {
t.elemTarget.Value = &(*t.Value)[index]
target, err := &t.elemTarget, error(nil)
return target, err
}
func (t *ScalarsArrayTarget) FinishElem(elem vdl.Target) error {
return nil
}
func (t *ScalarsArrayTarget) FinishList(elem vdl.ListTarget) error {
return nil
}
type Composites struct {
A0 Scalars
A1 ScalarsArray
A2 []Scalars
A3 map[KeyScalars]struct{}
A4 map[string]Scalars
A5 map[KeyScalars][]map[string]complex128
}
func (Composites) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.Composites"`
}) {
}
func (m *Composites) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
fieldsTarget1, err := t.StartFields(tt)
if err != nil {
return err
}
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A0")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.A0.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("A1")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.A1.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
return err
}
}
keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("A2")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
listTarget8, err := fieldTarget7.StartList(tt.NonOptional().Field(2).Type, len(m.A2))
if err != nil {
return err
}
for i, elem10 := range m.A2 {
elemTarget9, err := listTarget8.StartElem(i)
if err != nil {
return err
}
if err := elem10.FillVDLTarget(elemTarget9, tt.NonOptional().Field(2).Type.Elem()); err != nil {
return err
}
if err := listTarget8.FinishElem(elemTarget9); err != nil {
return err
}
}
if err := fieldTarget7.FinishList(listTarget8); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
return err
}
}
keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("A3")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
setTarget13, err := fieldTarget12.StartSet(tt.NonOptional().Field(3).Type, len(m.A3))
if err != nil {
return err
}
for key15 := range m.A3 {
keyTarget14, err := setTarget13.StartKey()
if err != nil {
return err
}
if err := key15.FillVDLTarget(keyTarget14, tt.NonOptional().Field(3).Type.Key()); err != nil {
return err
}
if err := setTarget13.FinishKey(keyTarget14); err != nil {
return err
}
}
if err := fieldTarget12.FinishSet(setTarget13); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("A4")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
mapTarget18, err := fieldTarget17.StartMap(tt.NonOptional().Field(4).Type, len(m.A4))
if err != nil {
return err
}
for key20, value22 := range m.A4 {
keyTarget19, err := mapTarget18.StartKey()
if err != nil {
return err
}
if err := keyTarget19.FromString(string(key20), tt.NonOptional().Field(4).Type.Key()); err != nil {
return err
}
valueTarget21, err := mapTarget18.FinishKeyStartField(keyTarget19)
if err != nil {
return err
}
if err := value22.FillVDLTarget(valueTarget21, tt.NonOptional().Field(4).Type.Elem()); err != nil {
return err
}
if err := mapTarget18.FinishField(keyTarget19, valueTarget21); err != nil {
return err
}
}
if err := fieldTarget17.FinishMap(mapTarget18); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget16, fieldTarget17); err != nil {
return err
}
}
keyTarget23, fieldTarget24, err := fieldsTarget1.StartField("A5")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
mapTarget25, err := fieldTarget24.StartMap(tt.NonOptional().Field(5).Type, len(m.A5))
if err != nil {
return err
}
for key27, value29 := range m.A5 {
keyTarget26, err := mapTarget25.StartKey()
if err != nil {
return err
}
if err := key27.FillVDLTarget(keyTarget26, tt.NonOptional().Field(5).Type.Key()); err != nil {
return err
}
valueTarget28, err := mapTarget25.FinishKeyStartField(keyTarget26)
if err != nil {
return err
}
listTarget30, err := valueTarget28.StartList(tt.NonOptional().Field(5).Type.Elem(), len(value29))
if err != nil {
return err
}
for i, elem32 := range value29 {
elemTarget31, err := listTarget30.StartElem(i)
if err != nil {
return err
}
mapTarget33, err := elemTarget31.StartMap(tt.NonOptional().Field(5).Type.Elem().Elem(), len(elem32))
if err != nil {
return err
}
for key35, value37 := range elem32 {
keyTarget34, err := mapTarget33.StartKey()
if err != nil {
return err
}
if err := keyTarget34.FromString(string(key35), tt.NonOptional().Field(5).Type.Elem().Elem().Key()); err != nil {
return err
}
valueTarget36, err := mapTarget33.FinishKeyStartField(keyTarget34)
if err != nil {
return err
}
if err := valueTarget36.FromComplex(complex128(value37), tt.NonOptional().Field(5).Type.Elem().Elem().Elem()); err != nil {
return err
}
if err := mapTarget33.FinishField(keyTarget34, valueTarget36); err != nil {
return err
}
}
if err := elemTarget31.FinishMap(mapTarget33); err != nil {
return err
}
if err := listTarget30.FinishElem(elemTarget31); err != nil {
return err
}
}
if err := valueTarget28.FinishList(listTarget30); err != nil {
return err
}
if err := mapTarget25.FinishField(keyTarget26, valueTarget28); err != nil {
return err
}
}
if err := fieldTarget24.FinishMap(mapTarget25); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget23, fieldTarget24); err != nil {
return err
}
}
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
return nil
}
func (m *Composites) MakeVDLTarget() vdl.Target {
return &CompositesTarget{Value: m}
}
type CompositesTarget struct {
Value *Composites
a0Target ScalarsTarget
a1Target ScalarsArrayTarget
a2Target __VDLTarget1_list
a3Target __VDLTarget2_set
a4Target __VDLTarget3_map
a5Target __VDLTarget4_map
vdl.TargetBase
vdl.FieldsTargetBase
}
func (t *CompositesTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
if ttWant := vdl.TypeOf((*Composites)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
return t, nil
}
func (t *CompositesTarget) StartField(name string) (key, field vdl.Target, _ error) {
switch name {
case "A0":
t.a0Target.Value = &t.Value.A0
target, err := &t.a0Target, error(nil)
return nil, target, err
case "A1":
t.a1Target.Value = &t.Value.A1
target, err := &t.a1Target, error(nil)
return nil, target, err
case "A2":
t.a2Target.Value = &t.Value.A2
target, err := &t.a2Target, error(nil)
return nil, target, err
case "A3":
t.a3Target.Value = &t.Value.A3
target, err := &t.a3Target, error(nil)
return nil, target, err
case "A4":
t.a4Target.Value = &t.Value.A4
target, err := &t.a4Target, error(nil)
return nil, target, err
case "A5":
t.a5Target.Value = &t.Value.A5
target, err := &t.a5Target, error(nil)
return nil, target, err
default:
return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/lib/vdl/testdata/base.Composites", name)
}
}
func (t *CompositesTarget) FinishField(_, _ vdl.Target) error {
return nil
}
func (t *CompositesTarget) FinishFields(_ vdl.FieldsTarget) error {
return nil
}
// []Scalars
type __VDLTarget1_list struct {
Value *[]Scalars
elemTarget ScalarsTarget
vdl.TargetBase
vdl.ListTargetBase
}
func (t *__VDLTarget1_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
if ttWant := vdl.TypeOf((*[]Scalars)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
if cap(*t.Value) < len {
*t.Value = make([]Scalars, len)
} else {
*t.Value = (*t.Value)[:len]
}
return t, nil
}
func (t *__VDLTarget1_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 *__VDLTarget1_list) FinishElem(elem vdl.Target) error {
return nil
}
func (t *__VDLTarget1_list) FinishList(elem vdl.ListTarget) error {
return nil
}
// map[KeyScalars]struct{}
type __VDLTarget2_set struct {
Value *map[KeyScalars]struct{}
currKey KeyScalars
keyTarget KeyScalarsTarget
vdl.TargetBase
vdl.SetTargetBase
}
func (t *__VDLTarget2_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {
if ttWant := vdl.TypeOf((*map[KeyScalars]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
*t.Value = make(map[KeyScalars]struct{})
return t, nil
}
func (t *__VDLTarget2_set) StartKey() (key vdl.Target, _ error) {
t.currKey = KeyScalars{}
t.keyTarget.Value = &t.currKey
target, err := &t.keyTarget, error(nil)
return target, err
}
func (t *__VDLTarget2_set) FinishKey(key vdl.Target) error {
(*t.Value)[t.currKey] = struct{}{}
return nil
}
func (t *__VDLTarget2_set) FinishSet(list vdl.SetTarget) error {
if len(*t.Value) == 0 {
*t.Value = nil
}
return nil
}
// map[string]Scalars
type __VDLTarget3_map struct {
Value *map[string]Scalars
currKey string
currElem Scalars
keyTarget vdl.StringTarget
elemTarget ScalarsTarget
vdl.TargetBase
vdl.MapTargetBase
}
func (t *__VDLTarget3_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {
if ttWant := vdl.TypeOf((*map[string]Scalars)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
*t.Value = make(map[string]Scalars)
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 = Scalars{
A16: vdl.AnyType,
B15: NamedUnionA{},
}
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
}
// map[KeyScalars][]map[string]complex128
type __VDLTarget4_map struct {
Value *map[KeyScalars][]map[string]complex128
currKey KeyScalars
currElem []map[string]complex128
keyTarget KeyScalarsTarget
elemTarget __VDLTarget5_list
vdl.TargetBase
vdl.MapTargetBase
}
func (t *__VDLTarget4_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {
if ttWant := vdl.TypeOf((*map[KeyScalars][]map[string]complex128)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
*t.Value = make(map[KeyScalars][]map[string]complex128)
return t, nil
}
func (t *__VDLTarget4_map) StartKey() (key vdl.Target, _ error) {
t.currKey = KeyScalars{}
t.keyTarget.Value = &t.currKey
target, err := &t.keyTarget, error(nil)
return target, err
}
func (t *__VDLTarget4_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
t.currElem = []map[string]complex128(nil)
t.elemTarget.Value = &t.currElem
target, err := &t.elemTarget, error(nil)
return target, err
}
func (t *__VDLTarget4_map) FinishField(key, field vdl.Target) error {
(*t.Value)[t.currKey] = t.currElem
return nil
}
func (t *__VDLTarget4_map) FinishMap(elem vdl.MapTarget) error {
if len(*t.Value) == 0 {
*t.Value = nil
}
return nil
}
// []map[string]complex128
type __VDLTarget5_list struct {
Value *[]map[string]complex128
elemTarget __VDLTarget6_map
vdl.TargetBase
vdl.ListTargetBase
}
func (t *__VDLTarget5_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
if ttWant := vdl.TypeOf((*[]map[string]complex128)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
if cap(*t.Value) < len {
*t.Value = make([]map[string]complex128, len)
} else {
*t.Value = (*t.Value)[:len]
}
return t, nil
}
func (t *__VDLTarget5_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 *__VDLTarget5_list) FinishElem(elem vdl.Target) error {
return nil
}
func (t *__VDLTarget5_list) FinishList(elem vdl.ListTarget) error {
return nil
}
// map[string]complex128
type __VDLTarget6_map struct {
Value *map[string]complex128
currKey string
currElem complex128
keyTarget vdl.StringTarget
elemTarget vdl.Complex128Target
vdl.TargetBase
vdl.MapTargetBase
}
func (t *__VDLTarget6_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {
if ttWant := vdl.TypeOf((*map[string]complex128)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
*t.Value = make(map[string]complex128)
return t, nil
}
func (t *__VDLTarget6_map) StartKey() (key vdl.Target, _ error) {
t.currKey = ""
t.keyTarget.Value = &t.currKey
target, err := &t.keyTarget, error(nil)
return target, err
}
func (t *__VDLTarget6_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
t.currElem = complex128(0)
t.elemTarget.Value = &t.currElem
target, err := &t.elemTarget, error(nil)
return target, err
}
func (t *__VDLTarget6_map) FinishField(key, field vdl.Target) error {
(*t.Value)[t.currKey] = t.currElem
return nil
}
func (t *__VDLTarget6_map) FinishMap(elem vdl.MapTarget) error {
if len(*t.Value) == 0 {
*t.Value = nil
}
return nil
}
type CompositesArray [2]Composites
func (CompositesArray) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.CompositesArray"`
}) {
}
func (m *CompositesArray) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
listTarget1, err := t.StartList(tt, 2)
if err != nil {
return err
}
for i, elem3 := range *m {
elemTarget2, err := listTarget1.StartElem(i)
if err != nil {
return err
}
if err := elem3.FillVDLTarget(elemTarget2, tt.NonOptional().Elem()); err != nil {
return err
}
if err := listTarget1.FinishElem(elemTarget2); err != nil {
return err
}
}
if err := t.FinishList(listTarget1); err != nil {
return err
}
return nil
}
func (m *CompositesArray) MakeVDLTarget() vdl.Target {
return &CompositesArrayTarget{Value: m}
}
// CompositesArray
type CompositesArrayTarget struct {
Value *CompositesArray
elemTarget CompositesTarget
vdl.TargetBase
vdl.ListTargetBase
}
func (t *CompositesArrayTarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
if ttWant := vdl.TypeOf((*CompositesArray)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
return t, nil
}
func (t *CompositesArrayTarget) StartElem(index int) (elem vdl.Target, _ error) {
t.elemTarget.Value = &(*t.Value)[index]
target, err := &t.elemTarget, error(nil)
return target, err
}
func (t *CompositesArrayTarget) FinishElem(elem vdl.Target) error {
return nil
}
func (t *CompositesArrayTarget) FinishList(elem vdl.ListTarget) error {
return nil
}
type CompComp struct {
A0 Composites
A1 CompositesArray
A2 []Composites
A3 map[string]Composites
A4 map[KeyScalars][]map[string]Composites
}
func (CompComp) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.CompComp"`
}) {
}
func (m *CompComp) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
fieldsTarget1, err := t.StartFields(tt)
if err != nil {
return err
}
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A0")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.A0.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("A1")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.A1.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
return err
}
}
keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("A2")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
listTarget8, err := fieldTarget7.StartList(tt.NonOptional().Field(2).Type, len(m.A2))
if err != nil {
return err
}
for i, elem10 := range m.A2 {
elemTarget9, err := listTarget8.StartElem(i)
if err != nil {
return err
}
if err := elem10.FillVDLTarget(elemTarget9, tt.NonOptional().Field(2).Type.Elem()); err != nil {
return err
}
if err := listTarget8.FinishElem(elemTarget9); err != nil {
return err
}
}
if err := fieldTarget7.FinishList(listTarget8); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
return err
}
}
keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("A3")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
mapTarget13, err := fieldTarget12.StartMap(tt.NonOptional().Field(3).Type, len(m.A3))
if err != nil {
return err
}
for key15, value17 := range m.A3 {
keyTarget14, err := mapTarget13.StartKey()
if err != nil {
return err
}
if err := keyTarget14.FromString(string(key15), tt.NonOptional().Field(3).Type.Key()); err != nil {
return err
}
valueTarget16, err := mapTarget13.FinishKeyStartField(keyTarget14)
if err != nil {
return err
}
if err := value17.FillVDLTarget(valueTarget16, tt.NonOptional().Field(3).Type.Elem()); err != nil {
return err
}
if err := mapTarget13.FinishField(keyTarget14, valueTarget16); err != nil {
return err
}
}
if err := fieldTarget12.FinishMap(mapTarget13); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
keyTarget18, fieldTarget19, err := fieldsTarget1.StartField("A4")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
mapTarget20, err := fieldTarget19.StartMap(tt.NonOptional().Field(4).Type, len(m.A4))
if err != nil {
return err
}
for key22, value24 := range m.A4 {
keyTarget21, err := mapTarget20.StartKey()
if err != nil {
return err
}
if err := key22.FillVDLTarget(keyTarget21, tt.NonOptional().Field(4).Type.Key()); err != nil {
return err
}
valueTarget23, err := mapTarget20.FinishKeyStartField(keyTarget21)
if err != nil {
return err
}
listTarget25, err := valueTarget23.StartList(tt.NonOptional().Field(4).Type.Elem(), len(value24))
if err != nil {
return err
}
for i, elem27 := range value24 {
elemTarget26, err := listTarget25.StartElem(i)
if err != nil {
return err
}
mapTarget28, err := elemTarget26.StartMap(tt.NonOptional().Field(4).Type.Elem().Elem(), len(elem27))
if err != nil {
return err
}
for key30, value32 := range elem27 {
keyTarget29, err := mapTarget28.StartKey()
if err != nil {
return err
}
if err := keyTarget29.FromString(string(key30), tt.NonOptional().Field(4).Type.Elem().Elem().Key()); err != nil {
return err
}
valueTarget31, err := mapTarget28.FinishKeyStartField(keyTarget29)
if err != nil {
return err
}
if err := value32.FillVDLTarget(valueTarget31, tt.NonOptional().Field(4).Type.Elem().Elem().Elem()); err != nil {
return err
}
if err := mapTarget28.FinishField(keyTarget29, valueTarget31); err != nil {
return err
}
}
if err := elemTarget26.FinishMap(mapTarget28); err != nil {
return err
}
if err := listTarget25.FinishElem(elemTarget26); err != nil {
return err
}
}
if err := valueTarget23.FinishList(listTarget25); err != nil {
return err
}
if err := mapTarget20.FinishField(keyTarget21, valueTarget23); err != nil {
return err
}
}
if err := fieldTarget19.FinishMap(mapTarget20); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget18, fieldTarget19); err != nil {
return err
}
}
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
return nil
}
func (m *CompComp) MakeVDLTarget() vdl.Target {
return &CompCompTarget{Value: m}
}
type CompCompTarget struct {
Value *CompComp
a0Target CompositesTarget
a1Target CompositesArrayTarget
a2Target __VDLTarget7_list
a3Target __VDLTarget8_map
a4Target __VDLTarget9_map
vdl.TargetBase
vdl.FieldsTargetBase
}
func (t *CompCompTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
if ttWant := vdl.TypeOf((*CompComp)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
return t, nil
}
func (t *CompCompTarget) StartField(name string) (key, field vdl.Target, _ error) {
switch name {
case "A0":
t.a0Target.Value = &t.Value.A0
target, err := &t.a0Target, error(nil)
return nil, target, err
case "A1":
t.a1Target.Value = &t.Value.A1
target, err := &t.a1Target, error(nil)
return nil, target, err
case "A2":
t.a2Target.Value = &t.Value.A2
target, err := &t.a2Target, error(nil)
return nil, target, err
case "A3":
t.a3Target.Value = &t.Value.A3
target, err := &t.a3Target, error(nil)
return nil, target, err
case "A4":
t.a4Target.Value = &t.Value.A4
target, err := &t.a4Target, error(nil)
return nil, target, err
default:
return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/lib/vdl/testdata/base.CompComp", name)
}
}
func (t *CompCompTarget) FinishField(_, _ vdl.Target) error {
return nil
}
func (t *CompCompTarget) FinishFields(_ vdl.FieldsTarget) error {
return nil
}
// []Composites
type __VDLTarget7_list struct {
Value *[]Composites
elemTarget CompositesTarget
vdl.TargetBase
vdl.ListTargetBase
}
func (t *__VDLTarget7_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
if ttWant := vdl.TypeOf((*[]Composites)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
if cap(*t.Value) < len {
*t.Value = make([]Composites, len)
} else {
*t.Value = (*t.Value)[:len]
}
return t, nil
}
func (t *__VDLTarget7_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 *__VDLTarget7_list) FinishElem(elem vdl.Target) error {
return nil
}
func (t *__VDLTarget7_list) FinishList(elem vdl.ListTarget) error {
return nil
}
// map[string]Composites
type __VDLTarget8_map struct {
Value *map[string]Composites
currKey string
currElem Composites
keyTarget vdl.StringTarget
elemTarget CompositesTarget
vdl.TargetBase
vdl.MapTargetBase
}
func (t *__VDLTarget8_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {
if ttWant := vdl.TypeOf((*map[string]Composites)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
*t.Value = make(map[string]Composites)
return t, nil
}
func (t *__VDLTarget8_map) StartKey() (key vdl.Target, _ error) {
t.currKey = ""
t.keyTarget.Value = &t.currKey
target, err := &t.keyTarget, error(nil)
return target, err
}
func (t *__VDLTarget8_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
t.currElem = Composites{
A0: Scalars{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
A1: ScalarsArray{
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
},
}
t.elemTarget.Value = &t.currElem
target, err := &t.elemTarget, error(nil)
return target, err
}
func (t *__VDLTarget8_map) FinishField(key, field vdl.Target) error {
(*t.Value)[t.currKey] = t.currElem
return nil
}
func (t *__VDLTarget8_map) FinishMap(elem vdl.MapTarget) error {
if len(*t.Value) == 0 {
*t.Value = nil
}
return nil
}
// map[KeyScalars][]map[string]Composites
type __VDLTarget9_map struct {
Value *map[KeyScalars][]map[string]Composites
currKey KeyScalars
currElem []map[string]Composites
keyTarget KeyScalarsTarget
elemTarget __VDLTarget10_list
vdl.TargetBase
vdl.MapTargetBase
}
func (t *__VDLTarget9_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {
if ttWant := vdl.TypeOf((*map[KeyScalars][]map[string]Composites)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
*t.Value = make(map[KeyScalars][]map[string]Composites)
return t, nil
}
func (t *__VDLTarget9_map) StartKey() (key vdl.Target, _ error) {
t.currKey = KeyScalars{}
t.keyTarget.Value = &t.currKey
target, err := &t.keyTarget, error(nil)
return target, err
}
func (t *__VDLTarget9_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
t.currElem = []map[string]Composites(nil)
t.elemTarget.Value = &t.currElem
target, err := &t.elemTarget, error(nil)
return target, err
}
func (t *__VDLTarget9_map) FinishField(key, field vdl.Target) error {
(*t.Value)[t.currKey] = t.currElem
return nil
}
func (t *__VDLTarget9_map) FinishMap(elem vdl.MapTarget) error {
if len(*t.Value) == 0 {
*t.Value = nil
}
return nil
}
// []map[string]Composites
type __VDLTarget10_list struct {
Value *[]map[string]Composites
elemTarget __VDLTarget8_map
vdl.TargetBase
vdl.ListTargetBase
}
func (t *__VDLTarget10_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
if ttWant := vdl.TypeOf((*[]map[string]Composites)(nil)); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
if cap(*t.Value) < len {
*t.Value = make([]map[string]Composites, len)
} else {
*t.Value = (*t.Value)[:len]
}
return t, nil
}
func (t *__VDLTarget10_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 *__VDLTarget10_list) FinishElem(elem vdl.Target) error {
return nil
}
func (t *__VDLTarget10_list) FinishList(elem vdl.ListTarget) error {
return nil
}
// Args will be reordered to show up before NestedArgs in the generated output.
type Args struct {
A int32
B int32
}
func (Args) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.Args"`
}) {
}
func (m *Args) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
fieldsTarget1, err := t.StartFields(tt)
if err != nil {
return err
}
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget3.FromInt(int64(m.A), tt.NonOptional().Field(0).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("B")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := fieldTarget5.FromInt(int64(m.B), tt.NonOptional().Field(1).Type); err != nil {
return err
}
if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
return err
}
}
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
return nil
}
func (m *Args) MakeVDLTarget() vdl.Target {
return &ArgsTarget{Value: m}
}
type ArgsTarget struct {
Value *Args
aTarget vdl.Int32Target
bTarget vdl.Int32Target
vdl.TargetBase
vdl.FieldsTargetBase
}
func (t *ArgsTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
if ttWant := vdl.TypeOf((*Args)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
return t, nil
}
func (t *ArgsTarget) StartField(name string) (key, field vdl.Target, _ error) {
switch name {
case "A":
t.aTarget.Value = &t.Value.A
target, err := &t.aTarget, error(nil)
return nil, target, err
case "B":
t.bTarget.Value = &t.Value.B
target, err := &t.bTarget, error(nil)
return nil, target, err
default:
return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/lib/vdl/testdata/base.Args", name)
}
}
func (t *ArgsTarget) FinishField(_, _ vdl.Target) error {
return nil
}
func (t *ArgsTarget) FinishFields(_ vdl.FieldsTarget) error {
return nil
}
// NestedArgs is defined before Args; that's allowed in regular Go, and also
// allowed in our vdl files. The compiler will re-order dependent types to ease
// code generation in other languages.
type NestedArgs struct {
Args Args
}
func (NestedArgs) __VDLReflect(struct {
Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NestedArgs"`
}) {
}
func (m *NestedArgs) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
fieldsTarget1, err := t.StartFields(tt)
if err != nil {
return err
}
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Args")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
if err := m.Args.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 *NestedArgs) MakeVDLTarget() vdl.Target {
return &NestedArgsTarget{Value: m}
}
type NestedArgsTarget struct {
Value *NestedArgs
argsTarget ArgsTarget
vdl.TargetBase
vdl.FieldsTargetBase
}
func (t *NestedArgsTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
if ttWant := vdl.TypeOf((*NestedArgs)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
}
return t, nil
}
func (t *NestedArgsTarget) StartField(name string) (key, field vdl.Target, _ error) {
switch name {
case "Args":
t.argsTarget.Value = &t.Value.Args
target, err := &t.argsTarget, error(nil)
return nil, target, err
default:
return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/lib/vdl/testdata/base.NestedArgs", name)
}
}
func (t *NestedArgsTarget) FinishField(_, _ vdl.Target) error {
return nil
}
func (t *NestedArgsTarget) FinishFields(_ vdl.FieldsTarget) error {
return nil
}
// Create zero values for each type.
var (
__VDLZeroNamedBool = NamedBool(false)
__VDLZeroNamedByte = NamedByte(0)
__VDLZeroNamedUint16 = NamedUint16(0)
__VDLZeroNamedUint32 = NamedUint32(0)
__VDLZeroNamedUint64 = NamedUint64(0)
__VDLZeroNamedInt8 = NamedInt8(0)
__VDLZeroNamedInt16 = NamedInt16(0)
__VDLZeroNamedInt32 = NamedInt32(0)
__VDLZeroNamedInt64 = NamedInt64(0)
__VDLZeroNamedFloat32 = NamedFloat32(0)
__VDLZeroNamedFloat64 = NamedFloat64(0)
__VDLZeroNamedComplex64 = NamedComplex64(0)
__VDLZeroNamedComplex128 = NamedComplex128(0)
__VDLZeroNamedString = NamedString("")
__VDLZeroNamedEnum = NamedEnumA
__VDLZeroNamedArray = NamedArray{}
__VDLZeroNamedList = NamedList(nil)
__VDLZeroNamedSet = NamedSet(nil)
__VDLZeroNamedMap = NamedMap(nil)
__VDLZeroNamedStruct = NamedStruct{}
__VDLZeroNamedUnion = NamedUnion(NamedUnionA{})
__VDLZeroScalars = Scalars{
A16: vdl.AnyType,
B15: NamedUnionA{},
}
__VDLZeroKeyScalars = KeyScalars{}
__VDLZeroScalarsArray = ScalarsArray{
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
}
__VDLZeroComposites = Composites{
A0: Scalars{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
A1: ScalarsArray{
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
},
}
__VDLZeroCompositesArray = CompositesArray{
{
A0: Scalars{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
A1: ScalarsArray{
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
},
},
{
A0: Scalars{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
A1: ScalarsArray{
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
},
},
}
__VDLZeroCompComp = CompComp{
A0: Composites{
A0: Scalars{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
A1: ScalarsArray{
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
},
},
A1: CompositesArray{
{
A0: Scalars{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
A1: ScalarsArray{
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
},
},
{
A0: Scalars{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
A1: ScalarsArray{
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
{
A16: vdl.AnyType,
B15: NamedUnionA{},
},
},
},
},
}
__VDLZeroArgs = Args{}
__VDLZeroNestedArgs = NestedArgs{}
)
//////////////////////////////////////////////////
// Const definitions
const Cbool = true
const Cbyte = byte(1)
const Cint32 = int32(2)
const Cint64 = int64(3)
const Cuint32 = uint32(4)
const Cuint64 = uint64(5)
const Cfloat32 = float32(6)
const Cfloat64 = float64(7)
const CNamedBool = NamedBool(true)
var CNamedStruct = NamedStruct{
A: true,
B: "test",
}
const Ccomplex64 = complex64(8 + 9i)
const Ccomplex128 = complex128(10 + 11i)
const Cstring = "foo"
const Cenum = NamedEnumA
var Cunion = NamedUnion(NamedUnionA{true})
var Carray = NamedArray{
true,
false,
}
var Clist = []int32{
1,
2,
3,
}
var Cset = map[int32]struct{}{
1: struct{}{},
2: struct{}{},
3: struct{}{},
}
var cmap = map[int32]string{
1: "A",
2: "B",
3: "C",
}
var Cargs = Args{
A: 1,
B: 2,
}
var CScalars = Scalars{
A0: true,
A1: 1,
A2: 2,
A3: 3,
A4: 4,
A5: 5,
A6: 6,
A7: 7,
A8: 8,
A9: 9,
A10: 10,
A11: 11,
A12: 12,
A13: "abc",
A15: vom.RawBytesOf(false),
A16: vdl.TypeOf((*bool)(nil)),
B0: true,
B1: 1,
B2: 2,
B3: 3,
B4: 4,
B5: 5,
B6: 6,
B7: 7,
B8: 8,
B9: 9,
B10: 10,
B11: 11,
B12: 12,
B13: "abc",
B14: NamedEnumB,
B15: NamedUnionC{123},
}
const True = true
const Foo = "foo"
const Five = int32(5)
const Six = uint64(6)
const SixSquared = uint64(36)
const FiveSquared = int32(25)
var CTypeObject_bool = vdl.TypeOf((*bool)(nil))
var CTypeObject_string = vdl.TypeOf((*string)(nil))
var CTypeObject_bytes = vdl.TypeOf((*[]byte)(nil))
var CTypeObject_byte = vdl.TypeOf((*byte)(nil))
var CTypeObject_uint16 = vdl.TypeOf((*uint16)(nil))
var CTypeObject_int8 = vdl.TypeOf((*int8)(nil))
var CTypeObject_int16 = vdl.TypeOf((*int16)(nil))
var CTypeObject_float32 = vdl.TypeOf((*float32)(nil))
var CTypeObject_complex64 = vdl.TypeOf((*complex64)(nil))
var CTypeObject_enum = vdl.TypeOf((*NamedEnum)(nil))
var CTypeObject_Array = vdl.TypeOf((*NamedArray)(nil))
var CTypeObject_List = vdl.TypeOf((*[]string)(nil))
var CTypeObject_Set = vdl.TypeOf((*map[string]struct{})(nil))
var CTypeObject_Map = vdl.TypeOf((*map[string]int64)(nil))
var CTypeObject_Struct = vdl.TypeOf((*Scalars)(nil)).Elem()
var CTypeObject_Union = vdl.TypeOf((*NamedUnion)(nil))
var CTypeObject_TypeObject = vdl.TypeObjectType
var CTypeObject_Any = vdl.AnyType
//////////////////////////////////////////////////
// Error definitions
var (
ErrNoParams1 = verror.Register("v.io/x/ref/lib/vdl/testdata/base.NoParams1", verror.NoRetry, "{1:}{2:} en msg")
ErrNoParams2 = verror.Register("v.io/x/ref/lib/vdl/testdata/base.NoParams2", verror.RetryRefetch, "{1:}{2:} en msg")
ErrWithParams1 = verror.Register("v.io/x/ref/lib/vdl/testdata/base.WithParams1", verror.NoRetry, "{1:}{2:} en x={3} y={4}")
ErrWithParams2 = verror.Register("v.io/x/ref/lib/vdl/testdata/base.WithParams2", verror.RetryRefetch, "{1:}{2:} en x={3} y={4}")
errNotExported = verror.Register("v.io/x/ref/lib/vdl/testdata/base.notExported", verror.NoRetry, "{1:}{2:} en x={3} y={4}")
)
// NewErrNoParams1 returns an error with the ErrNoParams1 ID.
func NewErrNoParams1(ctx *context.T) error {
return verror.New(ErrNoParams1, ctx)
}
// NewErrNoParams2 returns an error with the ErrNoParams2 ID.
func NewErrNoParams2(ctx *context.T) error {
return verror.New(ErrNoParams2, ctx)
}
// NewErrWithParams1 returns an error with the ErrWithParams1 ID.
func NewErrWithParams1(ctx *context.T, x string, y int32) error {
return verror.New(ErrWithParams1, ctx, x, y)
}
// NewErrWithParams2 returns an error with the ErrWithParams2 ID.
func NewErrWithParams2(ctx *context.T, x string, y int32) error {
return verror.New(ErrWithParams2, ctx, x, y)
}
// newErrNotExported returns an error with the errNotExported ID.
func newErrNotExported(ctx *context.T, x string, y int32) error {
return verror.New(errNotExported, ctx, x, y)
}
//////////////////////////////////////////////////
// Interface definitions
// ServiceAClientMethods is the client interface
// containing ServiceA methods.
type ServiceAClientMethods interface {
MethodA1(*context.T, ...rpc.CallOpt) error
MethodA2(_ *context.T, a int32, b string, _ ...rpc.CallOpt) (s string, _ error)
MethodA3(_ *context.T, a int32, _ ...rpc.CallOpt) (ServiceAMethodA3ClientCall, error)
MethodA4(_ *context.T, a int32, _ ...rpc.CallOpt) (ServiceAMethodA4ClientCall, error)
}
// ServiceAClientStub adds universal methods to ServiceAClientMethods.
type ServiceAClientStub interface {
ServiceAClientMethods
rpc.UniversalServiceMethods
}
// ServiceAClient returns a client stub for ServiceA.
func ServiceAClient(name string) ServiceAClientStub {
return implServiceAClientStub{name}
}
type implServiceAClientStub struct {
name string
}
func (c implServiceAClientStub) MethodA1(ctx *context.T, opts ...rpc.CallOpt) (err error) {
err = v23.GetClient(ctx).Call(ctx, c.name, "MethodA1", nil, nil, opts...)
return
}
func (c implServiceAClientStub) MethodA2(ctx *context.T, i0 int32, i1 string, opts ...rpc.CallOpt) (o0 string, err error) {
err = v23.GetClient(ctx).Call(ctx, c.name, "MethodA2", []interface{}{i0, i1}, []interface{}{&o0}, opts...)
return
}
func (c implServiceAClientStub) MethodA3(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (ocall ServiceAMethodA3ClientCall, err error) {
var call rpc.ClientCall
if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "MethodA3", []interface{}{i0}, opts...); err != nil {
return
}
ocall = &implServiceAMethodA3ClientCall{ClientCall: call}
return
}
func (c implServiceAClientStub) MethodA4(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (ocall ServiceAMethodA4ClientCall, err error) {
var call rpc.ClientCall
if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "MethodA4", []interface{}{i0}, opts...); err != nil {
return
}
ocall = &implServiceAMethodA4ClientCall{ClientCall: call}
return
}
// ServiceAMethodA3ClientStream is the client stream for ServiceA.MethodA3.
type ServiceAMethodA3ClientStream interface {
// RecvStream returns the receiver side of the ServiceA.MethodA3 client stream.
RecvStream() interface {
// Advance stages an item so that it may be retrieved via Value. Returns
// true iff there is an item to retrieve. Advance must be called before
// Value is called. May block if an item is not available.
Advance() bool
// Value returns the item that was staged by Advance. May panic if Advance
// returned false or was not called. Never blocks.
Value() Scalars
// Err returns any error encountered by Advance. Never blocks.
Err() error
}
}
// ServiceAMethodA3ClientCall represents the call returned from ServiceA.MethodA3.
type ServiceAMethodA3ClientCall interface {
ServiceAMethodA3ClientStream
// Finish blocks until the server is done, and returns the positional return
// values for call.
//
// Finish returns immediately if the call has been canceled; depending on the
// timing the output could either be an error signaling cancelation, or the
// valid positional return values from the server.
//
// Calling Finish is mandatory for releasing stream resources, unless the call
// has been canceled or any of the other methods return an error. Finish should
// be called at most once.
Finish() (s string, _ error)
}
type implServiceAMethodA3ClientCall struct {
rpc.ClientCall
valRecv Scalars
errRecv error
}
func (c *implServiceAMethodA3ClientCall) RecvStream() interface {
Advance() bool
Value() Scalars
Err() error
} {
return implServiceAMethodA3ClientCallRecv{c}
}
type implServiceAMethodA3ClientCallRecv struct {
c *implServiceAMethodA3ClientCall
}
func (c implServiceAMethodA3ClientCallRecv) Advance() bool {
c.c.valRecv = Scalars{}
c.c.errRecv = c.c.Recv(&c.c.valRecv)
return c.c.errRecv == nil
}
func (c implServiceAMethodA3ClientCallRecv) Value() Scalars {
return c.c.valRecv
}
func (c implServiceAMethodA3ClientCallRecv) Err() error {
if c.c.errRecv == io.EOF {
return nil
}
return c.c.errRecv
}
func (c *implServiceAMethodA3ClientCall) Finish() (o0 string, err error) {
err = c.ClientCall.Finish(&o0)
return
}
// ServiceAMethodA4ClientStream is the client stream for ServiceA.MethodA4.
type ServiceAMethodA4ClientStream interface {
// RecvStream returns the receiver side of the ServiceA.MethodA4 client stream.
RecvStream() interface {
// Advance stages an item so that it may be retrieved via Value. Returns
// true iff there is an item to retrieve. Advance must be called before
// Value is called. May block if an item is not available.
Advance() bool
// Value returns the item that was staged by Advance. May panic if Advance
// returned false or was not called. Never blocks.
Value() string
// Err returns any error encountered by Advance. Never blocks.
Err() error
}
// SendStream returns the send side of the ServiceA.MethodA4 client stream.
SendStream() interface {
// Send places the item onto the output stream. Returns errors
// encountered while sending, or if Send is called after Close or
// the stream has been canceled. Blocks if there is no buffer
// space; will unblock when buffer space is available or after
// the stream has been canceled.
Send(item int32) error
// Close indicates to the server that no more items will be sent;
// server Recv calls will receive io.EOF after all sent items.
// This is an optional call - e.g. a client might call Close if it
// needs to continue receiving items from the server after it's
// done sending. Returns errors encountered while closing, or if
// Close is called after the stream has been canceled. Like Send,
// blocks if there is no buffer space available.
Close() error
}
}
// ServiceAMethodA4ClientCall represents the call returned from ServiceA.MethodA4.
type ServiceAMethodA4ClientCall interface {
ServiceAMethodA4ClientStream
// Finish performs the equivalent of SendStream().Close, then blocks until
// the server is done, and returns the positional return values for the call.
//
// Finish returns immediately if the call has been canceled; depending on the
// timing the output could either be an error signaling cancelation, or the
// valid positional return values from the server.
//
// Calling Finish is mandatory for releasing stream resources, unless the call
// has been canceled or any of the other methods return an error. Finish should
// be called at most once.
Finish() error
}
type implServiceAMethodA4ClientCall struct {
rpc.ClientCall
valRecv string
errRecv error
}
func (c *implServiceAMethodA4ClientCall) RecvStream() interface {
Advance() bool
Value() string
Err() error
} {
return implServiceAMethodA4ClientCallRecv{c}
}
type implServiceAMethodA4ClientCallRecv struct {
c *implServiceAMethodA4ClientCall
}
func (c implServiceAMethodA4ClientCallRecv) Advance() bool {
c.c.errRecv = c.c.Recv(&c.c.valRecv)
return c.c.errRecv == nil
}
func (c implServiceAMethodA4ClientCallRecv) Value() string {
return c.c.valRecv
}
func (c implServiceAMethodA4ClientCallRecv) Err() error {
if c.c.errRecv == io.EOF {
return nil
}
return c.c.errRecv
}
func (c *implServiceAMethodA4ClientCall) SendStream() interface {
Send(item int32) error
Close() error
} {
return implServiceAMethodA4ClientCallSend{c}
}
type implServiceAMethodA4ClientCallSend struct {
c *implServiceAMethodA4ClientCall
}
func (c implServiceAMethodA4ClientCallSend) Send(item int32) error {
return c.c.Send(item)
}
func (c implServiceAMethodA4ClientCallSend) Close() error {
return c.c.CloseSend()
}
func (c *implServiceAMethodA4ClientCall) Finish() (err error) {
err = c.ClientCall.Finish()
return
}
// ServiceAServerMethods is the interface a server writer
// implements for ServiceA.
type ServiceAServerMethods interface {
MethodA1(*context.T, rpc.ServerCall) error
MethodA2(_ *context.T, _ rpc.ServerCall, a int32, b string) (s string, _ error)
MethodA3(_ *context.T, _ ServiceAMethodA3ServerCall, a int32) (s string, _ error)
MethodA4(_ *context.T, _ ServiceAMethodA4ServerCall, a int32) error
}
// ServiceAServerStubMethods is the server interface containing
// ServiceA methods, as expected by rpc.Server.
// The only difference between this interface and ServiceAServerMethods
// is the streaming methods.
type ServiceAServerStubMethods interface {
MethodA1(*context.T, rpc.ServerCall) error
MethodA2(_ *context.T, _ rpc.ServerCall, a int32, b string) (s string, _ error)
MethodA3(_ *context.T, _ *ServiceAMethodA3ServerCallStub, a int32) (s string, _ error)
MethodA4(_ *context.T, _ *ServiceAMethodA4ServerCallStub, a int32) error
}
// ServiceAServerStub adds universal methods to ServiceAServerStubMethods.
type ServiceAServerStub interface {
ServiceAServerStubMethods
// Describe the ServiceA interfaces.
Describe__() []rpc.InterfaceDesc
}
// ServiceAServer returns a server stub for ServiceA.
// It converts an implementation of ServiceAServerMethods into
// an object that may be used by rpc.Server.
func ServiceAServer(impl ServiceAServerMethods) ServiceAServerStub {
stub := implServiceAServerStub{
impl: impl,
}
// Initialize GlobState; always check the stub itself first, to handle the
// case where the user has the Glob method defined in their VDL source.
if gs := rpc.NewGlobState(stub); gs != nil {
stub.gs = gs
} else if gs := rpc.NewGlobState(impl); gs != nil {
stub.gs = gs
}
return stub
}
type implServiceAServerStub struct {
impl ServiceAServerMethods
gs *rpc.GlobState
}
func (s implServiceAServerStub) MethodA1(ctx *context.T, call rpc.ServerCall) error {
return s.impl.MethodA1(ctx, call)
}
func (s implServiceAServerStub) MethodA2(ctx *context.T, call rpc.ServerCall, i0 int32, i1 string) (string, error) {
return s.impl.MethodA2(ctx, call, i0, i1)
}
func (s implServiceAServerStub) MethodA3(ctx *context.T, call *ServiceAMethodA3ServerCallStub, i0 int32) (string, error) {
return s.impl.MethodA3(ctx, call, i0)
}
func (s implServiceAServerStub) MethodA4(ctx *context.T, call *ServiceAMethodA4ServerCallStub, i0 int32) error {
return s.impl.MethodA4(ctx, call, i0)
}
func (s implServiceAServerStub) Globber() *rpc.GlobState {
return s.gs
}
func (s implServiceAServerStub) Describe__() []rpc.InterfaceDesc {
return []rpc.InterfaceDesc{ServiceADesc}
}
// ServiceADesc describes the ServiceA interface.
var ServiceADesc rpc.InterfaceDesc = descServiceA
// descServiceA hides the desc to keep godoc clean.
var descServiceA = rpc.InterfaceDesc{
Name: "ServiceA",
PkgPath: "v.io/x/ref/lib/vdl/testdata/base",
Methods: []rpc.MethodDesc{
{
Name: "MethodA1",
},
{
Name: "MethodA2",
InArgs: []rpc.ArgDesc{
{"a", ``}, // int32
{"b", ``}, // string
},
OutArgs: []rpc.ArgDesc{
{"s", ``}, // string
},
},
{
Name: "MethodA3",
InArgs: []rpc.ArgDesc{
{"a", ``}, // int32
},
OutArgs: []rpc.ArgDesc{
{"s", ``}, // string
},
Tags: []*vdl.Value{vdl.ValueOf("tag"), vdl.ValueOf(uint64(6))},
},
{
Name: "MethodA4",
InArgs: []rpc.ArgDesc{
{"a", ``}, // int32
},
},
},
}
// ServiceAMethodA3ServerStream is the server stream for ServiceA.MethodA3.
type ServiceAMethodA3ServerStream interface {
// SendStream returns the send side of the ServiceA.MethodA3 server stream.
SendStream() interface {
// Send places the item onto the output stream. Returns errors encountered
// while sending. Blocks if there is no buffer space; will unblock when
// buffer space is available.
Send(item Scalars) error
}
}
// ServiceAMethodA3ServerCall represents the context passed to ServiceA.MethodA3.
type ServiceAMethodA3ServerCall interface {
rpc.ServerCall
ServiceAMethodA3ServerStream
}
// ServiceAMethodA3ServerCallStub is a wrapper that converts rpc.StreamServerCall into
// a typesafe stub that implements ServiceAMethodA3ServerCall.
type ServiceAMethodA3ServerCallStub struct {
rpc.StreamServerCall
}
// Init initializes ServiceAMethodA3ServerCallStub from rpc.StreamServerCall.
func (s *ServiceAMethodA3ServerCallStub) Init(call rpc.StreamServerCall) {
s.StreamServerCall = call
}
// SendStream returns the send side of the ServiceA.MethodA3 server stream.
func (s *ServiceAMethodA3ServerCallStub) SendStream() interface {
Send(item Scalars) error
} {
return implServiceAMethodA3ServerCallSend{s}
}
type implServiceAMethodA3ServerCallSend struct {
s *ServiceAMethodA3ServerCallStub
}
func (s implServiceAMethodA3ServerCallSend) Send(item Scalars) error {
return s.s.Send(item)
}
// ServiceAMethodA4ServerStream is the server stream for ServiceA.MethodA4.
type ServiceAMethodA4ServerStream interface {
// RecvStream returns the receiver side of the ServiceA.MethodA4 server stream.
RecvStream() interface {
// Advance stages an item so that it may be retrieved via Value. Returns
// true iff there is an item to retrieve. Advance must be called before
// Value is called. May block if an item is not available.
Advance() bool
// Value returns the item that was staged by Advance. May panic if Advance
// returned false or was not called. Never blocks.
Value() int32
// Err returns any error encountered by Advance. Never blocks.
Err() error
}
// SendStream returns the send side of the ServiceA.MethodA4 server stream.
SendStream() interface {
// Send places the item onto the output stream. Returns errors encountered
// while sending. Blocks if there is no buffer space; will unblock when
// buffer space is available.
Send(item string) error
}
}
// ServiceAMethodA4ServerCall represents the context passed to ServiceA.MethodA4.
type ServiceAMethodA4ServerCall interface {
rpc.ServerCall
ServiceAMethodA4ServerStream
}
// ServiceAMethodA4ServerCallStub is a wrapper that converts rpc.StreamServerCall into
// a typesafe stub that implements ServiceAMethodA4ServerCall.
type ServiceAMethodA4ServerCallStub struct {
rpc.StreamServerCall
valRecv int32
errRecv error
}
// Init initializes ServiceAMethodA4ServerCallStub from rpc.StreamServerCall.
func (s *ServiceAMethodA4ServerCallStub) Init(call rpc.StreamServerCall) {
s.StreamServerCall = call
}
// RecvStream returns the receiver side of the ServiceA.MethodA4 server stream.
func (s *ServiceAMethodA4ServerCallStub) RecvStream() interface {
Advance() bool
Value() int32
Err() error
} {
return implServiceAMethodA4ServerCallRecv{s}
}
type implServiceAMethodA4ServerCallRecv struct {
s *ServiceAMethodA4ServerCallStub
}
func (s implServiceAMethodA4ServerCallRecv) Advance() bool {
s.s.errRecv = s.s.Recv(&s.s.valRecv)
return s.s.errRecv == nil
}
func (s implServiceAMethodA4ServerCallRecv) Value() int32 {
return s.s.valRecv
}
func (s implServiceAMethodA4ServerCallRecv) Err() error {
if s.s.errRecv == io.EOF {
return nil
}
return s.s.errRecv
}
// SendStream returns the send side of the ServiceA.MethodA4 server stream.
func (s *ServiceAMethodA4ServerCallStub) SendStream() interface {
Send(item string) error
} {
return implServiceAMethodA4ServerCallSend{s}
}
type implServiceAMethodA4ServerCallSend struct {
s *ServiceAMethodA4ServerCallStub
}
func (s implServiceAMethodA4ServerCallSend) Send(item string) error {
return s.s.Send(item)
}
// ServiceBClientMethods is the client interface
// containing ServiceB methods.
type ServiceBClientMethods interface {
ServiceAClientMethods
MethodB1(_ *context.T, a Scalars, b Composites, _ ...rpc.CallOpt) (c CompComp, _ error)
}
// ServiceBClientStub adds universal methods to ServiceBClientMethods.
type ServiceBClientStub interface {
ServiceBClientMethods
rpc.UniversalServiceMethods
}
// ServiceBClient returns a client stub for ServiceB.
func ServiceBClient(name string) ServiceBClientStub {
return implServiceBClientStub{name, ServiceAClient(name)}
}
type implServiceBClientStub struct {
name string
ServiceAClientStub
}
func (c implServiceBClientStub) MethodB1(ctx *context.T, i0 Scalars, i1 Composites, opts ...rpc.CallOpt) (o0 CompComp, err error) {
err = v23.GetClient(ctx).Call(ctx, c.name, "MethodB1", []interface{}{i0, i1}, []interface{}{&o0}, opts...)
return
}
// ServiceBServerMethods is the interface a server writer
// implements for ServiceB.
type ServiceBServerMethods interface {
ServiceAServerMethods
MethodB1(_ *context.T, _ rpc.ServerCall, a Scalars, b Composites) (c CompComp, _ error)
}
// ServiceBServerStubMethods is the server interface containing
// ServiceB methods, as expected by rpc.Server.
// The only difference between this interface and ServiceBServerMethods
// is the streaming methods.
type ServiceBServerStubMethods interface {
ServiceAServerStubMethods
MethodB1(_ *context.T, _ rpc.ServerCall, a Scalars, b Composites) (c CompComp, _ error)
}
// ServiceBServerStub adds universal methods to ServiceBServerStubMethods.
type ServiceBServerStub interface {
ServiceBServerStubMethods
// Describe the ServiceB interfaces.
Describe__() []rpc.InterfaceDesc
}
// ServiceBServer returns a server stub for ServiceB.
// It converts an implementation of ServiceBServerMethods into
// an object that may be used by rpc.Server.
func ServiceBServer(impl ServiceBServerMethods) ServiceBServerStub {
stub := implServiceBServerStub{
impl: impl,
ServiceAServerStub: ServiceAServer(impl),
}
// Initialize GlobState; always check the stub itself first, to handle the
// case where the user has the Glob method defined in their VDL source.
if gs := rpc.NewGlobState(stub); gs != nil {
stub.gs = gs
} else if gs := rpc.NewGlobState(impl); gs != nil {
stub.gs = gs
}
return stub
}
type implServiceBServerStub struct {
impl ServiceBServerMethods
ServiceAServerStub
gs *rpc.GlobState
}
func (s implServiceBServerStub) MethodB1(ctx *context.T, call rpc.ServerCall, i0 Scalars, i1 Composites) (CompComp, error) {
return s.impl.MethodB1(ctx, call, i0, i1)
}
func (s implServiceBServerStub) Globber() *rpc.GlobState {
return s.gs
}
func (s implServiceBServerStub) Describe__() []rpc.InterfaceDesc {
return []rpc.InterfaceDesc{ServiceBDesc, ServiceADesc}
}
// ServiceBDesc describes the ServiceB interface.
var ServiceBDesc rpc.InterfaceDesc = descServiceB
// descServiceB hides the desc to keep godoc clean.
var descServiceB = rpc.InterfaceDesc{
Name: "ServiceB",
PkgPath: "v.io/x/ref/lib/vdl/testdata/base",
Embeds: []rpc.EmbedDesc{
{"ServiceA", "v.io/x/ref/lib/vdl/testdata/base", ``},
},
Methods: []rpc.MethodDesc{
{
Name: "MethodB1",
InArgs: []rpc.ArgDesc{
{"a", ``}, // Scalars
{"b", ``}, // Composites
},
OutArgs: []rpc.ArgDesc{
{"c", ``}, // CompComp
},
},
},
}
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{}{}
}
// Register types.
vdl.Register((*NamedBool)(nil))
vdl.Register((*NamedByte)(nil))
vdl.Register((*NamedUint16)(nil))
vdl.Register((*NamedUint32)(nil))
vdl.Register((*NamedUint64)(nil))
vdl.Register((*NamedInt8)(nil))
vdl.Register((*NamedInt16)(nil))
vdl.Register((*NamedInt32)(nil))
vdl.Register((*NamedInt64)(nil))
vdl.Register((*NamedFloat32)(nil))
vdl.Register((*NamedFloat64)(nil))
vdl.Register((*NamedComplex64)(nil))
vdl.Register((*NamedComplex128)(nil))
vdl.Register((*NamedString)(nil))
vdl.Register((*NamedEnum)(nil))
vdl.Register((*NamedArray)(nil))
vdl.Register((*NamedList)(nil))
vdl.Register((*NamedSet)(nil))
vdl.Register((*NamedMap)(nil))
vdl.Register((*NamedStruct)(nil))
vdl.Register((*NamedUnion)(nil))
vdl.Register((*Scalars)(nil))
vdl.Register((*KeyScalars)(nil))
vdl.Register((*ScalarsArray)(nil))
vdl.Register((*Composites)(nil))
vdl.Register((*CompositesArray)(nil))
vdl.Register((*CompComp)(nil))
vdl.Register((*Args)(nil))
vdl.Register((*NestedArgs)(nil))
// Set error format strings.
i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrNoParams1.ID), "{1:}{2:} en msg")
i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrNoParams2.ID), "{1:}{2:} en msg")
i18n.Cat().SetWithBase(i18n.LangID("fr"), i18n.MsgID(ErrNoParams2.ID), "{1:}{2:} fr msg")
i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrWithParams1.ID), "{1:}{2:} en x={3} y={4}")
i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrWithParams2.ID), "{1:}{2:} en x={3} y={4}")
i18n.Cat().SetWithBase(i18n.LangID("fr"), i18n.MsgID(ErrWithParams2.ID), "{1:}{2:} fr y={4} x={3}")
i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(errNotExported.ID), "{1:}{2:} en x={3} y={4}")
return struct{}{}
}