vdl/builtin.vdl.go

// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file was auto-generated by the vanadium vdl tool.
// Source: builtin.vdl

package vdl

import (
	"fmt"
)

// WireError is the wire representation for the built-in error type.  Errors and
// exceptions in each programming environment are converted to this type to
// ensure wire compatibility.  Generated code for each environment provides
// automatic conversions into idiomatic native representations.
type WireError struct {
	Id        string        // Error Id, used to uniquely identify each error.
	RetryCode WireRetryCode // Retry behavior suggested for the receiver.
	Msg       string        // Error message, may be empty.
	ParamList []*Value      // Variadic parameters contained in the error.
}

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

func (m *WireError) FillVDLTarget(t Target, tt *Type) error {

	if __VDLType_builtin_v_io_v23_vdl_WireError == nil || __VDLTypebuiltin0 == nil {
		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
	}
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Id")
	if err != ErrFieldNoExist && err != nil {
		return err
	}
	if err != ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.Id), StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("RetryCode")
	if err != ErrFieldNoExist && err != nil {
		return err
	}
	if err != ErrFieldNoExist {

		if err := m.RetryCode.FillVDLTarget(fieldTarget5, __VDLType_builtin_v_io_v23_vdl_WireRetryCode); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Msg")
	if err != ErrFieldNoExist && err != nil {
		return err
	}
	if err != ErrFieldNoExist {
		if err := fieldTarget7.FromString(string(m.Msg), StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
			return err
		}
	}
	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("ParamList")
	if err != ErrFieldNoExist && err != nil {
		return err
	}
	if err != ErrFieldNoExist {

		listTarget10, err := fieldTarget9.StartList(__VDLTypebuiltin1, len(m.ParamList))
		if err != nil {
			return err
		}
		for i, elem12 := range m.ParamList {
			elemTarget11, err := listTarget10.StartElem(i)
			if err != nil {
				return err
			}

			if elem12 == nil {
				if err := elemTarget11.FromNil(AnyType); err != nil {
					return err
				}
			} else {
				if err := FromValue(elemTarget11, elem12); err != nil {
					return err
				}
			}
			if err := listTarget10.FinishElem(elemTarget11); err != nil {
				return err
			}
		}
		if err := fieldTarget9.FinishList(listTarget10); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *WireError) MakeVDLTarget() Target {
	return nil
}

// WireRetryCode is the suggested retry behavior for the receiver of an error.
// If the receiver doesn't know how to handle the specific error, it should
// attempt the suggested retry behavior.
type WireRetryCode int

const (
	WireRetryCodeNoRetry WireRetryCode = iota
	WireRetryCodeRetryConnection
	WireRetryCodeRetryRefetch
	WireRetryCodeRetryBackoff
)

// WireRetryCodeAll holds all labels for WireRetryCode.
var WireRetryCodeAll = [...]WireRetryCode{WireRetryCodeNoRetry, WireRetryCodeRetryConnection, WireRetryCodeRetryRefetch, WireRetryCodeRetryBackoff}

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

// Set assigns label to x.
func (x *WireRetryCode) Set(label string) error {
	switch label {
	case "NoRetry", "noretry":
		*x = WireRetryCodeNoRetry
		return nil
	case "RetryConnection", "retryconnection":
		*x = WireRetryCodeRetryConnection
		return nil
	case "RetryRefetch", "retryrefetch":
		*x = WireRetryCodeRetryRefetch
		return nil
	case "RetryBackoff", "retrybackoff":
		*x = WireRetryCodeRetryBackoff
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in vdl.WireRetryCode", label)
}

// String returns the string label of x.
func (x WireRetryCode) String() string {
	switch x {
	case WireRetryCodeNoRetry:
		return "NoRetry"
	case WireRetryCodeRetryConnection:
		return "RetryConnection"
	case WireRetryCodeRetryRefetch:
		return "RetryRefetch"
	case WireRetryCodeRetryBackoff:
		return "RetryBackoff"
	}
	return ""
}

func (WireRetryCode) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vdl.WireRetryCode"`
	Enum struct{ NoRetry, RetryConnection, RetryRefetch, RetryBackoff string }
}) {
}

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

func (m WireRetryCode) MakeVDLTarget() Target {
	return nil
}

func init() {
	Register((*WireError)(nil))
	Register((*WireRetryCode)(nil))
}

var __VDLTypebuiltin0 *Type = TypeOf((*WireError)(nil))
var __VDLTypebuiltin1 *Type = TypeOf([]*Value(nil))
var __VDLType_builtin_v_io_v23_vdl_WireError *Type = TypeOf(WireError{})
var __VDLType_builtin_v_io_v23_vdl_WireRetryCode *Type = TypeOf(WireRetryCodeNoRetry)

func __VDLEnsureNativeBuilt_builtin() {
}