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

package naming

import (
	"fmt"
	"v.io/v23/vdl"
	"v.io/v23/vdl/vdlconv"
	vdltime "v.io/v23/vdlroot/time"
	"v.io/v23/verror"
)

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

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

// MountFlag is a bit mask of options to the mount call.
type MountFlag uint32

func (MountFlag) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/naming.MountFlag"`
}) {
}

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

func (m *MountFlag) MakeVDLTarget() vdl.Target {
	return &MountFlagTarget{Value: m}
}

type MountFlagTarget struct {
	Value *MountFlag
	vdl.TargetBase
}

func (t *MountFlagTarget) FromUint(src uint64, tt *vdl.Type) error {

	val, err := vdlconv.Uint64ToUint32(src)
	if err != nil {
		return err
	}
	*t.Value = MountFlag(val)

	return nil
}
func (t *MountFlagTarget) FromInt(src int64, tt *vdl.Type) error {

	val, err := vdlconv.Int64ToUint32(src)
	if err != nil {
		return err
	}
	*t.Value = MountFlag(val)

	return nil
}
func (t *MountFlagTarget) FromFloat(src float64, tt *vdl.Type) error {

	val, err := vdlconv.Float64ToUint32(src)
	if err != nil {
		return err
	}
	*t.Value = MountFlag(val)

	return nil
}

func (x MountFlag) VDLIsZero() bool {
	return x == 0
}

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

func (x *MountFlag) VDLRead(dec vdl.Decoder) error {
	if err := dec.StartValue(); err != nil {
		return err
	}
	tmp, err := dec.DecodeUint(32)
	if err != nil {
		return err
	}
	*x = MountFlag(tmp)
	return dec.FinishValue()
}

// MountedServer represents a server mounted on a specific name.
type MountedServer struct {
	// Server is the OA that's mounted.
	Server string
	// Deadline before the mount entry expires.
	Deadline vdltime.Deadline
}

func (MountedServer) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/naming.MountedServer"`
}) {
}

func (m *MountedServer) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Server == "")
	if var4 {
		if err := fieldsTarget1.ZeroField("Server"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Server")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromString(string(m.Server), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var wireValue5 vdltime.WireDeadline
	if err := vdltime.WireDeadlineFromNative(&wireValue5, m.Deadline); err != nil {
		return err
	}

	var8 := (wireValue5 == vdltime.WireDeadline{})
	if var8 {
		if err := fieldsTarget1.ZeroField("Deadline"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Deadline")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := wireValue5.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(1).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 *MountedServer) MakeVDLTarget() vdl.Target {
	return &MountedServerTarget{Value: m}
}

type MountedServerTarget struct {
	Value          *MountedServer
	serverTarget   vdl.StringTarget
	deadlineTarget vdltime.WireDeadlineTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	if ttWant := vdl.TypeOf((*MountedServer)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *MountedServerTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Server":
		t.serverTarget.Value = &t.Value.Server
		target, err := &t.serverTarget, error(nil)
		return nil, target, err
	case "Deadline":
		t.deadlineTarget.Value = &t.Value.Deadline
		target, err := &t.deadlineTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, vdl.ErrFieldNoExist
	}
}
func (t *MountedServerTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *MountedServerTarget) ZeroField(name string) error {
	switch name {
	case "Server":
		t.Value.Server = ""
		return nil
	case "Deadline":
		t.Value.Deadline = vdltime.Deadline{}
		return nil
	default:
		return vdl.ErrFieldNoExist
	}
}
func (t *MountedServerTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x MountedServer) VDLIsZero() bool {
	if x.Server != "" {
		return false
	}
	if !x.Deadline.Time.IsZero() {
		return false
	}
	return true
}

func (x MountedServer) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*MountedServer)(nil)).Elem()); err != nil {
		return err
	}
	if x.Server != "" {
		if err := enc.NextField("Server"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.StringType); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Server); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if !x.Deadline.Time.IsZero() {
		if err := enc.NextField("Deadline"); err != nil {
			return err
		}
		var wire vdltime.WireDeadline
		if err := vdltime.WireDeadlineFromNative(&wire, x.Deadline); err != nil {
			return err
		}
		if err := wire.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *MountedServer) VDLRead(dec vdl.Decoder) error {
	*x = MountedServer{}
	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 "Server":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.Server, err = dec.DecodeString(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "Deadline":
			var wire vdltime.WireDeadline
			if err := wire.VDLRead(dec); err != nil {
				return err
			}
			if err := vdltime.WireDeadlineToNative(wire, &x.Deadline); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

// MountEntry represents a given name mounted in the mounttable.
type MountEntry struct {
	// Name is the mounted name.
	Name string
	// Servers (if present) specifies the mounted names.
	Servers []MountedServer
	// ServesMountTable is true if the servers represent mount tables.
	ServesMountTable bool
	// IsLeaf is true if this entry represents a leaf object.
	IsLeaf bool
}

func (MountEntry) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/naming.MountEntry"`
}) {
}

