vdlroot/vdltool/vdltool.vdl.go

// 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: vdltool

// Package vdltool defines types used by the vdl tool itself, including the
// format of vdl.config files.
package vdltool

import (
	"fmt"
	"reflect"
	"v.io/v23/vdl"
)

var _ = __VDLInit() // Must be first; see __VDLInit comments for details.

//////////////////////////////////////////////////
// Type definitions

// GenLanguage enumerates the known code generation languages.
type GenLanguage int

const (
	GenLanguageGo GenLanguage = iota
	GenLanguageJava
	GenLanguageJavascript
	GenLanguageSwift
)

// GenLanguageAll holds all labels for GenLanguage.
var GenLanguageAll = [...]GenLanguage{GenLanguageGo, GenLanguageJava, GenLanguageJavascript, GenLanguageSwift}

// GenLanguageFromString creates a GenLanguage from a string label.
func GenLanguageFromString(label string) (x GenLanguage, err error) {
	err = x.Set(label)
	return
}

// Set assigns label to x.
func (x *GenLanguage) Set(label string) error {
	switch label {
	case "Go", "go":
		*x = GenLanguageGo
		return nil
	case "Java", "java":
		*x = GenLanguageJava
		return nil
	case "Javascript", "javascript":
		*x = GenLanguageJavascript
		return nil
	case "Swift", "swift":
		*x = GenLanguageSwift
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in vdltool.GenLanguage", label)
}

// String returns the string label of x.
func (x GenLanguage) String() string {
	switch x {
	case GenLanguageGo:
		return "Go"
	case GenLanguageJava:
		return "Java"
	case GenLanguageJavascript:
		return "Javascript"
	case GenLanguageSwift:
		return "Swift"
	}
	return ""
}

func (GenLanguage) __VDLReflect(struct {
	Name string `vdl:"vdltool.GenLanguage"`
	Enum struct{ Go, Java, Javascript, Swift string }
}) {
}

func (m *GenLanguage) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromEnumLabel((*m).String(), tt); err != nil {
		return err
	}
	return nil
}

func (m *GenLanguage) MakeVDLTarget() vdl.Target {
	return nil
}

type GenLanguageTarget struct {
	Value *GenLanguage
	vdl.TargetBase
}

func (t *GenLanguageTarget) FromEnumLabel(src string, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*GenLanguage)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	switch src {
	case "Go":
		*t.Value = 0
	case "Java":
		*t.Value = 1
	case "Javascript":
		*t.Value = 2
	case "Swift":
		*t.Value = 3
	default:
		return fmt.Errorf("label %s not in enum GenLanguage", src)
	}

	return nil
}

func (x *GenLanguage) VDLRead(dec vdl.Decoder) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	enum, err := dec.DecodeString()
	if err != nil {
		return err
	}
	if err = x.Set(enum); err != nil {
		return err
	}
	return dec.FinishValue()
}

func (x GenLanguage) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*GenLanguage)(nil))); err != nil {
		return err
	}
	if err := enc.EncodeString(x.String()); err != nil {
		return err
	}
	return enc.FinishValue()
}

// GoImport describes Go import information.
type GoImport struct {
	// Path is the package path that uniquely identifies the imported package.
	Path string
	// Name is the name of the package identified by Path.  Due to Go conventions,
	// it is typically just the basename of Path, but may be set to something
	// different if the imported package doesn't follow Go conventions.
	Name string
}

func (GoImport) __VDLReflect(struct {
	Name string `vdl:"vdltool.GoImport"`
}) {
}

