// 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 (
	"fmt"
	"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(vdl.TypeOf((*Annotation)(nil)).Elem()); err != nil {
		return err
	}
	if !x.When.IsZero() {
		if err := enc.NextField("When"); 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.NextField("Message"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.StringType); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Message); 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 *Annotation) VDLRead(dec vdl.Decoder) error {
	*x = Annotation{}
	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 "When":
			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 "Message":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.Message, err = dec.DecodeString(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

// 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(vdl.TypeOf((*SpanRecord)(nil)).Elem()); err != nil {
		return err
	}
	if x.Id != (uniqueid.Id{}) {
		if err := enc.NextField("Id"); err != nil {
			return err
		}
		if err := x.Id.VDLWrite(enc); err != nil {
			return err
		}
	}
	if x.Parent != (uniqueid.Id{}) {
		if err := enc.NextField("Parent"); err != nil {
			return err
		}
		if err := x.Parent.VDLWrite(enc); 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.Start.IsZero() {
		if err := enc.NextField("Start"); 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("End"); 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("Annotations"); err != nil {
			return err
		}
		if err := __VDLWriteAnon_list_1(enc, x.Annotations); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWriteAnon_list_1(enc vdl.Encoder, x []Annotation) error {
	if err := enc.StartValue(vdl.TypeOf((*[]Annotation)(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 *SpanRecord) VDLRead(dec vdl.Decoder) error {
	*x = SpanRecord{}
	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 "Id":
			if err := x.Id.VDLRead(dec); err != nil {
				return err
			}
		case "Parent":
			if err := x.Parent.VDLRead(dec); err != nil {
				return err
			}
		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 "Start":
			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 "End":
			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 "Annotations":
			if err := __VDLReadAnon_list_1(dec, &x.Annotations); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLReadAnon_list_1(dec vdl.Decoder, x *[]Annotation) 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([]Annotation, 0, len)
	default:
		*x = nil
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		}
		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(vdl.TypeOf((*TraceRecord)(nil)).Elem()); err != nil {
		return err
	}
	if x.Id != (uniqueid.Id{}) {
		if err := enc.NextField("Id"); err != nil {
			return err
		}
		if err := x.Id.VDLWrite(enc); err != nil {
			return err
		}
	}
	if len(x.Spans) != 0 {
		if err := enc.NextField("Spans"); err != nil {
			return err
		}
		if err := __VDLWriteAnon_list_2(enc, x.Spans); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWriteAnon_list_2(enc vdl.Encoder, x []SpanRecord) error {
	if err := enc.StartValue(vdl.TypeOf((*[]SpanRecord)(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 *TraceRecord) VDLRead(dec vdl.Decoder) error {
	*x = TraceRecord{}
	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 "Id":
			if err := x.Id.VDLRead(dec); err != nil {
				return err
			}
		case "Spans":
			if err := __VDLReadAnon_list_2(dec, &x.Spans); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLReadAnon_list_2(dec vdl.Decoder, x *[]SpanRecord) 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([]SpanRecord, 0, len)
	default:
		*x = nil
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		}
		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.StartValue(vdl.TypeOf((*TraceFlags)(nil))); err != nil {
		return err
	}
	if err := enc.EncodeInt(int64(x)); err != nil {
		return err
	}
	return enc.FinishValue()
}

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

// 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(vdl.TypeOf((*Request)(nil)).Elem()); err != nil {
		return err
	}
	if x.SpanId != (uniqueid.Id{}) {
		if err := enc.NextField("SpanId"); err != nil {
			return err
		}
		if err := x.SpanId.VDLWrite(enc); err != nil {
			return err
		}
	}
	if x.TraceId != (uniqueid.Id{}) {
		if err := enc.NextField("TraceId"); err != nil {
			return err
		}
		if err := x.TraceId.VDLWrite(enc); err != nil {
			return err
		}
	}
	if x.Flags != 0 {
		if err := enc.NextField("Flags"); err != nil {
			return err
		}
		if err := x.Flags.VDLWrite(enc); err != nil {
			return err
		}
	}
	if x.LogLevel != 0 {
		if err := enc.NextField("LogLevel"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Int32Type); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(x.LogLevel)); 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 *Request) VDLRead(dec vdl.Decoder) error {
	*x = Request{}
	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 "SpanId":
			if err := x.SpanId.VDLRead(dec); err != nil {
				return err
			}
		case "TraceId":
			if err := x.TraceId.VDLRead(dec); err != nil {
				return err
			}
		case "Flags":
			if err := x.Flags.VDLRead(dec); err != nil {
				return err
			}
		case "LogLevel":
			if err := dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(32)
			if err != nil {
				return err
			}
			x.LogLevel = int32(tmp)
			if err := dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

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(vdl.TypeOf((*Response)(nil)).Elem()); err != nil {
		return err
	}
	if x.Flags != 0 {
		if err := enc.NextField("Flags"); err != nil {
			return err
		}
		if err := x.Flags.VDLWrite(enc); err != nil {
			return err
		}
	}
	if !x.Trace.VDLIsZero() {
		if err := enc.NextField("Trace"); err != nil {
			return err
		}
		if err := x.Trace.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *Response) VDLRead(dec vdl.Decoder) error {
	*x = Response{}
	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 "Flags":
			if err := x.Flags.VDLRead(dec); err != nil {
				return err
			}
		case "Trace":
			if err := x.Trace.VDLRead(dec); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

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

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

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))

	return struct{}{}
}