func (m *MountEntry) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Name == "")
	if var4 {
		if err := fieldsTarget1.ZeroField("Name"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			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
			}
		}
	}
	var var7 bool
	if len(m.Servers) == 0 {
		var7 = true
	}
	if var7 {
		if err := fieldsTarget1.ZeroField("Servers"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Servers")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			listTarget8, err := fieldTarget6.StartList(tt.NonOptional().Field(1).Type, len(m.Servers))
			if err != nil {
				return err
			}
			for i, elem10 := range m.Servers {
				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
			}
		}
	}
	var13 := (m.ServesMountTable == false)
	if var13 {
		if err := fieldsTarget1.ZeroField("ServesMountTable"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("ServesMountTable")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget12.FromBool(bool(m.ServesMountTable), tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
				return err
			}
		}
	}
	var16 := (m.IsLeaf == false)
	if var16 {
		if err := fieldsTarget1.ZeroField("IsLeaf"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("IsLeaf")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget15.FromBool(bool(m.IsLeaf), tt.NonOptional().Field(3).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *MountEntry) MakeVDLTarget() vdl.Target {
	return &MountEntryTarget{Value: m}
}

type MountEntryTarget struct {
	Value                  *MountEntry
	nameTarget             vdl.StringTarget
	serversTarget          __VDLTarget1_list
	servesMountTableTarget vdl.BoolTarget
	isLeafTarget           vdl.BoolTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	if ttWant := vdl.TypeOf((*MountEntry)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *MountEntryTarget) 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 "Servers":
		t.serversTarget.Value = &t.Value.Servers
		target, err := &t.serversTarget, error(nil)
		return nil, target, err
	case "ServesMountTable":
		t.servesMountTableTarget.Value = &t.Value.ServesMountTable
		target, err := &t.servesMountTableTarget, error(nil)
		return nil, target, err
	case "IsLeaf":
		t.isLeafTarget.Value = &t.Value.IsLeaf
		target, err := &t.isLeafTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, vdl.ErrFieldNoExist
	}
}
func (t *MountEntryTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *MountEntryTarget) ZeroField(name string) error {
	switch name {
	case "Name":
		t.Value.Name = ""
		return nil
	case "Servers":
		t.Value.Servers = []MountedServer(nil)
		return nil
	case "ServesMountTable":
		t.Value.ServesMountTable = false
		return nil
	case "IsLeaf":
		t.Value.IsLeaf = false
		return nil
	default:
		return vdl.ErrFieldNoExist
	}
}
func (t *MountEntryTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// []MountedServer
type __VDLTarget1_list struct {
	Value      *[]MountedServer
	elemTarget MountedServerTarget
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *__VDLTarget1_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*[]MountedServer)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make([]MountedServer, 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
}

func (x MountEntry) VDLIsZero() bool {
	if x.Name != "" {
		return false
	}
	if len(x.Servers) != 0 {
		return false
	}
	if x.ServesMountTable {
		return false
	}
	if x.IsLeaf {
		return false
	}
	return true
}

func (x MountEntry) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*MountEntry)(nil)).Elem()); err != nil {
		return err
	}
	if x.Name != "" {
		if err := enc.NextField("Name"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.StringType); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Name); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if len(x.Servers) != 0 {
		if err := enc.NextField("Servers"); err != nil {
			return err
		}
		if err := __VDLWriteAnon_list_1(enc, x.Servers); err != nil {
			return err
		}
	}
	if x.ServesMountTable {
		if err := enc.NextField("ServesMountTable"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.BoolType); err != nil {
			return err
		}
		if err := enc.EncodeBool(x.ServesMountTable); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.IsLeaf {
		if err := enc.NextField("IsLeaf"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.BoolType); err != nil {
			return err
		}
		if err := enc.EncodeBool(x.IsLeaf); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWriteAnon_list_1(enc vdl.Encoder, x []MountedServer) error {
	if err := enc.StartValue(vdl.TypeOf((*[]MountedServer)(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()
}

func (x *MountEntry) VDLRead(dec vdl.Decoder) error {
	*x = MountEntry{}
	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 "Name":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.Name, err = dec.DecodeString(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "Servers":
			if err := __VDLReadAnon_list_1(dec, &x.Servers); err != nil {
				return err
			}
		case "ServesMountTable":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.ServesMountTable, err = dec.DecodeBool(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "IsLeaf":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.IsLeaf, err = dec.DecodeBool(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLReadAnon_list_1(dec vdl.Decoder, x *[]MountedServer) 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([]MountedServer, 0, len)
	default:
		*x = nil
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		}
		var elem MountedServer
		if err := elem.VDLRead(dec); err != nil {
			return err
		}
		*x = append(*x, elem)
	}
}

// GlobError is returned by namespace.Glob to indicate a subtree of the namespace
// that could not be traversed.
type GlobError struct {
	// Root of the subtree.
	Name string
	// The error that occurred fulfilling the request.
	Error error
}

func (GlobError) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/naming.GlobError"`
}) {
}

func (m *GlobError) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Name == "")
	if var4 {
		if err := fieldsTarget1.ZeroField("Name"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			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
			}
		}
	}
	var7 := (m.Error == (error)(nil))
	if var7 {
		if err := fieldsTarget1.ZeroField("Error"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Error")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			var wireError8 vdl.WireError
			if err := verror.WireFromNative(&wireError8, m.Error); err != nil {
				return err
			}
			if err := wireError8.FillVDLTarget(fieldTarget6, vdl.ErrorType); 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 *GlobError) MakeVDLTarget() vdl.Target {
	return &GlobErrorTarget{Value: m}
}

type GlobErrorTarget struct {
	Value       *GlobError
	nameTarget  vdl.StringTarget
	errorTarget verror.ErrorTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	if ttWant := vdl.TypeOf((*GlobError)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *GlobErrorTarget) 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 "Error":
		t.errorTarget.Value = &t.Value.Error
		target, err := &t.errorTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, vdl.ErrFieldNoExist
	}
}
func (t *GlobErrorTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *GlobErrorTarget) ZeroField(name string) error {
	switch name {
	case "Name":
		t.Value.Name = ""
		return nil
	case "Error":
		t.Value.Error = (error)(nil)
		return nil
	default:
		return vdl.ErrFieldNoExist
	}
}
func (t *GlobErrorTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x GlobError) VDLIsZero() bool {
	return x == GlobError{}
}

func (x GlobError) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*GlobError)(nil)).Elem()); err != nil {
		return err
	}
	if x.Name != "" {
		if err := enc.NextField("Name"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.StringType); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Name); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.Error != nil {
		if err := enc.NextField("Error"); err != nil {
			return err
		}
		if err := verror.VDLWrite(enc, x.Error); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *GlobError) VDLRead(dec vdl.Decoder) error {
	*x = GlobError{}
	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 "Name":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.Name, err = dec.DecodeString(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "Error":
			if err := verror.VDLRead(dec, &x.Error); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

type (
	// GlobReply represents any single field of the GlobReply union type.
	//
	// GlobReply is the data type returned by Glob__.
	GlobReply 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 GlobReply union type.
		__VDLReflect(__GlobReplyReflect)
		FillVDLTarget(vdl.Target, *vdl.Type) error
		VDLIsZero() bool
		VDLWrite(vdl.Encoder) error
	}
	// GlobReplyEntry represents field Entry of the GlobReply union type.
	GlobReplyEntry struct{ Value MountEntry }
	// GlobReplyError represents field Error of the GlobReply union type.
	GlobReplyError struct{ Value GlobError }
	// __GlobReplyReflect describes the GlobReply union type.
	__GlobReplyReflect struct {
		Name               string `vdl:"v.io/v23/naming.GlobReply"`
		Type               GlobReply
		UnionTargetFactory globReplyTargetFactory
		Union              struct {
			Entry GlobReplyEntry
			Error GlobReplyError
		}
	}
)

func (x GlobReplyEntry) Index() int                      { return 0 }
func (x GlobReplyEntry) Interface() interface{}          { return x.Value }
func (x GlobReplyEntry) Name() string                    { return "Entry" }
func (x GlobReplyEntry) __VDLReflect(__GlobReplyReflect) {}

func (m GlobReplyEntry) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Entry")
	if err != nil {
		return err
	}

	if err := m.Value.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 GlobReplyEntry) MakeVDLTarget() vdl.Target {
	return nil
}

