vendor/google.golang.org/genproto/googleapis/api/expr/v1beta1/eval.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/expr/v1beta1/eval.proto

package expr

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	status "google.golang.org/genproto/googleapis/rpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

// The state of an evaluation.
//
// Can represent an initial, partial, or completed state of evaluation.
type EvalState struct {
	// The unique values referenced in this message.
	Values []*ExprValue `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
	// An ordered list of results.
	//
	// Tracks the flow of evaluation through the expression.
	// May be sparse.
	Results              []*EvalState_Result `protobuf:"bytes,3,rep,name=results,proto3" json:"results,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *EvalState) Reset()         { *m = EvalState{} }
func (m *EvalState) String() string { return proto.CompactTextString(m) }
func (*EvalState) ProtoMessage()    {}
func (*EvalState) Descriptor() ([]byte, []int) {
	return fileDescriptor_5cf79b1c58929ac8, []int{0}
}

func (m *EvalState) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EvalState.Unmarshal(m, b)
}
func (m *EvalState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EvalState.Marshal(b, m, deterministic)
}
func (m *EvalState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EvalState.Merge(m, src)
}
func (m *EvalState) XXX_Size() int {
	return xxx_messageInfo_EvalState.Size(m)
}
func (m *EvalState) XXX_DiscardUnknown() {
	xxx_messageInfo_EvalState.DiscardUnknown(m)
}

var xxx_messageInfo_EvalState proto.InternalMessageInfo

func (m *EvalState) GetValues() []*ExprValue {
	if m != nil {
		return m.Values
	}
	return nil
}

func (m *EvalState) GetResults() []*EvalState_Result {
	if m != nil {
		return m.Results
	}
	return nil
}

// A single evaluation result.
type EvalState_Result struct {
	// The expression this result is for.
	Expr *IdRef `protobuf:"bytes,1,opt,name=expr,proto3" json:"expr,omitempty"`
	// The index in `values` of the resulting value.
	Value                int32    `protobuf:"varint,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EvalState_Result) Reset()         { *m = EvalState_Result{} }
func (m *EvalState_Result) String() string { return proto.CompactTextString(m) }
func (*EvalState_Result) ProtoMessage()    {}
func (*EvalState_Result) Descriptor() ([]byte, []int) {
	return fileDescriptor_5cf79b1c58929ac8, []int{0, 0}
}

func (m *EvalState_Result) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EvalState_Result.Unmarshal(m, b)
}
func (m *EvalState_Result) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EvalState_Result.Marshal(b, m, deterministic)
}
func (m *EvalState_Result) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EvalState_Result.Merge(m, src)
}
func (m *EvalState_Result) XXX_Size() int {
	return xxx_messageInfo_EvalState_Result.Size(m)
}
func (m *EvalState_Result) XXX_DiscardUnknown() {
	xxx_messageInfo_EvalState_Result.DiscardUnknown(m)
}

var xxx_messageInfo_EvalState_Result proto.InternalMessageInfo

func (m *EvalState_Result) GetExpr() *IdRef {
	if m != nil {
		return m.Expr
	}
	return nil
}

func (m *EvalState_Result) GetValue() int32 {
	if m != nil {
		return m.Value
	}
	return 0
}

// The value of an evaluated expression.
type ExprValue struct {
	// An expression can resolve to a value, error or unknown.
	//
	// Types that are valid to be assigned to Kind:
	//	*ExprValue_Value
	//	*ExprValue_Error
	//	*ExprValue_Unknown
	Kind                 isExprValue_Kind `protobuf_oneof:"kind"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *ExprValue) Reset()         { *m = ExprValue{} }
func (m *ExprValue) String() string { return proto.CompactTextString(m) }
func (*ExprValue) ProtoMessage()    {}
func (*ExprValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_5cf79b1c58929ac8, []int{1}
}

func (m *ExprValue) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExprValue.Unmarshal(m, b)
}
func (m *ExprValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExprValue.Marshal(b, m, deterministic)
}
func (m *ExprValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExprValue.Merge(m, src)
}
func (m *ExprValue) XXX_Size() int {
	return xxx_messageInfo_ExprValue.Size(m)
}
func (m *ExprValue) XXX_DiscardUnknown() {
	xxx_messageInfo_ExprValue.DiscardUnknown(m)
}

var xxx_messageInfo_ExprValue proto.InternalMessageInfo

type isExprValue_Kind interface {
	isExprValue_Kind()
}

type ExprValue_Value struct {
	Value *Value `protobuf:"bytes,1,opt,name=value,proto3,oneof"`
}

type ExprValue_Error struct {
	Error *ErrorSet `protobuf:"bytes,2,opt,name=error,proto3,oneof"`
}

type ExprValue_Unknown struct {
	Unknown *UnknownSet `protobuf:"bytes,3,opt,name=unknown,proto3,oneof"`
}

func (*ExprValue_Value) isExprValue_Kind() {}

func (*ExprValue_Error) isExprValue_Kind() {}

func (*ExprValue_Unknown) isExprValue_Kind() {}

func (m *ExprValue) GetKind() isExprValue_Kind {
	if m != nil {
		return m.Kind
	}
	return nil
}

func (m *ExprValue) GetValue() *Value {
	if x, ok := m.GetKind().(*ExprValue_Value); ok {
		return x.Value
	}
	return nil
}

func (m *ExprValue) GetError() *ErrorSet {
	if x, ok := m.GetKind().(*ExprValue_Error); ok {
		return x.Error
	}
	return nil
}

func (m *ExprValue) GetUnknown() *UnknownSet {
	if x, ok := m.GetKind().(*ExprValue_Unknown); ok {
		return x.Unknown
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*ExprValue) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _ExprValue_OneofMarshaler, _ExprValue_OneofUnmarshaler, _ExprValue_OneofSizer, []interface{}{
		(*ExprValue_Value)(nil),
		(*ExprValue_Error)(nil),
		(*ExprValue_Unknown)(nil),
	}
}

func _ExprValue_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*ExprValue)
	// kind
	switch x := m.Kind.(type) {
	case *ExprValue_Value:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Value); err != nil {
			return err
		}
	case *ExprValue_Error:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Error); err != nil {
			return err
		}
	case *ExprValue_Unknown:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Unknown); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("ExprValue.Kind has unexpected type %T", x)
	}
	return nil
}

func _ExprValue_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*ExprValue)
	switch tag {
	case 1: // kind.value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Value)
		err := b.DecodeMessage(msg)
		m.Kind = &ExprValue_Value{msg}
		return true, err
	case 2: // kind.error
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ErrorSet)
		err := b.DecodeMessage(msg)
		m.Kind = &ExprValue_Error{msg}
		return true, err
	case 3: // kind.unknown
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(UnknownSet)
		err := b.DecodeMessage(msg)
		m.Kind = &ExprValue_Unknown{msg}
		return true, err
	default:
		return false, nil
	}
}

