operator.go

package cypher

type Operator struct {
	representation string
	operatorType   OperatorType
	key            string
	notNil         bool
	err            error
}

func OperatorCreate(representation string, operatorType OperatorType) Operator {

	o := Operator{
		representation: representation,
		operatorType:   operatorType,
		notNil:         true,
	}
	o.key = getAddress(&o)
	return o
}

func OperatorError(err error) Operator {
	return Operator{err: err}
}

func (o Operator) GetError() error {
	return o.err
}

func (o Operator) isNotNil() bool {
	return o.notNil
}

func (o Operator) accept(visitor *CypherRenderer) {
	visitor.enter(o)
	visitor.leave(o)
}

func (o Operator) enter(renderer *CypherRenderer) {
	operatorType := o.operatorType
	if operatorType == LABEL {
		return
	}
	if operatorType != PREFIX && o != EXPONENTIATION {
		renderer.append(" ")
	}
	renderer.append(o.representation)
	if operatorType != POSTFIX && o != EXPONENTIATION {
		renderer.append(" ")
	}
}

func (o Operator) leave(renderer *CypherRenderer) {
}

func (o Operator) getKey() string {
	return o.key
}

func (o Operator) isUnary() bool {
	return o.operatorType != BINARY
}

var ADDITION = createBinaryOperator("+")
var SUBTRACTION = createBinaryOperator("-")
var MULTIPLICATION = createBinaryOperator("*")
var DIVISION = createBinaryOperator("/")
var MODULO_DIVISION = createBinaryOperator("%")
var EXPONENTIATION = createBinaryOperator("^")
var EQUALITY = createBinaryOperator("=")
var INEQUALITY = createBinaryOperator("<>")
var LESS_THAN = createBinaryOperator("<")
var GREATER_THAN = createBinaryOperator(">")
var LESS_THAN_OR_EQUAL_TO = createBinaryOperator("<=")
var GREATER_THAN_OR_EQUAL_TO = createBinaryOperator(">=")
var STARTS_WITH = createBinaryOperator("STARTS WITH")
var ENDS_WITH = createBinaryOperator("ENDS WITH")
var CONTAINS = createBinaryOperator("CONTAINS")
var AND = createBinaryOperator("AND")
var OR = createBinaryOperator("OR")
var XOR = createBinaryOperator("XOR")
var CONCAT = createBinaryOperator("+")
var MATCHES = createBinaryOperator("=~")
var IN = createBinaryOperator("IN")
var ASSIGMENT = createBinaryOperator("=")
var PIPE = createBinaryOperator("|")
var IS_NULL = createPostfixOperator("IS NULL")
var IS_NOT_NULL = createPostfixOperator("IS NOT NULL")
var NOT = createPrefixOperator("NOT")
var SET = createPropertyOperator("=")
var GET = createPropertyOperator(".")
var MUTATE = createPropertyOperator("+=")
var SET_LABEL = createLabelOperator("")
var REMOVE_LABEL = createLabelOperator("")

func createBinaryOperator(representation string) Operator {
	return OperatorCreate(representation, BINARY)
}

func createPropertyOperator(representation string) Operator {
	return OperatorCreate(representation, PROPERTY)
}

func createLabelOperator(representation string) Operator {
	return OperatorCreate(representation, LABEL)
}

func createPrefixOperator(representation string) Operator {
	return OperatorCreate(representation, PREFIX)
}

func createPostfixOperator(representation string) Operator {
	return OperatorCreate(representation, POSTFIX)
}

type OperatorType string

const (
	BINARY   OperatorType = "binary"
	PREFIX                = "prefix"
	POSTFIX               = "postfix"
	PROPERTY              = "property"
	LABEL                 = "label"
)