condition.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: flyteidl/core/condition.proto

package core

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	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.ProtoPackageIsVersion3 // please upgrade the proto package

// Binary Operator for each expression
type ComparisonExpression_Operator int32

const (
	ComparisonExpression_EQ  ComparisonExpression_Operator = 0
	ComparisonExpression_NEQ ComparisonExpression_Operator = 1
	// Greater Than
	ComparisonExpression_GT  ComparisonExpression_Operator = 2
	ComparisonExpression_GTE ComparisonExpression_Operator = 3
	// Less Than
	ComparisonExpression_LT  ComparisonExpression_Operator = 4
	ComparisonExpression_LTE ComparisonExpression_Operator = 5
)

var ComparisonExpression_Operator_name = map[int32]string{
	0: "EQ",
	1: "NEQ",
	2: "GT",
	3: "GTE",
	4: "LT",
	5: "LTE",
}

var ComparisonExpression_Operator_value = map[string]int32{
	"EQ":  0,
	"NEQ": 1,
	"GT":  2,
	"GTE": 3,
	"LT":  4,
	"LTE": 5,
}

func (x ComparisonExpression_Operator) String() string {
	return proto.EnumName(ComparisonExpression_Operator_name, int32(x))
}

func (ComparisonExpression_Operator) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_df35c44899db166a, []int{0, 0}
}

// Nested conditions. They can be conjoined using AND / OR
// Order of evaluation is not important as the operators are Commutative
type ConjunctionExpression_LogicalOperator int32

const (
	// Conjunction
	ConjunctionExpression_AND ConjunctionExpression_LogicalOperator = 0
	ConjunctionExpression_OR  ConjunctionExpression_LogicalOperator = 1
)

var ConjunctionExpression_LogicalOperator_name = map[int32]string{
	0: "AND",
	1: "OR",
}

var ConjunctionExpression_LogicalOperator_value = map[string]int32{
	"AND": 0,
	"OR":  1,
}

func (x ConjunctionExpression_LogicalOperator) String() string {
	return proto.EnumName(ConjunctionExpression_LogicalOperator_name, int32(x))
}

func (ConjunctionExpression_LogicalOperator) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_df35c44899db166a, []int{3, 0}
}

// Defines a 2-level tree where the root is a comparison operator and Operands are primitives or known variables.
// Each expression results in a boolean result.
type ComparisonExpression struct {
	Operator             ComparisonExpression_Operator `protobuf:"varint,1,opt,name=operator,proto3,enum=flyteidl.core.ComparisonExpression_Operator" json:"operator,omitempty"`
	LeftValue            *Operand                      `protobuf:"bytes,2,opt,name=left_value,json=leftValue,proto3" json:"left_value,omitempty"`
	RightValue           *Operand                      `protobuf:"bytes,3,opt,name=right_value,json=rightValue,proto3" json:"right_value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

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

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

var xxx_messageInfo_ComparisonExpression proto.InternalMessageInfo

func (m *ComparisonExpression) GetOperator() ComparisonExpression_Operator {
	if m != nil {
		return m.Operator
	}
	return ComparisonExpression_EQ
}

func (m *ComparisonExpression) GetLeftValue() *Operand {
	if m != nil {
		return m.LeftValue
	}
	return nil
}

func (m *ComparisonExpression) GetRightValue() *Operand {
	if m != nil {
		return m.RightValue
	}
	return nil
}

// Defines an operand to a comparison expression.
type Operand struct {
	// Types that are valid to be assigned to Val:
	//	*Operand_Primitive
	//	*Operand_Var
	Val                  isOperand_Val `protobuf_oneof:"val"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_Operand proto.InternalMessageInfo

type isOperand_Val interface {
	isOperand_Val()
}

type Operand_Primitive struct {
	Primitive *Primitive `protobuf:"bytes,1,opt,name=primitive,proto3,oneof"`
}

type Operand_Var struct {
	Var string `protobuf:"bytes,2,opt,name=var,proto3,oneof"`
}

func (*Operand_Primitive) isOperand_Val() {}

func (*Operand_Var) isOperand_Val() {}

func (m *Operand) GetVal() isOperand_Val {
	if m != nil {
		return m.Val
	}
	return nil
}

func (m *Operand) GetPrimitive() *Primitive {
	if x, ok := m.GetVal().(*Operand_Primitive); ok {
		return x.Primitive
	}
	return nil
}

func (m *Operand) GetVar() string {
	if x, ok := m.GetVal().(*Operand_Var); ok {
		return x.Var
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Operand) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Operand_Primitive)(nil),
		(*Operand_Var)(nil),
	}
}

