services/profile/profile.vdl.go - release.go.x.ref - Git at Google

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

 // Package profile defines types for the implementation of Vanadium profiles.
 package profile

 import (
 	"fmt"
 	"v.io/v23/services/build"
 	"v.io/v23/vdl"
 )

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

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

 // Library describes a shared library that applications may use.
 type Library struct {
 	// Name is the name of the library.
 	Name string
 	// MajorVersion is the major version of the library.
 	MajorVersion string
 	// MinorVersion is the minor version of the library.
 	MinorVersion string
 }

 func (Library) __VDLReflect(struct {
 	Name string `vdl:"v.io/x/ref/services/profile.Library"`
 }) {
 }

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

 	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
 			return err
 		}
 	}
 	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("MajorVersion")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		if err := fieldTarget5.FromString(string(m.MajorVersion), tt.NonOptional().Field(1).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
 			return err
 		}
 	}
 	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("MinorVersion")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		if err := fieldTarget7.FromString(string(m.MinorVersion), 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 *Library) MakeVDLTarget() vdl.Target {
 	return &LibraryTarget{Value: m}
 }

 type LibraryTarget struct {
 	Value              *Library
 	nameTarget         vdl.StringTarget
 	majorVersionTarget vdl.StringTarget
 	minorVersionTarget vdl.StringTarget
 	vdl.TargetBase
 	vdl.FieldsTargetBase
 }

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

 	if ttWant := vdl.TypeOf((*Library)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
 		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
 	}
 	return t, nil
 }
 func (t *LibraryTarget) StartField(name string) (key, field vdl.Target, _ error) {
 	switch name {
 	case "Name":
 		t.nameTarget.Value = &t.Value.Name
 		target, err := &t.nameTarget, error(nil)
 		return nil, target, err
 	case "MajorVersion":
 		t.majorVersionTarget.Value = &t.Value.MajorVersion
 		target, err := &t.majorVersionTarget, error(nil)
 		return nil, target, err
 	case "MinorVersion":
 		t.minorVersionTarget.Value = &t.Value.MinorVersion
 		target, err := &t.minorVersionTarget, error(nil)
 		return nil, target, err
 	default:
 		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/profile.Library", name)
 	}
 }
 func (t *LibraryTarget) FinishField(_, _ vdl.Target) error {
 	return nil
 }
 func (t *LibraryTarget) FinishFields(_ vdl.FieldsTarget) error {

 	return nil
 }

 // Specification is how we represent a profile internally. It should
 // provide enough information to allow matching of binaries to devices.
 type Specification struct {
 	// Label is a human-friendly concise label for the profile,
 	// e.g. "linux-media".
 	Label string
 	// Description is a human-friendly description of the profile.
 	Description string
 	// Arch is the target hardware architecture of the profile.
 	Arch build.Architecture
 	// Os is the target operating system of the profile.
 	Os build.OperatingSystem
 	// Format is the file format supported by the profile.
 	Format build.Format
 	// Libraries is a set of libraries the profile requires.
 	Libraries map[Library]struct{}
 }

 func (Specification) __VDLReflect(struct {
 	Name string `vdl:"v.io/x/ref/services/profile.Specification"`
 }) {
 }

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

 	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Label")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		if err := fieldTarget3.FromString(string(m.Label), tt.NonOptional().Field(0).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
 			return err
 		}
 	}
 	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Description")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		if err := fieldTarget5.FromString(string(m.Description), tt.NonOptional().Field(1).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
 			return err
 		}
 	}
 	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Arch")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {

 		if err := m.Arch.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(2).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
 			return err
 		}
 	}
 	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Os")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {

 		if err := m.Os.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(3).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
 			return err
 		}
 	}
 	keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("Format")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {

 		if err := m.Format.FillVDLTarget(fieldTarget11, tt.NonOptional().Field(4).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
 			return err
 		}
 	}
 	keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("Libraries")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {

 		setTarget14, err := fieldTarget13.StartSet(tt.NonOptional().Field(5).Type, len(m.Libraries))
 		if err != nil {
 			return err
 		}
 		for key16 := range m.Libraries {
 			keyTarget15, err := setTarget14.StartKey()
 			if err != nil {
 				return err
 			}

 			if err := key16.FillVDLTarget(keyTarget15, tt.NonOptional().Field(5).Type.Key()); err != nil {
 				return err
 			}
 			if err := setTarget14.FinishKey(keyTarget15); err != nil {
 				return err
 			}
 		}
 		if err := fieldTarget13.FinishSet(setTarget14); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
 			return err
 		}
 	}
 	if err := t.FinishFields(fieldsTarget1); err != nil {
 		return err
 	}
 	return nil
 }

 func (m *Specification) MakeVDLTarget() vdl.Target {
 	return &SpecificationTarget{Value: m}
 }

 type SpecificationTarget struct {
 	Value             *Specification
 	labelTarget       vdl.StringTarget
 	descriptionTarget vdl.StringTarget
 	archTarget        build.ArchitectureTarget
 	osTarget          build.OperatingSystemTarget
 	formatTarget      build.FormatTarget
 	librariesTarget   __VDLTarget1_set
 	vdl.TargetBase
 	vdl.FieldsTargetBase
 }

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

 	if ttWant := vdl.TypeOf((*Specification)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
 		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
 	}
 	return t, nil
 }
 func (t *SpecificationTarget) StartField(name string) (key, field vdl.Target, _ error) {
 	switch name {
 	case "Label":
 		t.labelTarget.Value = &t.Value.Label
 		target, err := &t.labelTarget, error(nil)
 		return nil, target, err
 	case "Description":
 		t.descriptionTarget.Value = &t.Value.Description
 		target, err := &t.descriptionTarget, error(nil)
 		return nil, target, err
 	case "Arch":
 		t.archTarget.Value = &t.Value.Arch
 		target, err := &t.archTarget, error(nil)
 		return nil, target, err
 	case "Os":
 		t.osTarget.Value = &t.Value.Os
 		target, err := &t.osTarget, error(nil)
 		return nil, target, err
 	case "Format":
 		t.formatTarget.Value = &t.Value.Format
 		target, err := &t.formatTarget, error(nil)
 		return nil, target, err
 	case "Libraries":
 		t.librariesTarget.Value = &t.Value.Libraries
 		target, err := &t.librariesTarget, error(nil)
 		return nil, target, err
 	default:
 		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/profile.Specification", name)
 	}
 }
 func (t *SpecificationTarget) FinishField(_, _ vdl.Target) error {
 	return nil
 }
 func (t *SpecificationTarget) FinishFields(_ vdl.FieldsTarget) error {

 	return nil
 }

 // map[Library]struct{}
 type __VDLTarget1_set struct {
 	Value     *map[Library]struct{}
 	currKey   Library
 	keyTarget LibraryTarget
 	vdl.TargetBase
 	vdl.SetTargetBase
 }

 func (t *__VDLTarget1_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

 	if ttWant := vdl.TypeOf((*map[Library]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
 		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
 	}
 	*t.Value = make(map[Library]struct{})
 	return t, nil
 }
 func (t *__VDLTarget1_set) StartKey() (key vdl.Target, _ error) {
 	t.currKey = Library{}
 	t.keyTarget.Value = &t.currKey
 	target, err := &t.keyTarget, error(nil)
 	return target, err
 }
 func (t *__VDLTarget1_set) FinishKey(key vdl.Target) error {
 	(*t.Value)[t.currKey] = struct{}{}
 	return nil
 }
 func (t *__VDLTarget1_set) FinishSet(list vdl.SetTarget) error {
 	if len(*t.Value) == 0 {
 		*t.Value = nil
 	}

 	return nil
 }

 // Create zero values for each type.
 var (
 	__VDLZeroLibrary       = Library{}
 	__VDLZeroSpecification = Specification{}
 )

 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((*Library)(nil))
 	vdl.Register((*Specification)(nil))

 	return struct{}{}
 }
	// 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: profile

	// Package profile defines types for the implementation of Vanadium profiles.
	package profile

	import (
	"fmt"
	"v.io/v23/services/build"
	"v.io/v23/vdl"
	)

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

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

	// Library describes a shared library that applications may use.
	type Library struct {
	// Name is the name of the library.
	Name string
	// MajorVersion is the major version of the library.
	MajorVersion string
	// MinorVersion is the minor version of the library.
	MinorVersion string
	}

	func (Library) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/services/profile.Library"`
	}) {
	}

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

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
	return err
	}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("MajorVersion")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	if err := fieldTarget5.FromString(string(m.MajorVersion), tt.NonOptional().Field(1).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
	return err
	}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("MinorVersion")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	if err := fieldTarget7.FromString(string(m.MinorVersion), 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 *Library) MakeVDLTarget() vdl.Target {
	return &LibraryTarget{Value: m}
	}

	type LibraryTarget struct {
	Value *Library
	nameTarget vdl.StringTarget
	majorVersionTarget vdl.StringTarget
	minorVersionTarget vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
	}

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

	if ttWant := vdl.TypeOf((*Library)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
	return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
	}
	func (t *LibraryTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
	t.nameTarget.Value = &t.Value.Name
	target, err := &t.nameTarget, error(nil)
	return nil, target, err
	case "MajorVersion":
	t.majorVersionTarget.Value = &t.Value.MajorVersion
	target, err := &t.majorVersionTarget, error(nil)
	return nil, target, err
	case "MinorVersion":
	t.minorVersionTarget.Value = &t.Value.MinorVersion
	target, err := &t.minorVersionTarget, error(nil)
	return nil, target, err
	default:
	return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/profile.Library", name)
	}
	}
	func (t *LibraryTarget) FinishField(_, _ vdl.Target) error {
	return nil
	}
	func (t *LibraryTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
	}

	// Specification is how we represent a profile internally. It should
	// provide enough information to allow matching of binaries to devices.
	type Specification struct {
	// Label is a human-friendly concise label for the profile,
	// e.g. "linux-media".
	Label string
	// Description is a human-friendly description of the profile.
	Description string
	// Arch is the target hardware architecture of the profile.
	Arch build.Architecture
	// Os is the target operating system of the profile.
	Os build.OperatingSystem
	// Format is the file format supported by the profile.
	Format build.Format
	// Libraries is a set of libraries the profile requires.
	Libraries map[Library]struct{}
	}

	func (Specification) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/services/profile.Specification"`
	}) {
	}

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

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Label")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	if err := fieldTarget3.FromString(string(m.Label), tt.NonOptional().Field(0).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
	return err
	}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Description")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	if err := fieldTarget5.FromString(string(m.Description), tt.NonOptional().Field(1).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
	return err
	}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Arch")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {

	if err := m.Arch.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(2).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
	return err
	}
	}
	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Os")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {

	if err := m.Os.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(3).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
	return err
	}
	}
	keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("Format")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {

	if err := m.Format.FillVDLTarget(fieldTarget11, tt.NonOptional().Field(4).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
	return err
	}
	}
	keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("Libraries")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {

	setTarget14, err := fieldTarget13.StartSet(tt.NonOptional().Field(5).Type, len(m.Libraries))
	if err != nil {
	return err
	}
	for key16 := range m.Libraries {
	keyTarget15, err := setTarget14.StartKey()
	if err != nil {
	return err
	}

	if err := key16.FillVDLTarget(keyTarget15, tt.NonOptional().Field(5).Type.Key()); err != nil {
	return err
	}
	if err := setTarget14.FinishKey(keyTarget15); err != nil {
	return err
	}
	}
	if err := fieldTarget13.FinishSet(setTarget14); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
	return err
	}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
	return err
	}
	return nil
	}

	func (m *Specification) MakeVDLTarget() vdl.Target {
	return &SpecificationTarget{Value: m}
	}

	type SpecificationTarget struct {
	Value *Specification
	labelTarget vdl.StringTarget
	descriptionTarget vdl.StringTarget
	archTarget build.ArchitectureTarget
	osTarget build.OperatingSystemTarget
	formatTarget build.FormatTarget
	librariesTarget __VDLTarget1_set
	vdl.TargetBase
	vdl.FieldsTargetBase
	}

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

	if ttWant := vdl.TypeOf((*Specification)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
	return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
	}
	func (t *SpecificationTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Label":
	t.labelTarget.Value = &t.Value.Label
	target, err := &t.labelTarget, error(nil)
	return nil, target, err
	case "Description":
	t.descriptionTarget.Value = &t.Value.Description
	target, err := &t.descriptionTarget, error(nil)
	return nil, target, err
	case "Arch":
	t.archTarget.Value = &t.Value.Arch
	target, err := &t.archTarget, error(nil)
	return nil, target, err
	case "Os":
	t.osTarget.Value = &t.Value.Os
	target, err := &t.osTarget, error(nil)
	return nil, target, err
	case "Format":
	t.formatTarget.Value = &t.Value.Format
	target, err := &t.formatTarget, error(nil)
	return nil, target, err
	case "Libraries":
	t.librariesTarget.Value = &t.Value.Libraries
	target, err := &t.librariesTarget, error(nil)
	return nil, target, err
	default:
	return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/profile.Specification", name)
	}
	}
	func (t *SpecificationTarget) FinishField(_, _ vdl.Target) error {
	return nil
	}
	func (t *SpecificationTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
	}

	// map[Library]struct{}
	type __VDLTarget1_set struct {
	Value *map[Library]struct{}
	currKey Library
	keyTarget LibraryTarget
	vdl.TargetBase
	vdl.SetTargetBase
	}

	func (t __VDLTarget1_set) StartSet(tt vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*map[Library]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
	return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[Library]struct{})
	return t, nil
	}
	func (t *__VDLTarget1_set) StartKey() (key vdl.Target, _ error) {
	t.currKey = Library{}
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
	}
	func (t *__VDLTarget1_set) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
	}
	func (t *__VDLTarget1_set) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
	*t.Value = nil
	}

	return nil
	}

	// Create zero values for each type.
	var (
	__VDLZeroLibrary = Library{}
	__VDLZeroSpecification = Specification{}
	)

	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((*Library)(nil))
	vdl.Register((*Specification)(nil))

	return struct{}{}
	}