instruction_serialiser

type AddNode struct {
	LeftChild  *ArithmeticResultNodeWrapper `protobuf:"bytes,1,opt,name=left_child,json=leftChild,proto3" json:"left_child,omitempty"`
	RightChild *ArithmeticResultNodeWrapper `protobuf:"bytes,2,opt,name=right_child,json=rightChild,proto3" json:"right_child,omitempty"`
	// contains filtered or unexported fields
}

type AndNode struct {
	LeftChild  *LogicalResultNodeWrapper `protobuf:"bytes,1,opt,name=left_child,json=leftChild,proto3" json:"left_child,omitempty"`
	RightChild *LogicalResultNodeWrapper `protobuf:"bytes,2,opt,name=right_child,json=rightChild,proto3" json:"right_child,omitempty"`
	// contains filtered or unexported fields
}

type ArithmeticIfElseNode struct {
	Condition *LogicalResultNodeWrapper    `protobuf:"bytes,1,opt,name=condition,proto3" json:"condition,omitempty"`
	If        *ArithmeticResultNodeWrapper `protobuf:"bytes,2,opt,name=if,proto3" json:"if,omitempty"`
	Else      *ArithmeticResultNodeWrapper `protobuf:"bytes,3,opt,name=else,proto3" json:"else,omitempty"`
	// contains filtered or unexported fields
}

type ArithmeticResultNodeWrapper struct {

	// Types that are assignable to Node:
	//	*ArithmeticResultNodeWrapper_AddNode
	//	*ArithmeticResultNodeWrapper_DivideNode
	//	*ArithmeticResultNodeWrapper_MultiplyNode
	//	*ArithmeticResultNodeWrapper_NumberNode
	//	*ArithmeticResultNodeWrapper_SubtractNode
	//	*ArithmeticResultNodeWrapper_VariableNode
	//	*ArithmeticResultNodeWrapper_LogarithmNode
	//	*ArithmeticResultNodeWrapper_PowerNode
	//	*ArithmeticResultNodeWrapper_ModuloNode
	//	*ArithmeticResultNodeWrapper_IfElseNode
	Node isArithmeticResultNodeWrapper_Node `protobuf_oneof:"node"`
	// contains filtered or unexported fields
}

type ArithmeticResultNodeWrapper_AddNode struct {
	AddNode *AddNode `protobuf:"bytes,1,opt,name=add_node,json=addNode,proto3,oneof"`
}

type ArithmeticResultNodeWrapper_DivideNode struct {
	DivideNode *DivideNode `protobuf:"bytes,2,opt,name=divide_node,json=divideNode,proto3,oneof"`
}

type ArithmeticResultNodeWrapper_IfElseNode struct {
	IfElseNode *ArithmeticIfElseNode `protobuf:"bytes,10,opt,name=if_else_node,json=ifElseNode,proto3,oneof"`
}

type ArithmeticResultNodeWrapper_LogarithmNode struct {
	LogarithmNode *LogarithmNode `protobuf:"bytes,7,opt,name=logarithm_node,json=logarithmNode,proto3,oneof"`
}

type ArithmeticResultNodeWrapper_ModuloNode struct {
	ModuloNode *ModuloNode `protobuf:"bytes,9,opt,name=modulo_node,json=moduloNode,proto3,oneof"`
}

type ArithmeticResultNodeWrapper_MultiplyNode struct {
	MultiplyNode *MultiplyNode `protobuf:"bytes,3,opt,name=multiply_node,json=multiplyNode,proto3,oneof"`
}

type ArithmeticResultNodeWrapper_NumberNode struct {
	NumberNode *NumberNode `protobuf:"bytes,4,opt,name=number_node,json=numberNode,proto3,oneof"`
}

type ArithmeticResultNodeWrapper_PowerNode struct {
	PowerNode *PowerNode `protobuf:"bytes,8,opt,name=power_node,json=powerNode,proto3,oneof"`
}

type ArithmeticResultNodeWrapper_SubtractNode struct {
	SubtractNode *SubtractNode `protobuf:"bytes,5,opt,name=subtract_node,json=subtractNode,proto3,oneof"`
}

type ArithmeticResultNodeWrapper_VariableNode struct {
	VariableNode *ArithmeticVariableNode `protobuf:"bytes,6,opt,name=variable_node,json=variableNode,proto3,oneof"`
}

type ArithmeticType = float64

type ArithmeticVariableNode struct {
	VariableName string `protobuf:"bytes,1,opt,name=variable_name,json=variableName,proto3" json:"variable_name,omitempty"`
	// contains filtered or unexported fields
}