func (m *GoImport) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Path == "")
	if var4 {
		if err := fieldsTarget1.ZeroField("Path"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Path")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromString(string(m.Path), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.Name == "")
	if var7 {
		if err := fieldsTarget1.ZeroField("Name"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Name")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget6.FromString(string(m.Name), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *GoImport) MakeVDLTarget() vdl.Target {
	return nil
}

type GoImportTarget struct {
	Value *GoImport

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *GoImportTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*GoImport)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *GoImportTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Path":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Path))
		return nil, target, err
	case "Name":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Name))
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct vdltool.GoImport", name)
	}
}
func (t *GoImportTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *GoImportTarget) ZeroField(name string) error {
	switch name {
	case "Path":
		t.Value.Path = ""
		return nil
	case "Name":
		t.Value.Name = ""
		return nil
	default:
		return fmt.Errorf("field %s not in struct vdltool.GoImport", name)
	}
}
func (t *GoImportTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *GoImport) VDLRead(dec vdl.Decoder) error {
	*x = GoImport{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Path":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.Path, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "Name":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.Name, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func (x GoImport) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*GoImport)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.Path == "")
	if !(var1) {
		if err := enc.NextField("Path"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Path); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var2 := (x.Name == "")
	if !(var2) {
		if err := enc.NextField("Name"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Name); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

// GoType describes the Go type information associated with a VDL type.
// See v.io/x/ref/lib/vdl/testdata/native for examples.
type GoType struct {
	// Type is the Go type to use in generated code, instead of the VDL type.  If
	// the Go type requires additional imports, specify the type using the
	// standard local package name here, and also specify the import package in
	// Imports.
	Type string
	// Imports are the Go imports to use in generated code, required by the Type.
	Imports []GoImport
}

func (GoType) __VDLReflect(struct {
	Name string `vdl:"vdltool.GoType"`
}) {
}

func (m *GoType) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Type == "")
	if var4 {
		if err := fieldsTarget1.ZeroField("Type"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Type")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromString(string(m.Type), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var var7 bool
	if len(m.Imports) == 0 {
		var7 = true
	}
	if var7 {
		if err := fieldsTarget1.ZeroField("Imports"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Imports")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			listTarget8, err := fieldTarget6.StartList(tt.NonOptional().Field(1).Type, len(m.Imports))
			if err != nil {
				return err
			}
			for i, elem10 := range m.Imports {
				elemTarget9, err := listTarget8.StartElem(i)
				if err != nil {
					return err
				}

				if err := elem10.FillVDLTarget(elemTarget9, tt.NonOptional().Field(1).Type.Elem()); err != nil {
					return err
				}
				if err := listTarget8.FinishElem(elemTarget9); err != nil {
					return err
				}
			}
			if err := fieldTarget6.FinishList(listTarget8); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *GoType) MakeVDLTarget() vdl.Target {
	return nil
}

type GoTypeTarget struct {
	Value *GoType

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *GoTypeTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*GoType)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *GoTypeTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Type":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Type))
		return nil, target, err
	case "Imports":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Imports))
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct vdltool.GoType", name)
	}
}
func (t *GoTypeTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *GoTypeTarget) ZeroField(name string) error {
	switch name {
	case "Type":
		t.Value.Type = ""
		return nil
	case "Imports":
		t.Value.Imports = []GoImport(nil)
		return nil
	default:
		return fmt.Errorf("field %s not in struct vdltool.GoType", name)
	}
}
func (t *GoTypeTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *GoType) VDLRead(dec vdl.Decoder) error {
	*x = GoType{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Type":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.Type, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "Imports":
			if err = __VDLRead1_list(dec, &x.Imports); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLRead1_list(dec vdl.Decoder, x *[]GoImport) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible list %T, from %v", *x, dec.Type())
	}
	switch len := dec.LenHint(); {
	case len > 0:
		*x = make([]GoImport, 0, len)
	default:
		*x = nil
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		}
		var elem GoImport
		if err = elem.VDLRead(dec); err != nil {
			return err
		}
		*x = append(*x, elem)
	}
}

func (x GoType) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*GoType)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.Type == "")
	if !(var1) {
		if err := enc.NextField("Type"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Type); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var var2 bool
	if len(x.Imports) == 0 {
		var2 = true
	}
	if !(var2) {
		if err := enc.NextField("Imports"); err != nil {
			return err
		}
		if err := __VDLWrite1_list(enc, &x.Imports); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite1_list(enc vdl.Encoder, x *[]GoImport) error {
	if err := enc.StartValue(vdl.TypeOf((*[]GoImport)(nil))); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(*x)); err != nil {
		return err
	}
	for i := 0; i < len(*x); i++ {
		if err := enc.NextEntry(false); err != nil {
			return err
		}
		if err := (*x)[i].VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

// GoConfig specifies go specific configuration.
type GoConfig struct {
	// WireToNativeTypes specifies the mapping from a VDL wire type to its Go
	// native type representation.  This is rarely used and easy to configure
	// incorrectly; usage is currently restricted to packages that are explicitly
	// whitelisted.
	//
	// WireToNativeTypes are meant for scenarios where there is an idiomatic Go
	// type used in your code, but you need a standard VDL representation for wire
	// compatibility.  E.g. the VDL time package defines Duration and Time for
	// wire compatibility, but we want the generated code to use the standard Go
	// time package.
	//
	// The key of the map is the name of the VDL type (aka WireType), which must
	// be defined in the vdl package associated with the vdl.config file.
	//
	// The code generator assumes the existence of a pair of conversion functions
	// converting between the wire and native types, and will automatically call
	// vdl.RegisterNative with these function names.
	//
	// Assuming the name of the WireType is Foo:
	//   func fooToNative(x Foo, n *Native) error
	//   func fooFromNative(x *Foo, n Native) error
	WireToNativeTypes map[string]GoType
}

func (GoConfig) __VDLReflect(struct {
	Name string `vdl:"vdltool.GoConfig"`
}) {
}

func (m *GoConfig) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var var4 bool
	if len(m.WireToNativeTypes) == 0 {
		var4 = true
	}
	if var4 {
		if err := fieldsTarget1.ZeroField("WireToNativeTypes"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("WireToNativeTypes")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget5, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.WireToNativeTypes))
			if err != nil {
				return err
			}
			for key7, value9 := range m.WireToNativeTypes {
				keyTarget6, err := mapTarget5.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget6.FromString(string(key7), tt.NonOptional().Field(0).Type.Key()); err != nil {
					return err
				}
				valueTarget8, err := mapTarget5.FinishKeyStartField(keyTarget6)
				if err != nil {
					return err
				}

				if err := value9.FillVDLTarget(valueTarget8, tt.NonOptional().Field(0).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget5.FinishField(keyTarget6, valueTarget8); err != nil {
					return err
				}
			}
			if err := fieldTarget3.FinishMap(mapTarget5); 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 *GoConfig) MakeVDLTarget() vdl.Target {
	return nil
}

type GoConfigTarget struct {
	Value *GoConfig

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *GoConfigTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*GoConfig)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *GoConfigTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "WireToNativeTypes":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.WireToNativeTypes))
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct vdltool.GoConfig", name)
	}
}
func (t *GoConfigTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *GoConfigTarget) ZeroField(name string) error {
	switch name {
	case "WireToNativeTypes":
		t.Value.WireToNativeTypes = map[string]GoType(nil)
		return nil
	default:
		return fmt.Errorf("field %s not in struct vdltool.GoConfig", name)
	}
}
func (t *GoConfigTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *GoConfig) VDLRead(dec vdl.Decoder) error {
	*x = GoConfig{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "WireToNativeTypes":
			if err = __VDLRead2_map(dec, &x.WireToNativeTypes); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLRead2_map(dec vdl.Decoder, x *map[string]GoType) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[string]GoType
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[string]GoType, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if key, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem GoType
		{
			if err = elem.VDLRead(dec); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[string]GoType)
		}
		tmpMap[key] = elem
	}
}