func (x GlobReplyError) Index() int                      { return 1 }
func (x GlobReplyError) Interface() interface{}          { return x.Value }
func (x GlobReplyError) Name() string                    { return "Error" }
func (x GlobReplyError) __VDLReflect(__GlobReplyReflect) {}

func (m GlobReplyError) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Error")
	if err != nil {
		return err
	}

	if err := m.Value.FillVDLTarget(fieldTarget3, 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 GlobReplyError) MakeVDLTarget() vdl.Target {
	return nil
}

type GlobReplyTarget struct {
	Value     *GlobReply
	fieldName string

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *GlobReplyTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if ttWant := vdl.TypeOf((*GlobReply)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}

	return t, nil
}
func (t *GlobReplyTarget) StartField(name string) (key, field vdl.Target, _ error) {
	t.fieldName = name
	switch name {
	case "Entry":
		val := MountEntry{}
		return nil, &MountEntryTarget{Value: &val}, nil
	case "Error":
		val := GlobError{}
		return nil, &GlobErrorTarget{Value: &val}, nil
	default:
		return nil, nil, fmt.Errorf("field %s not in union v.io/v23/naming.GlobReply", name)
	}
}
func (t *GlobReplyTarget) FinishField(_, fieldTarget vdl.Target) error {
	switch t.fieldName {
	case "Entry":
		*t.Value = GlobReplyEntry{*(fieldTarget.(*MountEntryTarget)).Value}
	case "Error":
		*t.Value = GlobReplyError{*(fieldTarget.(*GlobErrorTarget)).Value}
	}
	return nil
}
func (t *GlobReplyTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type globReplyTargetFactory struct{}

func (t globReplyTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) {
	if typedUnion, ok := union.(*GlobReply); ok {
		return &GlobReplyTarget{Value: typedUnion}, nil
	}
	return nil, fmt.Errorf("got %T, want *GlobReply", union)
}

func (x GlobReplyEntry) VDLIsZero() bool {
	return x.Value.VDLIsZero()
}

func (x GlobReplyError) VDLIsZero() bool {
	return false
}

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

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

func VDLReadGlobReply(dec vdl.Decoder, x *GlobReply) error {
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(x), dec.Type()) {
		return fmt.Errorf("incompatible union %T, from %v", x, dec.Type())
	}
	f, err := dec.NextField()
	if err != nil {
		return err
	}
	switch f {
	case "Entry":
		var field GlobReplyEntry
		if err := field.Value.VDLRead(dec); err != nil {
			return err
		}
		*x = field
	case "Error":
		var field GlobReplyError
		if err := field.Value.VDLRead(dec); err != nil {
			return err
		}
		*x = field
	case "":
		return fmt.Errorf("missing field in union %T, from %v", x, dec.Type())
	default:
		return fmt.Errorf("field %q not in union %T, from %v", f, x, dec.Type())
	}
	switch f, err := dec.NextField(); {
	case err != nil:
		return err
	case f != "":
		return fmt.Errorf("extra field %q in union %T, from %v", f, x, dec.Type())
	}
	return dec.FinishValue()
}