// Defines a boolean expression tree. It can be a simple or a conjunction expression.
// Multiple expressions can be combined using a conjunction or a disjunction to result in a final boolean result.
type BooleanExpression struct {
	// Types that are valid to be assigned to Expr:
	//	*BooleanExpression_Conjunction
	//	*BooleanExpression_Comparison
	Expr                 isBooleanExpression_Expr `protobuf_oneof:"expr"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

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

var xxx_messageInfo_BooleanExpression proto.InternalMessageInfo

type isBooleanExpression_Expr interface {
	isBooleanExpression_Expr()
}

type BooleanExpression_Conjunction struct {
	Conjunction *ConjunctionExpression `protobuf:"bytes,1,opt,name=conjunction,proto3,oneof"`
}

type BooleanExpression_Comparison struct {
	Comparison *ComparisonExpression `protobuf:"bytes,2,opt,name=comparison,proto3,oneof"`
}

func (*BooleanExpression_Conjunction) isBooleanExpression_Expr() {}

func (*BooleanExpression_Comparison) isBooleanExpression_Expr() {}

func (m *BooleanExpression) GetExpr() isBooleanExpression_Expr {
	if m != nil {
		return m.Expr
	}
	return nil
}

func (m *BooleanExpression) GetConjunction() *ConjunctionExpression {
	if x, ok := m.GetExpr().(*BooleanExpression_Conjunction); ok {
		return x.Conjunction
	}
	return nil
}

func (m *BooleanExpression) GetComparison() *ComparisonExpression {
	if x, ok := m.GetExpr().(*BooleanExpression_Comparison); ok {
		return x.Comparison
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*BooleanExpression) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*BooleanExpression_Conjunction)(nil),
		(*BooleanExpression_Comparison)(nil),
	}
}

// Defines a conjunction expression of two boolean expressions.
type ConjunctionExpression struct {
	Operator             ConjunctionExpression_LogicalOperator `protobuf:"varint,1,opt,name=operator,proto3,enum=flyteidl.core.ConjunctionExpression_LogicalOperator" json:"operator,omitempty"`
	LeftExpression       *BooleanExpression                    `protobuf:"bytes,2,opt,name=left_expression,json=leftExpression,proto3" json:"left_expression,omitempty"`
	RightExpression      *BooleanExpression                    `protobuf:"bytes,3,opt,name=right_expression,json=rightExpression,proto3" json:"right_expression,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
	XXX_unrecognized     []byte                                `json:"-"`
	XXX_sizecache        int32                                 `json:"-"`
}

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

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

var xxx_messageInfo_ConjunctionExpression proto.InternalMessageInfo

func (m *ConjunctionExpression) GetOperator() ConjunctionExpression_LogicalOperator {
	if m != nil {
		return m.Operator
	}
	return ConjunctionExpression_AND
}

func (m *ConjunctionExpression) GetLeftExpression() *BooleanExpression {
	if m != nil {
		return m.LeftExpression
	}
	return nil
}

func (m *ConjunctionExpression) GetRightExpression() *BooleanExpression {
	if m != nil {
		return m.RightExpression
	}
	return nil
}

func init() {
	proto.RegisterEnum("flyteidl.core.ComparisonExpression_Operator", ComparisonExpression_Operator_name, ComparisonExpression_Operator_value)
	proto.RegisterEnum("flyteidl.core.ConjunctionExpression_LogicalOperator", ConjunctionExpression_LogicalOperator_name, ConjunctionExpression_LogicalOperator_value)
	proto.RegisterType((*ComparisonExpression)(nil), "flyteidl.core.ComparisonExpression")
	proto.RegisterType((*Operand)(nil), "flyteidl.core.Operand")
	proto.RegisterType((*BooleanExpression)(nil), "flyteidl.core.BooleanExpression")
	proto.RegisterType((*ConjunctionExpression)(nil), "flyteidl.core.ConjunctionExpression")
}

func init() { proto.RegisterFile("flyteidl/core/condition.proto", fileDescriptor_df35c44899db166a) }