func (x GoConfig) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*GoConfig)(nil)).Elem()); err != nil {
		return err
	}
	var var1 bool
	if len(x.WireToNativeTypes) == 0 {
		var1 = true
	}
	if !(var1) {
		if err := enc.NextField("WireToNativeTypes"); err != nil {
			return err
		}
		if err := __VDLWrite2_map(enc, &x.WireToNativeTypes); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite2_map(enc vdl.Encoder, x *map[string]GoType) error {
	if err := enc.StartValue(vdl.TypeOf((*map[string]GoType)(nil))); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(*x)); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.NextEntry(false); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := elem.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

// JavaConfig specifies java specific configuration.
type JavaConfig struct {
	// WireToNativeTypes specifies the mapping from a VDL wire type to its Java
	// native type representation.  This is rarely used and easy to configure
	// incorrectly; usage is currently restricted to packages that are explicitly
	// whitelisted.
	//
	// WireToNativeTypes are meant for scenarios where there is an idiomatic Java
	// type used in your code, but you need a standard VDL representation for wire
	// compatibility.  E.g. the VDL time package defines Duration and Time for
	// wire compatibility, but we want the generated code to use the org.joda.time
	// package.
	//
	// The key of the map is the name of the VDL type (aka WireType), which must
	// be defined in the vdl package associated with the vdl.config file.
	//
	// The code generator assumes that the conversion functions will be registered
	// in java vdl package.
	WireToNativeTypes map[string]string
	// WireTypeRenames specifies the mapping from a VDL wire type name to its
	// Java native type name.
	//
	// WireTypeRenames are meant for scenarios where the VDL wire name
	// conflicts in some way with the Java native names, e.g., a VDL Integer
	// type could be named VInteger for clarity.
	//
	// When combined with WireToNativeTypes, this feature allows us to attach
	// functions to VDL types.  For example, we may rename AccessList VDL type
	// into WireAccessList and then map WireAccessList to our Java native type
	// AccessList which defines functions on the VDL data.
	//
	// The key of the map is the name of the VDL wire type, which must be
	// defined in the vdl package associated with the vdl.config file.
	WireTypeRenames map[string]string
}

func (JavaConfig) __VDLReflect(struct {
	Name string `vdl:"vdltool.JavaConfig"`
}) {
}

func (m *JavaConfig) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var var4 bool
	if len(m.WireToNativeTypes) == 0 {
		var4 = true
	}
	if var4 {
		if err := fieldsTarget1.ZeroField("WireToNativeTypes"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("WireToNativeTypes")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget5, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.WireToNativeTypes))
			if err != nil {
				return err
			}
			for key7, value9 := range m.WireToNativeTypes {
				keyTarget6, err := mapTarget5.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget6.FromString(string(key7), tt.NonOptional().Field(0).Type.Key()); err != nil {
					return err
				}
				valueTarget8, err := mapTarget5.FinishKeyStartField(keyTarget6)
				if err != nil {
					return err
				}
				if err := valueTarget8.FromString(string(value9), tt.NonOptional().Field(0).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget5.FinishField(keyTarget6, valueTarget8); err != nil {
					return err
				}
			}
			if err := fieldTarget3.FinishMap(mapTarget5); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var var12 bool
	if len(m.WireTypeRenames) == 0 {
		var12 = true
	}
	if var12 {
		if err := fieldsTarget1.ZeroField("WireTypeRenames"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("WireTypeRenames")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget13, err := fieldTarget11.StartMap(tt.NonOptional().Field(1).Type, len(m.WireTypeRenames))
			if err != nil {
				return err
			}
			for key15, value17 := range m.WireTypeRenames {
				keyTarget14, err := mapTarget13.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget14.FromString(string(key15), tt.NonOptional().Field(1).Type.Key()); err != nil {
					return err
				}
				valueTarget16, err := mapTarget13.FinishKeyStartField(keyTarget14)
				if err != nil {
					return err
				}
				if err := valueTarget16.FromString(string(value17), tt.NonOptional().Field(1).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget13.FinishField(keyTarget14, valueTarget16); err != nil {
					return err
				}
			}
			if err := fieldTarget11.FinishMap(mapTarget13); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *JavaConfig) MakeVDLTarget() vdl.Target {
	return nil
}

type JavaConfigTarget struct {
	Value *JavaConfig

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *JavaConfigTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*JavaConfig)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *JavaConfigTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "WireToNativeTypes":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.WireToNativeTypes))
		return nil, target, err
	case "WireTypeRenames":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.WireTypeRenames))
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct vdltool.JavaConfig", name)
	}
}
func (t *JavaConfigTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *JavaConfigTarget) ZeroField(name string) error {
	switch name {
	case "WireToNativeTypes":
		t.Value.WireToNativeTypes = map[string]string(nil)
		return nil
	case "WireTypeRenames":
		t.Value.WireTypeRenames = map[string]string(nil)
		return nil
	default:
		return fmt.Errorf("field %s not in struct vdltool.JavaConfig", name)
	}
}
func (t *JavaConfigTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *JavaConfig) VDLRead(dec vdl.Decoder) error {
	*x = JavaConfig{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "WireToNativeTypes":
			if err = __VDLRead3_map(dec, &x.WireToNativeTypes); err != nil {
				return err
			}
		case "WireTypeRenames":
			if err = __VDLRead3_map(dec, &x.WireTypeRenames); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLRead3_map(dec vdl.Decoder, x *map[string]string) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[string]string
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[string]string, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if key, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if elem, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[string]string)
		}
		tmpMap[key] = elem
	}
}