type (
	// GlobChildrenReply represents any single field of the GlobChildrenReply union type.
	//
	// GlobChildrenReply is the data type returned by GlobChildren__.
	GlobChildrenReply 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 GlobChildrenReply union type.
		__VDLReflect(__GlobChildrenReplyReflect)
		FillVDLTarget(vdl.Target, *vdl.Type) error
		VDLIsZero() bool
		VDLWrite(vdl.Encoder) error
	}
	// GlobChildrenReplyName represents field Name of the GlobChildrenReply union type.
	GlobChildrenReplyName struct{ Value string }
	// GlobChildrenReplyError represents field Error of the GlobChildrenReply union type.
	GlobChildrenReplyError struct{ Value GlobError }
	// __GlobChildrenReplyReflect describes the GlobChildrenReply union type.
	__GlobChildrenReplyReflect struct {
		Name               string `vdl:"v.io/v23/naming.GlobChildrenReply"`
		Type               GlobChildrenReply
		UnionTargetFactory globChildrenReplyTargetFactory
		Union              struct {
			Name  GlobChildrenReplyName
			Error GlobChildrenReplyError
		}
	}
)

func (x GlobChildrenReplyName) Index() int                              { return 0 }
func (x GlobChildrenReplyName) Interface() interface{}                  { return x.Value }
func (x GlobChildrenReplyName) Name() string                            { return "Name" }
func (x GlobChildrenReplyName) __VDLReflect(__GlobChildrenReplyReflect) {}