var fileDescriptor_df35c44899db166a = []byte{
	// 463 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0x4d, 0x6f, 0xd3, 0x40,
	0x10, 0x86, 0xfd, 0xd1, 0xa6, 0xcd, 0x44, 0x34, 0xcb, 0x0a, 0x50, 0x84, 0x40, 0x8a, 0x0c, 0x87,
	0x1e, 0xc0, 0x96, 0x42, 0xf9, 0xb8, 0x70, 0x20, 0x60, 0xd5, 0x88, 0xa8, 0x1f, 0x56, 0xc4, 0x81,
	0x03, 0xc8, 0x71, 0xb6, 0xee, 0xa2, 0x8d, 0xc7, 0xda, 0x6c, 0xa2, 0xf2, 0x2b, 0xf8, 0x15, 0xdc,
	0xf8, 0x91, 0x68, 0x37, 0x8e, 0x93, 0x38, 0x11, 0xca, 0xd1, 0xb3, 0xef, 0x33, 0xfb, 0x7a, 0xf6,
	0x1d, 0x78, 0x7a, 0x23, 0x7e, 0x29, 0xc6, 0xc7, 0x22, 0x48, 0x51, 0xb2, 0x20, 0xc5, 0x7c, 0xcc,
	0x15, 0xc7, 0xdc, 0x2f, 0x24, 0x2a, 0xa4, 0xf7, 0x96, 0xc7, 0xbe, 0x3e, 0x7e, 0xfc, 0x64, 0x53,
	0x2d, 0xb8, 0x62, 0x32, 0x11, 0xd3, 0x85, 0xd8, 0xfb, 0xed, 0xc0, 0x83, 0x8f, 0x38, 0x29, 0x12,
	0xc9, 0xa7, 0x98, 0x87, 0x77, 0x85, 0x64, 0xd3, 0x29, 0xc7, 0x9c, 0x46, 0x70, 0x8c, 0x05, 0x93,
	0x89, 0x42, 0xd9, 0xb1, 0xbb, 0xf6, 0xe9, 0x49, 0xef, 0x85, 0xbf, 0xd1, 0xd8, 0xdf, 0x85, 0xf9,
	0x97, 0x25, 0x13, 0x57, 0x34, 0x7d, 0x0d, 0x20, 0xd8, 0x8d, 0xfa, 0x31, 0x4f, 0xc4, 0x8c, 0x75,
	0x9c, 0xae, 0x7d, 0xda, 0xea, 0x3d, 0xaa, 0xf5, 0x32, 0x58, 0x3e, 0x8e, 0x9b, 0x5a, 0xf9, 0x55,
	0x0b, 0xe9, 0x5b, 0x68, 0x49, 0x9e, 0xdd, 0x2e, 0x39, 0xf7, 0xbf, 0x1c, 0x18, 0xa9, 0x01, 0xbd,
	0xf7, 0x70, 0xbc, 0x74, 0x41, 0x1b, 0xe0, 0x84, 0xd7, 0xc4, 0xa2, 0x47, 0xe0, 0x5e, 0x84, 0xd7,
	0xc4, 0xd6, 0x85, 0xf3, 0x21, 0x71, 0x74, 0xe1, 0x7c, 0x18, 0x12, 0x57, 0x17, 0x06, 0x43, 0x72,
	0xa0, 0x0b, 0x83, 0x61, 0x48, 0x0e, 0xbd, 0xef, 0x70, 0x54, 0x76, 0xa5, 0xef, 0xa0, 0x59, 0x48,
	0x3e, 0xe1, 0x8a, 0xcf, 0x99, 0x19, 0x42, 0xab, 0xd7, 0xa9, 0x19, 0xb8, 0x5a, 0x9e, 0x47, 0x56,
	0xbc, 0x12, 0x53, 0x0a, 0xee, 0x3c, 0x91, 0xe6, 0x67, 0x9b, 0x91, 0x15, 0xeb, 0x8f, 0xfe, 0xa1,
	0xae, 0x09, 0xef, 0xaf, 0x0d, 0xf7, 0xfb, 0x88, 0x82, 0x25, 0x9b, 0xe3, 0x6e, 0xa5, 0x98, 0xff,
	0x9c, 0xe5, 0xa9, 0x7e, 0xc9, 0xf2, 0xb2, 0xe7, 0x5b, 0x13, 0xaf, 0x14, 0x2b, 0x34, 0xb2, 0xe2,
	0x75, 0x94, 0x86, 0x00, 0x69, 0xf5, 0x32, 0xe5, 0xb8, 0x9f, 0xed, 0xf1, 0x74, 0x91, 0x15, 0xaf,
	0x81, 0xfd, 0x06, 0x1c, 0xb0, 0xbb, 0x42, 0x7a, 0x7f, 0x1c, 0x78, 0xb8, 0xf3, 0x5e, 0x7a, 0xb5,
	0x95, 0x90, 0xb3, 0x7d, 0xfc, 0xfa, 0x03, 0xcc, 0x78, 0x9a, 0x88, 0x1d, 0x49, 0xf9, 0x0c, 0x6d,
	0x93, 0x14, 0x56, 0x89, 0x4b, 0xff, 0xdd, 0x5a, 0xe3, 0xad, 0xf9, 0xc5, 0x27, 0x1a, 0x5c, 0x33,
	0xf7, 0x05, 0xc8, 0x22, 0x3d, 0x6b, 0xbd, 0xdc, 0x3d, 0x7b, 0xb5, 0x0d, 0xb9, 0x2a, 0x78, 0x1e,
	0xb4, 0x6b, 0xa6, 0x75, 0x5c, 0x3e, 0x5c, 0x7c, 0x22, 0x96, 0xce, 0xcf, 0x65, 0x4c, 0xec, 0xfe,
	0x9b, 0x6f, 0x67, 0x19, 0x57, 0xb7, 0xb3, 0x91, 0x9f, 0xe2, 0x24, 0x30, 0x57, 0xa0, 0xcc, 0x82,
	0x6a, 0xf9, 0x32, 0x96, 0x07, 0xc5, 0xe8, 0x65, 0x86, 0xc1, 0xc6, 0x3e, 0x8e, 0x1a, 0x66, 0x0f,
	0x5f, 0xfd, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xb8, 0x12, 0xe1, 0x54, 0xd5, 0x03, 0x00, 0x00,
}