func (x JavaConfig) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*JavaConfig)(nil)).Elem()); err != nil {
		return err
	}
	var var1 bool
	if len(x.WireToNativeTypes) == 0 {
		var1 = true
	}
	if !(var1) {
		if err := enc.NextField("WireToNativeTypes"); err != nil {
			return err
		}
		if err := __VDLWrite3_map(enc, &x.WireToNativeTypes); err != nil {
			return err
		}
	}
	var var2 bool
	if len(x.WireTypeRenames) == 0 {
		var2 = true
	}
	if !(var2) {
		if err := enc.NextField("WireTypeRenames"); err != nil {
			return err
		}
		if err := __VDLWrite3_map(enc, &x.WireTypeRenames); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite3_map(enc vdl.Encoder, x *map[string]string) error {
	if err := enc.StartValue(vdl.TypeOf((*map[string]string)(nil))); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(*x)); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.NextEntry(false); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(elem); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

// JavascriptConfig specifies javascript specific configuration.
type JavascriptConfig struct {
}

func (JavascriptConfig) __VDLReflect(struct {
	Name string `vdl:"vdltool.JavascriptConfig"`
}) {
}

func (m *JavascriptConfig) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *JavascriptConfig) MakeVDLTarget() vdl.Target {
	return nil
}

type JavascriptConfigTarget struct {
	Value *JavascriptConfig
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *JavascriptConfigTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*JavascriptConfig)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *JavascriptConfigTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	default:
		return nil, nil, fmt.Errorf("field %s not in struct vdltool.JavascriptConfig", name)
	}
}
func (t *JavascriptConfigTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *JavascriptConfigTarget) ZeroField(name string) error {
	switch name {
	default:
		return fmt.Errorf("field %s not in struct vdltool.JavascriptConfig", name)
	}
}
func (t *JavascriptConfigTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *JavascriptConfig) VDLRead(dec vdl.Decoder) error {
	*x = JavascriptConfig{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func (x JavascriptConfig) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*JavascriptConfig)(nil)).Elem()); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