type BoolNode struct {
	Value bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type DivideNode struct {
	LeftChild  *ArithmeticResultNodeWrapper `protobuf:"bytes,1,opt,name=left_child,json=leftChild,proto3" json:"left_child,omitempty"`
	RightChild *ArithmeticResultNodeWrapper `protobuf:"bytes,2,opt,name=right_child,json=rightChild,proto3" json:"right_child,omitempty"`
	// contains filtered or unexported fields
}

type EqualNode struct {
	LeftChild  *ArithmeticResultNodeWrapper `protobuf:"bytes,1,opt,name=left_child,json=leftChild,proto3" json:"left_child,omitempty"`
	RightChild *ArithmeticResultNodeWrapper `protobuf:"bytes,2,opt,name=right_child,json=rightChild,proto3" json:"right_child,omitempty"`
	// contains filtered or unexported fields
}

type GreaterThanNode struct {
	LeftChild  *ArithmeticResultNodeWrapper `protobuf:"bytes,1,opt,name=left_child,json=leftChild,proto3" json:"left_child,omitempty"`
	RightChild *ArithmeticResultNodeWrapper `protobuf:"bytes,2,opt,name=right_child,json=rightChild,proto3" json:"right_child,omitempty"`
	// contains filtered or unexported fields
}

type GreaterThanOrEqualNode struct {
	LeftChild  *ArithmeticResultNodeWrapper `protobuf:"bytes,1,opt,name=left_child,json=leftChild,proto3" json:"left_child,omitempty"`
	RightChild *ArithmeticResultNodeWrapper `protobuf:"bytes,2,opt,name=right_child,json=rightChild,proto3" json:"right_child,omitempty"`
	// contains filtered or unexported fields
}

type InstructionWrapper struct {

	// Types that are assignable to Wrapper:
	//	*InstructionWrapper_ArithmeticWrapper
	//	*InstructionWrapper_LogicalWrapper
	Wrapper isInstructionWrapper_Wrapper `protobuf_oneof:"wrapper"`
	// contains filtered or unexported fields
}

type InstructionWrapper_ArithmeticWrapper struct {
	ArithmeticWrapper *ArithmeticResultNodeWrapper `protobuf:"bytes,1,opt,name=arithmetic_wrapper,json=arithmeticWrapper,proto3,oneof"`
}

type InstructionWrapper_LogicalWrapper struct {
	LogicalWrapper *LogicalResultNodeWrapper `protobuf:"bytes,2,opt,name=logical_wrapper,json=logicalWrapper,proto3,oneof"`
}

type LogarithmNode struct {
	LeftChild  *ArithmeticResultNodeWrapper `protobuf:"bytes,1,opt,name=left_child,json=leftChild,proto3" json:"left_child,omitempty"`
	RightChild *ArithmeticResultNodeWrapper `protobuf:"bytes,2,opt,name=right_child,json=rightChild,proto3" json:"right_child,omitempty"` // the base
	// contains filtered or unexported fields
}

type LogicalIfElseNode struct {
	Condition *LogicalResultNodeWrapper `protobuf:"bytes,1,opt,name=condition,proto3" json:"condition,omitempty"`
	If        *LogicalResultNodeWrapper `protobuf:"bytes,2,opt,name=if,proto3" json:"if,omitempty"`
	Else      *LogicalResultNodeWrapper `protobuf:"bytes,3,opt,name=else,proto3" json:"else,omitempty"`
	// contains filtered or unexported fields
}

type LogicalResultNodeWrapper struct {

	// Types that are assignable to Node:
	//	*LogicalResultNodeWrapper_EqualNode
	//	*LogicalResultNodeWrapper_AndNode
	//	*LogicalResultNodeWrapper_BoolNode
	//	*LogicalResultNodeWrapper_NegateNode
	//	*LogicalResultNodeWrapper_OrNode
	//	*LogicalResultNodeWrapper_XorNode
	//	*LogicalResultNodeWrapper_VariableNode
	//	*LogicalResultNodeWrapper_IfElseNode
	//	*LogicalResultNodeWrapper_GreaterThanNode
	//	*LogicalResultNodeWrapper_GreaterThanOrEqualNode
	//	*LogicalResultNodeWrapper_SmallerThanNode
	//	*LogicalResultNodeWrapper_SmallerThanOrEqualNode
	Node isLogicalResultNodeWrapper_Node `protobuf_oneof:"node"`
	// contains filtered or unexported fields
}

type LogicalResultNodeWrapper_AndNode struct {
	AndNode *AndNode `protobuf:"bytes,2,opt,name=and_node,json=andNode,proto3,oneof"`
}

type LogicalResultNodeWrapper_BoolNode struct {
	BoolNode *BoolNode `protobuf:"bytes,3,opt,name=bool_node,json=boolNode,proto3,oneof"`
}

type LogicalResultNodeWrapper_EqualNode struct {
	EqualNode *EqualNode `protobuf:"bytes,1,opt,name=equal_node,json=equalNode,proto3,oneof"`
}

type LogicalResultNodeWrapper_GreaterThanNode struct {
	GreaterThanNode *GreaterThanNode `protobuf:"bytes,9,opt,name=greater_than_node,json=greaterThanNode,proto3,oneof"`
}

type LogicalResultNodeWrapper_GreaterThanOrEqualNode struct {
	GreaterThanOrEqualNode *GreaterThanOrEqualNode `protobuf:"bytes,10,opt,name=greater_than_or_equal_node,json=greaterThanOrEqualNode,proto3,oneof"`
}

type LogicalResultNodeWrapper_IfElseNode struct {
	IfElseNode *LogicalIfElseNode `protobuf:"bytes,8,opt,name=if_else_node,json=ifElseNode,proto3,oneof"`
}

type LogicalResultNodeWrapper_NegateNode struct {
	NegateNode *NegateNode `protobuf:"bytes,4,opt,name=negate_node,json=negateNode,proto3,oneof"`
}

type LogicalResultNodeWrapper_OrNode struct {
	OrNode *OrNode `protobuf:"bytes,5,opt,name=or_node,json=orNode,proto3,oneof"`
}

type LogicalResultNodeWrapper_SmallerThanNode struct {
	SmallerThanNode *SmallerThanNode `protobuf:"bytes,11,opt,name=smaller_than_node,json=smallerThanNode,proto3,oneof"`
}

type LogicalResultNodeWrapper_SmallerThanOrEqualNode struct {
	SmallerThanOrEqualNode *SmallerThanOrEqualNode `protobuf:"bytes,12,opt,name=smaller_than_or_equal_node,json=smallerThanOrEqualNode,proto3,oneof"`
}

type LogicalResultNodeWrapper_VariableNode struct {
	VariableNode *LogicalVariableNode `protobuf:"bytes,7,opt,name=variable_node,json=variableNode,proto3,oneof"`
}

type LogicalResultNodeWrapper_XorNode struct {
	XorNode *XorNode `protobuf:"bytes,6,opt,name=xor_node,json=xorNode,proto3,oneof"`
}

type LogicalType = bool

type LogicalVariableNode struct {
	VariableName string `protobuf:"bytes,1,opt,name=variable_name,json=variableName,proto3" json:"variable_name,omitempty"`
	// contains filtered or unexported fields
}

type ModuloNode struct {
	LeftChild  *ArithmeticResultNodeWrapper `protobuf:"bytes,1,opt,name=left_child,json=leftChild,proto3" json:"left_child,omitempty"`
	RightChild *ArithmeticResultNodeWrapper `protobuf:"bytes,2,opt,name=right_child,json=rightChild,proto3" json:"right_child,omitempty"`
	// contains filtered or unexported fields
}

type MultiplyNode struct {
	LeftChild  *ArithmeticResultNodeWrapper `protobuf:"bytes,1,opt,name=left_child,json=leftChild,proto3" json:"left_child,omitempty"`
	RightChild *ArithmeticResultNodeWrapper `protobuf:"bytes,2,opt,name=right_child,json=rightChild,proto3" json:"right_child,omitempty"`
	// contains filtered or unexported fields
}

type NegateNode struct {
	Child *LogicalResultNodeWrapper `protobuf:"bytes,1,opt,name=child,proto3" json:"child,omitempty"`
	// contains filtered or unexported fields
}

type NumberNode struct {
	Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type OrNode struct {
	LeftChild  *LogicalResultNodeWrapper `protobuf:"bytes,1,opt,name=left_child,json=leftChild,proto3" json:"left_child,omitempty"`
	RightChild *LogicalResultNodeWrapper `protobuf:"bytes,2,opt,name=right_child,json=rightChild,proto3" json:"right_child,omitempty"`
	// contains filtered or unexported fields
}

type PowerNode struct {
	LeftChild  *ArithmeticResultNodeWrapper `protobuf:"bytes,1,opt,name=left_child,json=leftChild,proto3" json:"left_child,omitempty"`    // the base
	RightChild *ArithmeticResultNodeWrapper `protobuf:"bytes,2,opt,name=right_child,json=rightChild,proto3" json:"right_child,omitempty"` // the exponent
	// contains filtered or unexported fields
}

type SmallerThanNode struct {
	LeftChild  *ArithmeticResultNodeWrapper `protobuf:"bytes,1,opt,name=left_child,json=leftChild,proto3" json:"left_child,omitempty"`
	RightChild *ArithmeticResultNodeWrapper `protobuf:"bytes,2,opt,name=right_child,json=rightChild,proto3" json:"right_child,omitempty"`
	// contains filtered or unexported fields
}

type SmallerThanOrEqualNode struct {
	LeftChild  *ArithmeticResultNodeWrapper `protobuf:"bytes,1,opt,name=left_child,json=leftChild,proto3" json:"left_child,omitempty"`
	RightChild *ArithmeticResultNodeWrapper `protobuf:"bytes,2,opt,name=right_child,json=rightChild,proto3" json:"right_child,omitempty"`
	// contains filtered or unexported fields
}

type SubtractNode struct {
	LeftChild  *ArithmeticResultNodeWrapper `protobuf:"bytes,1,opt,name=left_child,json=leftChild,proto3" json:"left_child,omitempty"`
	RightChild *ArithmeticResultNodeWrapper `protobuf:"bytes,2,opt,name=right_child,json=rightChild,proto3" json:"right_child,omitempty"`
	// contains filtered or unexported fields
}

type XorNode struct {
	LeftChild  *LogicalResultNodeWrapper `protobuf:"bytes,1,opt,name=left_child,json=leftChild,proto3" json:"left_child,omitempty"`
	RightChild *LogicalResultNodeWrapper `protobuf:"bytes,2,opt,name=right_child,json=rightChild,proto3" json:"right_child,omitempty"`
	// contains filtered or unexported fields
}