func _ExprValue_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*ExprValue)
	// kind
	switch x := m.Kind.(type) {
	case *ExprValue_Value:
		s := proto.Size(x.Value)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ExprValue_Error:
		s := proto.Size(x.Error)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ExprValue_Unknown:
		s := proto.Size(x.Unknown)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// A set of errors.
//
// The errors included depend on the context. See `ExprValue.error`.
type ErrorSet struct {
	// The errors in the set.
	Errors               []*status.Status `protobuf:"bytes,1,rep,name=errors,proto3" json:"errors,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *ErrorSet) Reset()         { *m = ErrorSet{} }
func (m *ErrorSet) String() string { return proto.CompactTextString(m) }
func (*ErrorSet) ProtoMessage()    {}
func (*ErrorSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_5cf79b1c58929ac8, []int{2}
}

func (m *ErrorSet) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ErrorSet.Unmarshal(m, b)
}
func (m *ErrorSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ErrorSet.Marshal(b, m, deterministic)
}
func (m *ErrorSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ErrorSet.Merge(m, src)
}
func (m *ErrorSet) XXX_Size() int {
	return xxx_messageInfo_ErrorSet.Size(m)
}
func (m *ErrorSet) XXX_DiscardUnknown() {
	xxx_messageInfo_ErrorSet.DiscardUnknown(m)
}

var xxx_messageInfo_ErrorSet proto.InternalMessageInfo

func (m *ErrorSet) GetErrors() []*status.Status {
	if m != nil {
		return m.Errors
	}
	return nil
}

// A set of expressions for which the value is unknown.
//
// The unknowns included depend on the context. See `ExprValue.unknown`.
type UnknownSet struct {
	// The ids of the expressions with unknown values.
	Exprs                []*IdRef `protobuf:"bytes,1,rep,name=exprs,proto3" json:"exprs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UnknownSet) Reset()         { *m = UnknownSet{} }
func (m *UnknownSet) String() string { return proto.CompactTextString(m) }
func (*UnknownSet) ProtoMessage()    {}
func (*UnknownSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_5cf79b1c58929ac8, []int{3}
}

func (m *UnknownSet) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UnknownSet.Unmarshal(m, b)
}
func (m *UnknownSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UnknownSet.Marshal(b, m, deterministic)
}
func (m *UnknownSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnknownSet.Merge(m, src)
}
func (m *UnknownSet) XXX_Size() int {
	return xxx_messageInfo_UnknownSet.Size(m)
}
func (m *UnknownSet) XXX_DiscardUnknown() {
	xxx_messageInfo_UnknownSet.DiscardUnknown(m)
}

var xxx_messageInfo_UnknownSet proto.InternalMessageInfo

func (m *UnknownSet) GetExprs() []*IdRef {
	if m != nil {
		return m.Exprs
	}
	return nil
}

// A reference to an expression id.
type IdRef struct {
	// The expression id.
	Id                   int32    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *IdRef) Reset()         { *m = IdRef{} }
func (m *IdRef) String() string { return proto.CompactTextString(m) }
func (*IdRef) ProtoMessage()    {}
func (*IdRef) Descriptor() ([]byte, []int) {
	return fileDescriptor_5cf79b1c58929ac8, []int{4}
}

func (m *IdRef) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IdRef.Unmarshal(m, b)
}
func (m *IdRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IdRef.Marshal(b, m, deterministic)
}
func (m *IdRef) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IdRef.Merge(m, src)
}
func (m *IdRef) XXX_Size() int {
	return xxx_messageInfo_IdRef.Size(m)
}
func (m *IdRef) XXX_DiscardUnknown() {
	xxx_messageInfo_IdRef.DiscardUnknown(m)
}

var xxx_messageInfo_IdRef proto.InternalMessageInfo

func (m *IdRef) GetId() int32 {
	if m != nil {
		return m.Id
	}
	return 0
}

func init() {
	proto.RegisterType((*EvalState)(nil), "google.api.expr.v1beta1.EvalState")
	proto.RegisterType((*EvalState_Result)(nil), "google.api.expr.v1beta1.EvalState.Result")
	proto.RegisterType((*ExprValue)(nil), "google.api.expr.v1beta1.ExprValue")
	proto.RegisterType((*ErrorSet)(nil), "google.api.expr.v1beta1.ErrorSet")
	proto.RegisterType((*UnknownSet)(nil), "google.api.expr.v1beta1.UnknownSet")
	proto.RegisterType((*IdRef)(nil), "google.api.expr.v1beta1.IdRef")
}

func init() { proto.RegisterFile("google/api/expr/v1beta1/eval.proto", fileDescriptor_5cf79b1c58929ac8) }