// SwiftConfig specifies swift specific configuration for this package.
// Note that despite the SwiftConfig options for a given package (which should be
// very rare in practice), we still need to know the name of the swift module
// that this package relates to to properly understand import boundaries between
// projects/frameworks/modules.
//
// We do this by defining a file called "swiftmodule" that contains JUST the
// name of the Swift module at the root of your VDL packages. For example,
// if you have the VDL files for your Xcode project/target called UberForCats
// at /Users/aaron/uberforcats/vdl, then create
// /Users/aaron/uberforcats/vdl/com.uberforcats/swiftmodule and have it just contain
// "UberForCats". We then will treat any VDL files contained in that directory and
// any subdirectories as part of the UberForCats Swift module, ultimately letting
// the compiler and will automatically do the right thing if others import your package.
// If you don't do this then nobody will be able to import your VDL types in Swift,
// and you might end up with extra long class/pkg names (ComuberforcatsServicesProfit
// instead of ServicesProfit for $VDLROOT/com.uberforcats/services/profit).
//
// If you are creating multiple Swift modules for a given $VDLROOT then just place
// swiftmodule files at the logical boundaries. For eample, we do this for v.io/v23
// to be exported to the VanadiumCore framework, but everything under v.io/v23/services
// lives in the VanadiumServices framework.
type SwiftConfig struct {
	// WireToNativeTypes specifies the mapping from a VDL wire type to its Swift
	// native type representation.  This is rarely used and easy to configure
	// incorrectly; usage is currently restricted to packages that are explicitly
	// whitelisted.
	//
	// WireToNativeTypes are meant for scenarios where there is an idiomatic Swift
	// type used in your code, but you need a standard VDL representation for wire
	// compatibility.  E.g. the VDL time package defines Duration and Time for
	// wire compatibility, but we want the generated code to use NSDate or NSTimeInterval
	//
	// The key of the map is the name of the VDL type (aka WireType), which must
	// be defined in the vdl package associated with the vdl.config file.
	//
	// The code generator assumes that the conversion functions will be registered
	// in Swift vdl package.
	WireToNativeTypes map[string]string
}

