vtrace/vtrace.vdl.go - release.go.v23 - 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: vtrace

 package vtrace

 import (
 	"time"
 	"v.io/v23/uniqueid"
 	"v.io/v23/vdl"
 	vdltime "v.io/v23/vdlroot/time"
 )

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

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

 // An Annotation represents data that is relevant at a specific moment.
 // They can be attached to spans to add useful debugging information.
 type Annotation struct {
 	// When the annotation was added.
 	When time.Time
 	// The annotation message.
 	// TODO(mattr): Allow richer annotations.
 	Message string
 }

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

 func (x Annotation) VDLIsZero() bool {
 	if !x.When.IsZero() {
 		return false
 	}
 	if x.Message != "" {
 		return false
 	}
 	return true
 }

 func (x Annotation) VDLWrite(enc vdl.Encoder) error {
 	if err := enc.StartValue(__VDLType_struct_1); err != nil {
 		return err
 	}
 	if !x.When.IsZero() {
 		if err := enc.NextField(0); err != nil {
 			return err
 		}
 		var wire vdltime.Time
 		if err := vdltime.TimeFromNative(&wire, x.When); err != nil {
 			return err
 		}
 		if err := wire.VDLWrite(enc); err != nil {
 			return err
 		}
 	}
 	if x.Message != "" {
 		if err := enc.NextFieldValueString(1, vdl.StringType, x.Message); err != nil {
 			return err
 		}
 	}
 	if err := enc.NextField(-1); err != nil {
 		return err
 	}
 	return enc.FinishValue()
 }

 func (x *Annotation) VDLRead(dec vdl.Decoder) error {
 	*x = Annotation{}
 	if err := dec.StartValue(__VDLType_struct_1); err != nil {
 		return err
 	}
 	decType := dec.Type()
 	for {
 		index, err := dec.NextField()
 		switch {
 		case err != nil:
 			return err
 		case index == -1:
 			return dec.FinishValue()
 		}
 		if decType != __VDLType_struct_1 {
 			index = __VDLType_struct_1.FieldIndexByName(decType.Field(index).Name)
 			if index == -1 {
 				if err := dec.SkipValue(); err != nil {
 					return err
 				}
 				continue
 			}
 		}
 		switch index {
 		case 0:
 			var wire vdltime.Time
 			if err := wire.VDLRead(dec); err != nil {
 				return err
 			}
 			if err := vdltime.TimeToNative(wire, &x.When); err != nil {
 				return err
 			}
 		case 1:
 			switch value, err := dec.ReadValueString(); {
 			case err != nil:
 				return err
 			default:
 				x.Message = value
 			}
 		}
 	}
 }

 // A SpanRecord is the wire format for a Span.
 type SpanRecord struct {
 	Id     uniqueid.Id // The Id of the Span.
 	Parent uniqueid.Id // The Id of this Span's parent.
 	Name   string      // The Name of this span.
 	Start  time.Time   // The start time of this span.
 	End    time.Time   // The end time of this span.
 	// A series of annotations.
 	Annotations []Annotation
 }

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

 func (x SpanRecord) VDLIsZero() bool {
 	if x.Id != (uniqueid.Id{}) {
 		return false
 	}
 	if x.Parent != (uniqueid.Id{}) {
 		return false
 	}
 	if x.Name != "" {
 		return false
 	}
 	if !x.Start.IsZero() {
 		return false
 	}
 	if !x.End.IsZero() {
 		return false
 	}
 	if len(x.Annotations) != 0 {
 		return false
 	}
 	return true
 }

 func (x SpanRecord) VDLWrite(enc vdl.Encoder) error {
 	if err := enc.StartValue(__VDLType_struct_3); err != nil {
 		return err
 	}
 	if x.Id != (uniqueid.Id{}) {
 		if err := enc.NextFieldValueBytes(0, __VDLType_array_4, x.Id[:]); err != nil {
 			return err
 		}
 	}
 	if x.Parent != (uniqueid.Id{}) {
 		if err := enc.NextFieldValueBytes(1, __VDLType_array_4, x.Parent[:]); err != nil {
 			return err
 		}
 	}
 	if x.Name != "" {
 		if err := enc.NextFieldValueString(2, vdl.StringType, x.Name); err != nil {
 			return err
 		}
 	}
 	if !x.Start.IsZero() {
 		if err := enc.NextField(3); err != nil {
 			return err
 		}
 		var wire vdltime.Time
 		if err := vdltime.TimeFromNative(&wire, x.Start); err != nil {
 			return err
 		}
 		if err := wire.VDLWrite(enc); err != nil {
 			return err
 		}
 	}
 	if !x.End.IsZero() {
 		if err := enc.NextField(4); err != nil {
 			return err
 		}
 		var wire vdltime.Time
 		if err := vdltime.TimeFromNative(&wire, x.End); err != nil {
 			return err
 		}
 		if err := wire.VDLWrite(enc); err != nil {
 			return err
 		}
 	}
 	if len(x.Annotations) != 0 {
 		if err := enc.NextField(5); err != nil {
 			return err
 		}
 		if err := __VDLWriteAnon_list_1(enc, x.Annotations); err != nil {
 			return err
 		}
 	}
 	if err := enc.NextField(-1); err != nil {
 		return err
 	}
 	return enc.FinishValue()
 }

 func __VDLWriteAnon_list_1(enc vdl.Encoder, x []Annotation) error {
 	if err := enc.StartValue(__VDLType_list_5); err != nil {
 		return err
 	}
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
 	for _, elem := range x {
 		if err := enc.NextEntry(false); 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()
 }

 func (x *SpanRecord) VDLRead(dec vdl.Decoder) error {
 	*x = SpanRecord{}
 	if err := dec.StartValue(__VDLType_struct_3); err != nil {
 		return err
 	}
 	decType := dec.Type()
 	for {
 		index, err := dec.NextField()
 		switch {
 		case err != nil:
 			return err
 		case index == -1:
 			return dec.FinishValue()
 		}
 		if decType != __VDLType_struct_3 {
 			index = __VDLType_struct_3.FieldIndexByName(decType.Field(index).Name)
 			if index == -1 {
 				if err := dec.SkipValue(); err != nil {
 					return err
 				}
 				continue
 			}
 		}
 		switch index {
 		case 0:
 			bytes := x.Id[:]
 			if err := dec.ReadValueBytes(16, &bytes); err != nil {
 				return err
 			}
 		case 1:
 			bytes := x.Parent[:]
 			if err := dec.ReadValueBytes(16, &bytes); err != nil {
 				return err
 			}
 		case 2:
 			switch value, err := dec.ReadValueString(); {
 			case err != nil:
 				return err
 			default:
 				x.Name = value
 			}
 		case 3:
 			var wire vdltime.Time
 			if err := wire.VDLRead(dec); err != nil {
 				return err
 			}
 			if err := vdltime.TimeToNative(wire, &x.Start); err != nil {
 				return err
 			}
 		case 4:
 			var wire vdltime.Time
 			if err := wire.VDLRead(dec); err != nil {
 				return err
 			}
 			if err := vdltime.TimeToNative(wire, &x.End); err != nil {
 				return err
 			}
 		case 5:
 			if err := __VDLReadAnon_list_1(dec, &x.Annotations); err != nil {
 				return err
 			}
 		}
 	}
 }

 func __VDLReadAnon_list_1(dec vdl.Decoder, x *[]Annotation) error {
 	if err := dec.StartValue(__VDLType_list_5); err != nil {
 		return err
 	}
 	if len := dec.LenHint(); len > 0 {
 		*x = make([]Annotation, 0, len)
 	} else {
 		*x = nil
 	}
 	for {
 		switch done, err := dec.NextEntry(); {
 		case err != nil:
 			return err
 		case done:
 			return dec.FinishValue()
 		default:
 			var elem Annotation
 			if err := elem.VDLRead(dec); err != nil {
 				return err
 			}
 			*x = append(*x, elem)
 		}
 	}
 }

 type TraceRecord struct {
 	Id    uniqueid.Id
 	Spans []SpanRecord
 }

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

 func (x TraceRecord) VDLIsZero() bool {
 	if x.Id != (uniqueid.Id{}) {
 		return false
 	}
 	if len(x.Spans) != 0 {
 		return false
 	}
 	return true
 }

 func (x TraceRecord) VDLWrite(enc vdl.Encoder) error {
 	if err := enc.StartValue(__VDLType_struct_6); err != nil {
 		return err
 	}
 	if x.Id != (uniqueid.Id{}) {
 		if err := enc.NextFieldValueBytes(0, __VDLType_array_4, x.Id[:]); err != nil {
 			return err
 		}
 	}
 	if len(x.Spans) != 0 {
 		if err := enc.NextField(1); err != nil {
 			return err
 		}
 		if err := __VDLWriteAnon_list_2(enc, x.Spans); err != nil {
 			return err
 		}
 	}
 	if err := enc.NextField(-1); err != nil {
 		return err
 	}
 	return enc.FinishValue()
 }

 func __VDLWriteAnon_list_2(enc vdl.Encoder, x []SpanRecord) error {
 	if err := enc.StartValue(__VDLType_list_7); err != nil {
 		return err
 	}
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
 	for _, elem := range x {
 		if err := enc.NextEntry(false); 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()
 }

 func (x *TraceRecord) VDLRead(dec vdl.Decoder) error {
 	*x = TraceRecord{}
 	if err := dec.StartValue(__VDLType_struct_6); err != nil {
 		return err
 	}
 	decType := dec.Type()
 	for {
 		index, err := dec.NextField()
 		switch {
 		case err != nil:
 			return err
 		case index == -1:
 			return dec.FinishValue()
 		}
 		if decType != __VDLType_struct_6 {
 			index = __VDLType_struct_6.FieldIndexByName(decType.Field(index).Name)
 			if index == -1 {
 				if err := dec.SkipValue(); err != nil {
 					return err
 				}
 				continue
 			}
 		}
 		switch index {
 		case 0:
 			bytes := x.Id[:]
 			if err := dec.ReadValueBytes(16, &bytes); err != nil {
 				return err
 			}
 		case 1:
 			if err := __VDLReadAnon_list_2(dec, &x.Spans); err != nil {
 				return err
 			}
 		}
 	}
 }

 func __VDLReadAnon_list_2(dec vdl.Decoder, x *[]SpanRecord) error {
 	if err := dec.StartValue(__VDLType_list_7); err != nil {
 		return err
 	}
 	if len := dec.LenHint(); len > 0 {
 		*x = make([]SpanRecord, 0, len)
 	} else {
 		*x = nil
 	}
 	for {
 		switch done, err := dec.NextEntry(); {
 		case err != nil:
 			return err
 		case done:
 			return dec.FinishValue()
 		default:
 			var elem SpanRecord
 			if err := elem.VDLRead(dec); err != nil {
 				return err
 			}
 			*x = append(*x, elem)
 		}
 	}
 }

 type TraceFlags int32

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

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

 func (x TraceFlags) VDLWrite(enc vdl.Encoder) error {
 	if err := enc.WriteValueInt(__VDLType_int32_8, int64(x)); err != nil {
 		return err
 	}
 	return nil
 }

 func (x *TraceFlags) VDLRead(dec vdl.Decoder) error {
 	switch value, err := dec.ReadValueInt(32); {
 	case err != nil:
 		return err
 	default:
 		*x = TraceFlags(value)
 	}
 	return nil
 }

 // Request is the object that carries trace informtion between processes.
 type Request struct {
 	SpanId   uniqueid.Id // The Id of the span that originated the RPC call.
 	TraceId  uniqueid.Id // The Id of the trace this call is a part of.
 	Flags    TraceFlags
 	LogLevel int32
 }

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

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

 func (x Request) VDLWrite(enc vdl.Encoder) error {
 	if err := enc.StartValue(__VDLType_struct_9); err != nil {
 		return err
 	}
 	if x.SpanId != (uniqueid.Id{}) {
 		if err := enc.NextFieldValueBytes(0, __VDLType_array_4, x.SpanId[:]); err != nil {
 			return err
 		}
 	}
 	if x.TraceId != (uniqueid.Id{}) {
 		if err := enc.NextFieldValueBytes(1, __VDLType_array_4, x.TraceId[:]); err != nil {
 			return err
 		}
 	}
 	if x.Flags != 0 {
 		if err := enc.NextFieldValueInt(2, __VDLType_int32_8, int64(x.Flags)); err != nil {
 			return err
 		}
 	}
 	if x.LogLevel != 0 {
 		if err := enc.NextFieldValueInt(3, vdl.Int32Type, int64(x.LogLevel)); err != nil {
 			return err
 		}
 	}
 	if err := enc.NextField(-1); err != nil {
 		return err
 	}
 	return enc.FinishValue()
 }

 func (x *Request) VDLRead(dec vdl.Decoder) error {
 	*x = Request{}
 	if err := dec.StartValue(__VDLType_struct_9); err != nil {
 		return err
 	}
 	decType := dec.Type()
 	for {
 		index, err := dec.NextField()
 		switch {
 		case err != nil:
 			return err
 		case index == -1:
 			return dec.FinishValue()
 		}
 		if decType != __VDLType_struct_9 {
 			index = __VDLType_struct_9.FieldIndexByName(decType.Field(index).Name)
 			if index == -1 {
 				if err := dec.SkipValue(); err != nil {
 					return err
 				}
 				continue
 			}
 		}
 		switch index {
 		case 0:
 			bytes := x.SpanId[:]
 			if err := dec.ReadValueBytes(16, &bytes); err != nil {
 				return err
 			}
 		case 1:
 			bytes := x.TraceId[:]
 			if err := dec.ReadValueBytes(16, &bytes); err != nil {
 				return err
 			}
 		case 2:
 			switch value, err := dec.ReadValueInt(32); {
 			case err != nil:
 				return err
 			default:
 				x.Flags = TraceFlags(value)
 			}
 		case 3:
 			switch value, err := dec.ReadValueInt(32); {
 			case err != nil:
 				return err
 			default:
 				x.LogLevel = int32(value)
 			}
 		}
 	}
 }

 type Response struct {
 	// Flags give options for trace collection, the client should alter its
 	// collection for this trace according to the flags sent back from the
 	// server.
 	Flags TraceFlags
 	// Trace is collected trace data.  This may be empty.
 	Trace TraceRecord
 }

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

 func (x Response) VDLIsZero() bool {
 	if x.Flags != 0 {
 		return false
 	}
 	if !x.Trace.VDLIsZero() {
 		return false
 	}
 	return true
 }

 func (x Response) VDLWrite(enc vdl.Encoder) error {
 	if err := enc.StartValue(__VDLType_struct_10); err != nil {
 		return err
 	}
 	if x.Flags != 0 {
 		if err := enc.NextFieldValueInt(0, __VDLType_int32_8, int64(x.Flags)); err != nil {
 			return err
 		}
 	}
 	if !x.Trace.VDLIsZero() {
 		if err := enc.NextField(1); err != nil {
 			return err
 		}
 		if err := x.Trace.VDLWrite(enc); err != nil {
 			return err
 		}
 	}
 	if err := enc.NextField(-1); err != nil {
 		return err
 	}
 	return enc.FinishValue()
 }

 func (x *Response) VDLRead(dec vdl.Decoder) error {
 	*x = Response{}
 	if err := dec.StartValue(__VDLType_struct_10); err != nil {
 		return err
 	}
 	decType := dec.Type()
 	for {
 		index, err := dec.NextField()
 		switch {
 		case err != nil:
 			return err
 		case index == -1:
 			return dec.FinishValue()
 		}
 		if decType != __VDLType_struct_10 {
 			index = __VDLType_struct_10.FieldIndexByName(decType.Field(index).Name)
 			if index == -1 {
 				if err := dec.SkipValue(); err != nil {
 					return err
 				}
 				continue
 			}
 		}
 		switch index {
 		case 0:
 			switch value, err := dec.ReadValueInt(32); {
 			case err != nil:
 				return err
 			default:
 				x.Flags = TraceFlags(value)
 			}
 		case 1:
 			if err := x.Trace.VDLRead(dec); err != nil {
 				return err
 			}
 		}
 	}
 }

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

 const Empty = TraceFlags(0)
 const CollectInMemory = TraceFlags(1)

 // Hold type definitions in package-level variables, for better performance.
 var (
 	__VDLType_struct_1  *vdl.Type
 	__VDLType_struct_2  *vdl.Type
 	__VDLType_struct_3  *vdl.Type
 	__VDLType_array_4   *vdl.Type
 	__VDLType_list_5    *vdl.Type
 	__VDLType_struct_6  *vdl.Type
 	__VDLType_list_7    *vdl.Type
 	__VDLType_int32_8   *vdl.Type
 	__VDLType_struct_9  *vdl.Type
 	__VDLType_struct_10 *vdl.Type
 )

 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((*Annotation)(nil))
 	vdl.Register((*SpanRecord)(nil))
 	vdl.Register((*TraceRecord)(nil))
 	vdl.Register((*TraceFlags)(nil))
 	vdl.Register((*Request)(nil))
 	vdl.Register((*Response)(nil))

 	// Initialize type definitions.
 	__VDLType_struct_1 = vdl.TypeOf((*Annotation)(nil)).Elem()
 	__VDLType_struct_2 = vdl.TypeOf((*vdltime.Time)(nil)).Elem()
 	__VDLType_struct_3 = vdl.TypeOf((*SpanRecord)(nil)).Elem()
 	__VDLType_array_4 = vdl.TypeOf((*uniqueid.Id)(nil))
 	__VDLType_list_5 = vdl.TypeOf((*[]Annotation)(nil))
 	__VDLType_struct_6 = vdl.TypeOf((*TraceRecord)(nil)).Elem()
 	__VDLType_list_7 = vdl.TypeOf((*[]SpanRecord)(nil))
 	__VDLType_int32_8 = vdl.TypeOf((*TraceFlags)(nil))
 	__VDLType_struct_9 = vdl.TypeOf((*Request)(nil)).Elem()
 	__VDLType_struct_10 = vdl.TypeOf((*Response)(nil)).Elem()

 	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: vtrace

	package vtrace

	import (
	"time"
	"v.io/v23/uniqueid"
	"v.io/v23/vdl"
	vdltime "v.io/v23/vdlroot/time"
	)

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

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

	// An Annotation represents data that is relevant at a specific moment.
	// They can be attached to spans to add useful debugging information.
	type Annotation struct {
	// When the annotation was added.
	When time.Time
	// The annotation message.
	// TODO(mattr): Allow richer annotations.
	Message string
	}

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

	func (x Annotation) VDLIsZero() bool {
	if !x.When.IsZero() {
	return false
	}
	if x.Message != "" {
	return false
	}
	return true
	}

	func (x Annotation) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_struct_1); err != nil {
	return err
	}
	if !x.When.IsZero() {
	if err := enc.NextField(0); err != nil {
	return err
	}
	var wire vdltime.Time
	if err := vdltime.TimeFromNative(&wire, x.When); err != nil {
	return err
	}
	if err := wire.VDLWrite(enc); err != nil {
	return err
	}
	}
	if x.Message != "" {
	if err := enc.NextFieldValueString(1, vdl.StringType, x.Message); err != nil {
	return err
	}
	}
	if err := enc.NextField(-1); err != nil {
	return err
	}
	return enc.FinishValue()
	}

	func (x *Annotation) VDLRead(dec vdl.Decoder) error {
	*x = Annotation{}
	if err := dec.StartValue(__VDLType_struct_1); err != nil {
	return err
	}
	decType := dec.Type()
	for {
	index, err := dec.NextField()
	switch {
	case err != nil:
	return err
	case index == -1:
	return dec.FinishValue()
	}
	if decType != __VDLType_struct_1 {
	index = __VDLType_struct_1.FieldIndexByName(decType.Field(index).Name)
	if index == -1 {
	if err := dec.SkipValue(); err != nil {
	return err
	}
	continue
	}
	}
	switch index {
	case 0:
	var wire vdltime.Time
	if err := wire.VDLRead(dec); err != nil {
	return err
	}
	if err := vdltime.TimeToNative(wire, &x.When); err != nil {
	return err
	}
	case 1:
	switch value, err := dec.ReadValueString(); {
	case err != nil:
	return err
	default:
	x.Message = value
	}
	}
	}
	}

	// A SpanRecord is the wire format for a Span.
	type SpanRecord struct {
	Id uniqueid.Id // The Id of the Span.
	Parent uniqueid.Id // The Id of this Span's parent.
	Name string // The Name of this span.
	Start time.Time // The start time of this span.
	End time.Time // The end time of this span.
	// A series of annotations.
	Annotations []Annotation
	}

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

	func (x SpanRecord) VDLIsZero() bool {
	if x.Id != (uniqueid.Id{}) {
	return false
	}
	if x.Parent != (uniqueid.Id{}) {
	return false
	}
	if x.Name != "" {
	return false
	}
	if !x.Start.IsZero() {
	return false
	}
	if !x.End.IsZero() {
	return false
	}
	if len(x.Annotations) != 0 {
	return false
	}
	return true
	}

	func (x SpanRecord) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_struct_3); err != nil {
	return err
	}
	if x.Id != (uniqueid.Id{}) {
	if err := enc.NextFieldValueBytes(0, __VDLType_array_4, x.Id[:]); err != nil {
	return err
	}
	}
	if x.Parent != (uniqueid.Id{}) {
	if err := enc.NextFieldValueBytes(1, __VDLType_array_4, x.Parent[:]); err != nil {
	return err
	}
	}
	if x.Name != "" {
	if err := enc.NextFieldValueString(2, vdl.StringType, x.Name); err != nil {
	return err
	}
	}
	if !x.Start.IsZero() {
	if err := enc.NextField(3); err != nil {
	return err
	}
	var wire vdltime.Time
	if err := vdltime.TimeFromNative(&wire, x.Start); err != nil {
	return err
	}
	if err := wire.VDLWrite(enc); err != nil {
	return err
	}
	}
	if !x.End.IsZero() {
	if err := enc.NextField(4); err != nil {
	return err
	}
	var wire vdltime.Time
	if err := vdltime.TimeFromNative(&wire, x.End); err != nil {
	return err
	}
	if err := wire.VDLWrite(enc); err != nil {
	return err
	}
	}
	if len(x.Annotations) != 0 {
	if err := enc.NextField(5); err != nil {
	return err
	}
	if err := __VDLWriteAnon_list_1(enc, x.Annotations); err != nil {
	return err
	}
	}
	if err := enc.NextField(-1); err != nil {
	return err
	}
	return enc.FinishValue()
	}

	func __VDLWriteAnon_list_1(enc vdl.Encoder, x []Annotation) error {
	if err := enc.StartValue(__VDLType_list_5); err != nil {
	return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
	return err
	}
	for _, elem := range x {
	if err := enc.NextEntry(false); 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()
	}

	func (x *SpanRecord) VDLRead(dec vdl.Decoder) error {
	*x = SpanRecord{}
	if err := dec.StartValue(__VDLType_struct_3); err != nil {
	return err
	}
	decType := dec.Type()
	for {
	index, err := dec.NextField()
	switch {
	case err != nil:
	return err
	case index == -1:
	return dec.FinishValue()
	}
	if decType != __VDLType_struct_3 {
	index = __VDLType_struct_3.FieldIndexByName(decType.Field(index).Name)
	if index == -1 {
	if err := dec.SkipValue(); err != nil {
	return err
	}
	continue
	}
	}
	switch index {
	case 0:
	bytes := x.Id[:]
	if err := dec.ReadValueBytes(16, &bytes); err != nil {
	return err
	}
	case 1:
	bytes := x.Parent[:]
	if err := dec.ReadValueBytes(16, &bytes); err != nil {
	return err
	}
	case 2:
	switch value, err := dec.ReadValueString(); {
	case err != nil:
	return err
	default:
	x.Name = value
	}
	case 3:
	var wire vdltime.Time
	if err := wire.VDLRead(dec); err != nil {
	return err
	}
	if err := vdltime.TimeToNative(wire, &x.Start); err != nil {
	return err
	}
	case 4:
	var wire vdltime.Time
	if err := wire.VDLRead(dec); err != nil {
	return err
	}
	if err := vdltime.TimeToNative(wire, &x.End); err != nil {
	return err
	}
	case 5:
	if err := __VDLReadAnon_list_1(dec, &x.Annotations); err != nil {
	return err
	}
	}
	}
	}

	func __VDLReadAnon_list_1(dec vdl.Decoder, x *[]Annotation) error {
	if err := dec.StartValue(__VDLType_list_5); err != nil {
	return err
	}
	if len := dec.LenHint(); len > 0 {
	*x = make([]Annotation, 0, len)
	} else {
	*x = nil
	}
	for {
	switch done, err := dec.NextEntry(); {
	case err != nil:
	return err
	case done:
	return dec.FinishValue()
	default:
	var elem Annotation
	if err := elem.VDLRead(dec); err != nil {
	return err
	}
	x = append(x, elem)
	}
	}
	}

	type TraceRecord struct {
	Id uniqueid.Id
	Spans []SpanRecord
	}

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

	func (x TraceRecord) VDLIsZero() bool {
	if x.Id != (uniqueid.Id{}) {
	return false
	}
	if len(x.Spans) != 0 {
	return false
	}
	return true
	}

	func (x TraceRecord) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_struct_6); err != nil {
	return err
	}
	if x.Id != (uniqueid.Id{}) {
	if err := enc.NextFieldValueBytes(0, __VDLType_array_4, x.Id[:]); err != nil {
	return err
	}
	}
	if len(x.Spans) != 0 {
	if err := enc.NextField(1); err != nil {
	return err
	}
	if err := __VDLWriteAnon_list_2(enc, x.Spans); err != nil {
	return err
	}
	}
	if err := enc.NextField(-1); err != nil {
	return err
	}
	return enc.FinishValue()
	}

	func __VDLWriteAnon_list_2(enc vdl.Encoder, x []SpanRecord) error {
	if err := enc.StartValue(__VDLType_list_7); err != nil {
	return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
	return err
	}
	for _, elem := range x {
	if err := enc.NextEntry(false); 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()
	}

	func (x *TraceRecord) VDLRead(dec vdl.Decoder) error {
	*x = TraceRecord{}
	if err := dec.StartValue(__VDLType_struct_6); err != nil {
	return err
	}
	decType := dec.Type()
	for {
	index, err := dec.NextField()
	switch {
	case err != nil:
	return err
	case index == -1:
	return dec.FinishValue()
	}
	if decType != __VDLType_struct_6 {
	index = __VDLType_struct_6.FieldIndexByName(decType.Field(index).Name)
	if index == -1 {
	if err := dec.SkipValue(); err != nil {
	return err
	}
	continue
	}
	}
	switch index {
	case 0:
	bytes := x.Id[:]
	if err := dec.ReadValueBytes(16, &bytes); err != nil {
	return err
	}
	case 1:
	if err := __VDLReadAnon_list_2(dec, &x.Spans); err != nil {
	return err
	}
	}
	}
	}

	func __VDLReadAnon_list_2(dec vdl.Decoder, x *[]SpanRecord) error {
	if err := dec.StartValue(__VDLType_list_7); err != nil {
	return err
	}
	if len := dec.LenHint(); len > 0 {
	*x = make([]SpanRecord, 0, len)
	} else {
	*x = nil
	}
	for {
	switch done, err := dec.NextEntry(); {
	case err != nil:
	return err
	case done:
	return dec.FinishValue()
	default:
	var elem SpanRecord
	if err := elem.VDLRead(dec); err != nil {
	return err
	}
	x = append(x, elem)
	}
	}
	}

	type TraceFlags int32

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

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

	func (x TraceFlags) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueInt(__VDLType_int32_8, int64(x)); err != nil {
	return err
	}
	return nil
	}

	func (x *TraceFlags) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueInt(32); {
	case err != nil:
	return err
	default:
	*x = TraceFlags(value)
	}
	return nil
	}

	// Request is the object that carries trace informtion between processes.
	type Request struct {
	SpanId uniqueid.Id // The Id of the span that originated the RPC call.
	TraceId uniqueid.Id // The Id of the trace this call is a part of.
	Flags TraceFlags
	LogLevel int32
	}

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

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

	func (x Request) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_struct_9); err != nil {
	return err
	}
	if x.SpanId != (uniqueid.Id{}) {
	if err := enc.NextFieldValueBytes(0, __VDLType_array_4, x.SpanId[:]); err != nil {
	return err
	}
	}
	if x.TraceId != (uniqueid.Id{}) {
	if err := enc.NextFieldValueBytes(1, __VDLType_array_4, x.TraceId[:]); err != nil {
	return err
	}
	}
	if x.Flags != 0 {
	if err := enc.NextFieldValueInt(2, __VDLType_int32_8, int64(x.Flags)); err != nil {
	return err
	}
	}
	if x.LogLevel != 0 {
	if err := enc.NextFieldValueInt(3, vdl.Int32Type, int64(x.LogLevel)); err != nil {
	return err
	}
	}
	if err := enc.NextField(-1); err != nil {
	return err
	}
	return enc.FinishValue()
	}

	func (x *Request) VDLRead(dec vdl.Decoder) error {
	*x = Request{}
	if err := dec.StartValue(__VDLType_struct_9); err != nil {
	return err
	}
	decType := dec.Type()
	for {
	index, err := dec.NextField()
	switch {
	case err != nil:
	return err
	case index == -1:
	return dec.FinishValue()
	}
	if decType != __VDLType_struct_9 {
	index = __VDLType_struct_9.FieldIndexByName(decType.Field(index).Name)
	if index == -1 {
	if err := dec.SkipValue(); err != nil {
	return err
	}
	continue
	}
	}
	switch index {
	case 0:
	bytes := x.SpanId[:]
	if err := dec.ReadValueBytes(16, &bytes); err != nil {
	return err
	}
	case 1:
	bytes := x.TraceId[:]
	if err := dec.ReadValueBytes(16, &bytes); err != nil {
	return err
	}
	case 2:
	switch value, err := dec.ReadValueInt(32); {
	case err != nil:
	return err
	default:
	x.Flags = TraceFlags(value)
	}
	case 3:
	switch value, err := dec.ReadValueInt(32); {
	case err != nil:
	return err
	default:
	x.LogLevel = int32(value)
	}
	}
	}
	}

	type Response struct {
	// Flags give options for trace collection, the client should alter its
	// collection for this trace according to the flags sent back from the
	// server.
	Flags TraceFlags
	// Trace is collected trace data. This may be empty.
	Trace TraceRecord
	}

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

	func (x Response) VDLIsZero() bool {
	if x.Flags != 0 {
	return false
	}
	if !x.Trace.VDLIsZero() {
	return false
	}
	return true
	}

	func (x Response) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_struct_10); err != nil {
	return err
	}
	if x.Flags != 0 {
	if err := enc.NextFieldValueInt(0, __VDLType_int32_8, int64(x.Flags)); err != nil {
	return err
	}
	}
	if !x.Trace.VDLIsZero() {
	if err := enc.NextField(1); err != nil {
	return err
	}
	if err := x.Trace.VDLWrite(enc); err != nil {
	return err
	}
	}
	if err := enc.NextField(-1); err != nil {
	return err
	}
	return enc.FinishValue()
	}

	func (x *Response) VDLRead(dec vdl.Decoder) error {
	*x = Response{}
	if err := dec.StartValue(__VDLType_struct_10); err != nil {
	return err
	}
	decType := dec.Type()
	for {
	index, err := dec.NextField()
	switch {
	case err != nil:
	return err
	case index == -1:
	return dec.FinishValue()
	}
	if decType != __VDLType_struct_10 {
	index = __VDLType_struct_10.FieldIndexByName(decType.Field(index).Name)
	if index == -1 {
	if err := dec.SkipValue(); err != nil {
	return err
	}
	continue
	}
	}
	switch index {
	case 0:
	switch value, err := dec.ReadValueInt(32); {
	case err != nil:
	return err
	default:
	x.Flags = TraceFlags(value)
	}
	case 1:
	if err := x.Trace.VDLRead(dec); err != nil {
	return err
	}
	}
	}
	}

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

	const Empty = TraceFlags(0)
	const CollectInMemory = TraceFlags(1)

	// Hold type definitions in package-level variables, for better performance.
	var (
	__VDLType_struct_1 *vdl.Type
	__VDLType_struct_2 *vdl.Type
	__VDLType_struct_3 *vdl.Type
	__VDLType_array_4 *vdl.Type
	__VDLType_list_5 *vdl.Type
	__VDLType_struct_6 *vdl.Type
	__VDLType_list_7 *vdl.Type
	__VDLType_int32_8 *vdl.Type
	__VDLType_struct_9 *vdl.Type
	__VDLType_struct_10 *vdl.Type
	)

	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((*Annotation)(nil))
	vdl.Register((*SpanRecord)(nil))
	vdl.Register((*TraceRecord)(nil))
	vdl.Register((*TraceFlags)(nil))
	vdl.Register((*Request)(nil))
	vdl.Register((*Response)(nil))

	// Initialize type definitions.
	__VDLType_struct_1 = vdl.TypeOf((*Annotation)(nil)).Elem()
	__VDLType_struct_2 = vdl.TypeOf((*vdltime.Time)(nil)).Elem()
	__VDLType_struct_3 = vdl.TypeOf((*SpanRecord)(nil)).Elem()
	__VDLType_array_4 = vdl.TypeOf((*uniqueid.Id)(nil))
	__VDLType_list_5 = vdl.TypeOf((*[]Annotation)(nil))
	__VDLType_struct_6 = vdl.TypeOf((*TraceRecord)(nil)).Elem()
	__VDLType_list_7 = vdl.TypeOf((*[]SpanRecord)(nil))
	__VDLType_int32_8 = vdl.TypeOf((*TraceFlags)(nil))
	__VDLType_struct_9 = vdl.TypeOf((*Request)(nil)).Elem()
	__VDLType_struct_10 = vdl.TypeOf((*Response)(nil)).Elem()

	return struct{}{}
	}