func (m GlobChildrenReplyName) 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 != nil {
		return err
	}
	if err := fieldTarget3.FromString(string(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 GlobChildrenReplyName) MakeVDLTarget() vdl.Target {
	return nil
}

func (x GlobChildrenReplyError) Index() int                              { return 1 }
func (x GlobChildrenReplyError) Interface() interface{}                  { return x.Value }
func (x GlobChildrenReplyError) Name() string                            { return "Error" }
func (x GlobChildrenReplyError) __VDLReflect(__GlobChildrenReplyReflect) {}

func (m GlobChildrenReplyError) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Error")
	if err != nil {
		return err
	}

	if err := m.Value.FillVDLTarget(fieldTarget3, 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 GlobChildrenReplyError) MakeVDLTarget() vdl.Target {
	return nil
}

type GlobChildrenReplyTarget struct {
	Value     *GlobChildrenReply
	fieldName string

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *GlobChildrenReplyTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if ttWant := vdl.TypeOf((*GlobChildrenReply)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}

	return t, nil
}
func (t *GlobChildrenReplyTarget) StartField(name string) (key, field vdl.Target, _ error) {
	t.fieldName = name
	switch name {
	case "Name":
		val := ""
		return nil, &vdl.StringTarget{Value: &val}, nil
	case "Error":
		val := GlobError{}
		return nil, &GlobErrorTarget{Value: &val}, nil
	default:
		return nil, nil, fmt.Errorf("field %s not in union v.io/v23/naming.GlobChildrenReply", name)
	}
}
func (t *GlobChildrenReplyTarget) FinishField(_, fieldTarget vdl.Target) error {
	switch t.fieldName {
	case "Name":
		*t.Value = GlobChildrenReplyName{*(fieldTarget.(*vdl.StringTarget)).Value}
	case "Error":
		*t.Value = GlobChildrenReplyError{*(fieldTarget.(*GlobErrorTarget)).Value}
	}
	return nil
}
func (t *GlobChildrenReplyTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type globChildrenReplyTargetFactory struct{}

func (t globChildrenReplyTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) {
	if typedUnion, ok := union.(*GlobChildrenReply); ok {
		return &GlobChildrenReplyTarget{Value: typedUnion}, nil
	}
	return nil, fmt.Errorf("got %T, want *GlobChildrenReply", union)
}

func (x GlobChildrenReplyName) VDLIsZero() bool {
	return x.Value == ""
}

func (x GlobChildrenReplyError) VDLIsZero() bool {
	return false
}

func (x GlobChildrenReplyName) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*GlobChildrenReply)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("Name"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.StringType); err != nil {
		return err
	}
	if err := enc.EncodeString(x.Value); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

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

func VDLReadGlobChildrenReply(dec vdl.Decoder, x *GlobChildrenReply) error {
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(x), dec.Type()) {
		return fmt.Errorf("incompatible union %T, from %v", x, dec.Type())
	}
	f, err := dec.NextField()
	if err != nil {
		return err
	}
	switch f {
	case "Name":
		var field GlobChildrenReplyName
		if err := dec.StartValue(); err != nil {
			return err
		}
		var err error
		if field.Value, err = dec.DecodeString(); err != nil {
			return err
		}
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "Error":
		var field GlobChildrenReplyError
		if err := field.Value.VDLRead(dec); err != nil {
			return err
		}
		*x = field
	case "":
		return fmt.Errorf("missing field in union %T, from %v", x, dec.Type())
	default:
		return fmt.Errorf("field %q not in union %T, from %v", f, x, dec.Type())
	}
	switch f, err := dec.NextField(); {
	case err != nil:
		return err
	case f != "":
		return fmt.Errorf("extra field %q in union %T, from %v", f, x, dec.Type())
	}
	return dec.FinishValue()
}

//////////////////////////////////////////////////
// Const definitions

const Replace = MountFlag(1) // Replace means the mount should replace what is currently at the mount point
const MT = MountFlag(2)      // MT means that the target server is a mount table.
const Leaf = MountFlag(4)    // Leaf means that the target server is a leaf.

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((*MountFlag)(nil))
	vdl.Register((*MountedServer)(nil))
	vdl.Register((*MountEntry)(nil))
	vdl.Register((*GlobError)(nil))
	vdl.Register((*GlobReply)(nil))
	vdl.Register((*GlobChildrenReply)(nil))

	return struct{}{}
}