func (SwiftConfig) __VDLReflect(struct {
	Name string `vdl:"vdltool.SwiftConfig"`
}) {
}

func (m *SwiftConfig) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var var4 bool
	if len(m.WireToNativeTypes) == 0 {
		var4 = true
	}
	if var4 {
		if err := fieldsTarget1.ZeroField("WireToNativeTypes"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("WireToNativeTypes")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget5, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.WireToNativeTypes))
			if err != nil {
				return err
			}
			for key7, value9 := range m.WireToNativeTypes {
				keyTarget6, err := mapTarget5.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget6.FromString(string(key7), tt.NonOptional().Field(0).Type.Key()); err != nil {
					return err
				}
				valueTarget8, err := mapTarget5.FinishKeyStartField(keyTarget6)
				if err != nil {
					return err
				}
				if err := valueTarget8.FromString(string(value9), tt.NonOptional().Field(0).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget5.FinishField(keyTarget6, valueTarget8); err != nil {
					return err
				}
			}
			if err := fieldTarget3.FinishMap(mapTarget5); 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 *SwiftConfig) MakeVDLTarget() vdl.Target {
	return nil
}

type SwiftConfigTarget struct {
	Value *SwiftConfig

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *SwiftConfigTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*SwiftConfig)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *SwiftConfigTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "WireToNativeTypes":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.WireToNativeTypes))
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct vdltool.SwiftConfig", name)
	}
}
func (t *SwiftConfigTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *SwiftConfigTarget) ZeroField(name string) error {
	switch name {
	case "WireToNativeTypes":
		t.Value.WireToNativeTypes = map[string]string(nil)
		return nil
	default:
		return fmt.Errorf("field %s not in struct vdltool.SwiftConfig", name)
	}
}
func (t *SwiftConfigTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *SwiftConfig) VDLRead(dec vdl.Decoder) error {
	*x = SwiftConfig{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "WireToNativeTypes":
			if err = __VDLRead3_map(dec, &x.WireToNativeTypes); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func (x SwiftConfig) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*SwiftConfig)(nil)).Elem()); err != nil {
		return err
	}
	var var1 bool
	if len(x.WireToNativeTypes) == 0 {
		var1 = true
	}
	if !(var1) {
		if err := enc.NextField("WireToNativeTypes"); err != nil {
			return err
		}
		if err := __VDLWrite3_map(enc, &x.WireToNativeTypes); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

// Config specifies the configuration for the vdl tool.  This is typically
// represented in optional "vdl.config" files in each vdl source package.  Each
// vdl.config file implicitly imports this package.  E.g. you may refer to
// vdltool.Config in the "vdl.config" file without explicitly importing vdltool.
type Config struct {
	// GenLanguages restricts the set of code generation languages.  If the set is
	// empty, all supported languages are allowed to be generated.
	GenLanguages map[GenLanguage]struct{}
	// Language-specific configurations.
	Go         GoConfig
	Java       JavaConfig
	Javascript JavascriptConfig
	Swift      SwiftConfig
}

func (Config) __VDLReflect(struct {
	Name string `vdl:"vdltool.Config"`
}) {
}

func (m *Config) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var var4 bool
	if len(m.GenLanguages) == 0 {
		var4 = true
	}
	if var4 {
		if err := fieldsTarget1.ZeroField("GenLanguages"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("GenLanguages")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			setTarget5, err := fieldTarget3.StartSet(tt.NonOptional().Field(0).Type, len(m.GenLanguages))
			if err != nil {
				return err
			}
			for key7 := range m.GenLanguages {
				keyTarget6, err := setTarget5.StartKey()
				if err != nil {
					return err
				}

				if err := key7.FillVDLTarget(keyTarget6, tt.NonOptional().Field(0).Type.Key()); err != nil {
					return err
				}
				if err := setTarget5.FinishKey(keyTarget6); err != nil {
					return err
				}
			}
			if err := fieldTarget3.FinishSet(setTarget5); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var10 := true
	var var11 bool
	if len(m.Go.WireToNativeTypes) == 0 {
		var11 = true
	}
	var10 = var10 && var11
	if var10 {
		if err := fieldsTarget1.ZeroField("Go"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Go")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.Go.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
				return err
			}
		}
	}
	var14 := true
	var var15 bool
	if len(m.Java.WireToNativeTypes) == 0 {
		var15 = true
	}
	var14 = var14 && var15
	var var16 bool
	if len(m.Java.WireTypeRenames) == 0 {
		var16 = true
	}
	var14 = var14 && var16
	if var14 {
		if err := fieldsTarget1.ZeroField("Java"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("Java")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.Java.FillVDLTarget(fieldTarget13, tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
				return err
			}
		}
	}
	var19 := (m.Javascript == JavascriptConfig{})
	if var19 {
		if err := fieldsTarget1.ZeroField("Javascript"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget17, fieldTarget18, err := fieldsTarget1.StartField("Javascript")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.Javascript.FillVDLTarget(fieldTarget18, tt.NonOptional().Field(3).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget17, fieldTarget18); err != nil {
				return err
			}
		}
	}
	var22 := true
	var var23 bool
	if len(m.Swift.WireToNativeTypes) == 0 {
		var23 = true
	}
	var22 = var22 && var23
	if var22 {
		if err := fieldsTarget1.ZeroField("Swift"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("Swift")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.Swift.FillVDLTarget(fieldTarget21, tt.NonOptional().Field(4).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Config) MakeVDLTarget() vdl.Target {
	return nil
}

type ConfigTarget struct {
	Value *Config

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *ConfigTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*Config)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *ConfigTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "GenLanguages":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.GenLanguages))
		return nil, target, err
	case "Go":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Go))
		return nil, target, err
	case "Java":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Java))
		return nil, target, err
	case "Javascript":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Javascript))
		return nil, target, err
	case "Swift":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Swift))
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct vdltool.Config", name)
	}
}
func (t *ConfigTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *ConfigTarget) ZeroField(name string) error {
	switch name {
	case "GenLanguages":
		t.Value.GenLanguages = map[GenLanguage]struct{}(nil)
		return nil
	case "Go":
		t.Value.Go = GoConfig{}
		return nil
	case "Java":
		t.Value.Java = JavaConfig{}
		return nil
	case "Javascript":
		t.Value.Javascript = JavascriptConfig{}
		return nil
	case "Swift":
		t.Value.Swift = SwiftConfig{}
		return nil
	default:
		return fmt.Errorf("field %s not in struct vdltool.Config", name)
	}
}
func (t *ConfigTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *Config) VDLRead(dec vdl.Decoder) error {
	*x = Config{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "GenLanguages":
			if err = __VDLRead4_set(dec, &x.GenLanguages); err != nil {
				return err
			}
		case "Go":
			if err = x.Go.VDLRead(dec); err != nil {
				return err
			}
		case "Java":
			if err = x.Java.VDLRead(dec); err != nil {
				return err
			}
		case "Javascript":
			if err = x.Javascript.VDLRead(dec); err != nil {
				return err
			}
		case "Swift":
			if err = x.Swift.VDLRead(dec); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLRead4_set(dec vdl.Decoder, x *map[GenLanguage]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible set %T, from %v", *x, dec.Type())
	}
	var tmpMap map[GenLanguage]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[GenLanguage]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key GenLanguage
		{
			if err = key.VDLRead(dec); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[GenLanguage]struct{})
		}
		tmpMap[key] = struct{}{}
	}
}

func (x Config) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*Config)(nil)).Elem()); err != nil {
		return err
	}
	var var1 bool
	if len(x.GenLanguages) == 0 {
		var1 = true
	}
	if !(var1) {
		if err := enc.NextField("GenLanguages"); err != nil {
			return err
		}
		if err := __VDLWrite4_set(enc, &x.GenLanguages); err != nil {
			return err
		}
	}
	var2 := true
	var var3 bool
	if len(x.Go.WireToNativeTypes) == 0 {
		var3 = true
	}
	var2 = var2 && var3
	if !(var2) {
		if err := enc.NextField("Go"); err != nil {
			return err
		}
		if err := x.Go.VDLWrite(enc); err != nil {
			return err
		}
	}
	var4 := true
	var var5 bool
	if len(x.Java.WireToNativeTypes) == 0 {
		var5 = true
	}
	var4 = var4 && var5
	var var6 bool
	if len(x.Java.WireTypeRenames) == 0 {
		var6 = true
	}
	var4 = var4 && var6
	if !(var4) {
		if err := enc.NextField("Java"); err != nil {
			return err
		}
		if err := x.Java.VDLWrite(enc); err != nil {
			return err
		}
	}
	var7 := (x.Javascript == JavascriptConfig{})
	if !(var7) {
		if err := enc.NextField("Javascript"); err != nil {
			return err
		}
		if err := x.Javascript.VDLWrite(enc); err != nil {
			return err
		}
	}
	var8 := true
	var var9 bool
	if len(x.Swift.WireToNativeTypes) == 0 {
		var9 = true
	}
	var8 = var8 && var9
	if !(var8) {
		if err := enc.NextField("Swift"); err != nil {
			return err
		}
		if err := x.Swift.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite4_set(enc vdl.Encoder, x *map[GenLanguage]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*map[GenLanguage]struct{})(nil))); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(*x)); err != nil {
		return err
	}
	for key := range *x {
		if err := enc.NextEntry(false); err != nil {
			return err
		}
		if err := key.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

var __VDLInitCalled bool

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

	// Register types.
	vdl.Register((*GenLanguage)(nil))
	vdl.Register((*GoImport)(nil))
	vdl.Register((*GoType)(nil))
	vdl.Register((*GoConfig)(nil))
	vdl.Register((*JavaConfig)(nil))
	vdl.Register((*JavascriptConfig)(nil))
	vdl.Register((*SwiftConfig)(nil))
	vdl.Register((*Config)(nil))

	return struct{}{}
}