var fileDescriptor_5cf79b1c58929ac8 = []byte{
	// 392 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0xcf, 0x8b, 0xd4, 0x30,
	0x14, 0xc7, 0xcd, 0xcc, 0xb6, 0xab, 0x6f, 0xc0, 0x43, 0x10, 0xb6, 0x8c, 0x20, 0x63, 0xf7, 0x32,
	0x7a, 0x48, 0xd8, 0x2a, 0x0b, 0xba, 0x07, 0xa1, 0xb2, 0xa0, 0xb7, 0x25, 0x83, 0x1e, 0xbc, 0x65,
	0xa7, 0xb1, 0xd4, 0xa9, 0x4d, 0x48, 0xd3, 0x3a, 0xff, 0xa1, 0xff, 0x86, 0x7f, 0x86, 0x47, 0xc9,
	0x4b, 0x83, 0x87, 0xa5, 0xcc, 0xf1, 0x25, 0x9f, 0xcf, 0xf7, 0xe5, 0xc7, 0x83, 0xbc, 0xd6, 0xba,
	0x6e, 0x15, 0x97, 0xa6, 0xe1, 0xea, 0x68, 0x2c, 0x1f, 0xaf, 0xee, 0x95, 0x93, 0x57, 0x5c, 0x8d,
	0xb2, 0x65, 0xc6, 0x6a, 0xa7, 0xe9, 0x45, 0x60, 0x98, 0x34, 0x0d, 0xf3, 0x0c, 0x9b, 0x98, 0xf5,
	0xe5, 0x9c, 0x3c, 0xca, 0x76, 0x50, 0xc1, 0x5e, 0x4f, 0x36, 0xb7, 0x66, 0xcf, 0x7b, 0x27, 0xdd,
	0xd0, 0x87, 0x8d, 0xfc, 0x0f, 0x81, 0x27, 0xb7, 0xa3, 0x6c, 0x77, 0x4e, 0x3a, 0x45, 0xdf, 0x43,
	0x8a, 0x56, 0x9f, 0x91, 0xcd, 0x72, 0xbb, 0x2a, 0x72, 0x36, 0xd3, 0x95, 0xdd, 0x1e, 0x8d, 0xfd,
	0xea, 0x51, 0x31, 0x19, 0xf4, 0x23, 0x9c, 0x5b, 0xd5, 0x0f, 0xad, 0xeb, 0xb3, 0x25, 0xca, 0xaf,
	0xe6, 0xe5, 0xd8, 0x90, 0x09, 0x34, 0x44, 0x34, 0xd7, 0x02, 0xd2, 0xb0, 0x44, 0x0b, 0x38, 0xf3,
	0x4e, 0x46, 0x36, 0x64, 0xbb, 0x2a, 0x5e, 0xcc, 0x66, 0x7d, 0xae, 0x84, 0xfa, 0x2e, 0x90, 0xa5,
	0xcf, 0x20, 0xc1, 0xc3, 0x64, 0x8b, 0x0d, 0xd9, 0x26, 0x22, 0x14, 0xf9, 0x6f, 0x7f, 0xc5, 0x78,
	0x5c, 0x7a, 0x1d, 0x99, 0x53, 0xc1, 0x88, 0x7f, 0x7a, 0x34, 0xa5, 0xd0, 0x77, 0x90, 0x28, 0x6b,
	0xb5, 0xc5, 0xec, 0x55, 0xf1, 0x72, 0xfe, 0x72, 0x9e, 0xda, 0x29, 0xe7, 0x55, 0x34, 0xe8, 0x07,
	0x38, 0x1f, 0xba, 0x43, 0xa7, 0x7f, 0x75, 0xd9, 0x12, 0xe5, 0xcb, 0x59, 0xf9, 0x4b, 0xe0, 0x82,
	0x1e, 0xad, 0x32, 0x85, 0xb3, 0x43, 0xd3, 0x55, 0xf9, 0x35, 0x3c, 0x8e, 0xe9, 0xf4, 0x35, 0xa4,
	0x98, 0x1e, 0xbf, 0x8a, 0xc6, 0x4c, 0x6b, 0xf6, 0x6c, 0x87, 0x5f, 0x2c, 0x26, 0x22, 0x2f, 0x01,
	0xfe, 0x07, 0xd3, 0xb7, 0x90, 0xf8, 0x9e, 0x51, 0x3c, 0xf5, 0xb4, 0x01, 0xce, 0x2f, 0x20, 0xc1,
	0x9a, 0x3e, 0x85, 0x45, 0x53, 0xe1, 0xeb, 0x25, 0x62, 0xd1, 0x54, 0xe5, 0x0f, 0x78, 0xbe, 0xd7,
	0x3f, 0xe7, 0x42, 0x4a, 0x9c, 0xae, 0x3b, 0x3f, 0x6b, 0x77, 0xe4, 0xdb, 0xcd, 0x44, 0xd5, 0xba,
	0x95, 0x5d, 0xcd, 0xb4, 0xad, 0x79, 0xad, 0x3a, 0x9c, 0x44, 0x1e, 0xb6, 0xa4, 0x69, 0xfa, 0x07,
	0xa3, 0x7c, 0xe3, 0x8b, 0xbf, 0x84, 0xdc, 0xa7, 0x88, 0xbe, 0xf9, 0x17, 0x00, 0x00, 0xff, 0xff,
	0x33, 0xb5, 0xd5, 0x2b, 0x31, 0x03, 0x00, 0x00,
}