InequalityExpression

abstract def canEqual(that: Any): Boolean

abstract def includeEquality: Boolean

abstract def lhs: Expression

abstract def negated: InequalityExpression

abstract def position: InputPosition

abstract def productArity: Int

abstract def productElement(n: Int): Any

abstract def rhs: Expression

abstract def swapped: InequalityExpression

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def arguments: Seq[Expression]

def asCanonicalStringVal: String

final def asInstanceOf[T0]: T0

def canonicalOperatorSymbol: String

def clone(): AnyRef

def containsAggregate: Boolean

Return true is this expression contains an aggregating expression.

def copyAndReplace(variable: LogicalVariable): AnyRef { def by(replacement: => org.opencypher.v9_0.expressions.Expression): org.opencypher.v9_0.expressions.Expression }

def dependencies: Set[LogicalVariable]

def dup(children: Seq[AnyRef]): InequalityExpression.this.type

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def findAggregate: Option[Expression]

Returns the first encountered aggregate expression, or None if none existed.

final def getClass(): Class[_]

def hashCode(): Int

def inputs: Seq[(Expression, Set[LogicalVariable])]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def occurrences(variable: LogicalVariable): Set[Ref[Variable]]

def productIterator: Iterator[Any]

def productPrefix: String

val signatures: Vector[TypeSignature]

def subExpressions: Seq[Expression]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit