## net.sf.saxon.expr
Class GeneralComparison10

    java.lang.Object
      net.sf.saxon.expr.ComputedExpression
          net.sf.saxon.expr.BinaryExpression
              net.sf.saxon.expr.GeneralComparison10

All Implemented Interfaces:
  Container, Expression, InstructionInfoProvider, java.io.Serializable, javax.xml.transform.SourceLocator

public class GeneralComparison10
extends BinaryExpression

GeneralComparison10: a boolean expression that compares two expressions for equals, not-equals, greater-than or less-than. This implements the operators =, !=, <, >, etc. This version of the class implements general comparisons in XPath 1.0 backwards compatibility mode, as defined in the Oct 2004 revision of the specifications.

See Also:
  Serialized Form

Field Summary
`protected AtomicComparer` `comparer`
`protected int` `singletonOperator`

Fields inherited from class net.sf.saxon.expr.BinaryExpression
`operand0, operand1, operator`

Fields inherited from class net.sf.saxon.expr.ComputedExpression
`locationId, staticProperties`

Fields inherited from interface net.sf.saxon.expr.Expression
`EVALUATE_METHOD, ITERATE_METHOD, PROCESS_METHOD`

Constructor Summary
`GeneralComparison10(Expression p0, int op, Expression p1)` Create a general comparison identifying the two operands and the operator

Method Summary
`Expression` `analyze(StaticContext env, ItemType contextItemType)` Type-check the expression
`protected static boolean` `compare(AtomicValue a0, int operator, AtomicValue a1, AtomicComparer comparer, XPathContext context)` Compare two atomic values
`int` `computeCardinality()` Determine the static cardinality.
`protected java.lang.String` `displayOperator()`
`boolean` `effectiveBooleanValue(XPathContext context)` Evaluate the expression in a boolean context
`Item` `evaluateItem(XPathContext context)` Evaluate the expression in a given context
`ItemType` `getItemType()` Determine the data type of the expression

Methods inherited from class net.sf.saxon.expr.BinaryExpression
`computeSpecialProperties, display, equals, getOperands, getOperator, hashCode, isCommutative, isInverse, iterateSubExpressions, promote, simplify`

Methods inherited from class net.sf.saxon.expr.ComputedExpression

`adoptChildExpression, checkPermittedContents, computeDependencies, computeStaticProperties, dynamicError, dynamicError, evaluateAsString, getCardinality, getColumnNumber, getConstructType, getDependencies, getExecutable, getImplementationMethod, getInstructionInfo, getIntrinsicDependencies, getLineNumber, getLocationId, getParentExpression, getPublicId, getSpecialProperties, getSystemId, iterate, markTailFunctionCalls, process, resetStaticProperties, setLocationId, setParentExpression, typeError, typeError`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### singletonOperator

    protected int singletonOperator

### comparer

    protected AtomicComparer comparer

Constructor Detail

### GeneralComparison10

    public GeneralComparison10(Expression p0,
                               int op,
                               Expression p1)

  Create a general comparison identifying the two operands and the operator

Parameters:
  `p0` - the left-hand operand
  `op` - the operator, as a token returned by the Tokenizer (e.g. Token.LT)
  `p1` - the right-hand operand

Method Detail

### computeCardinality

    public int computeCardinality()

  Determine the static cardinality. Returns [1..1]

  Overrides:
    `computeCardinality` in class `BinaryExpression`

### analyze

    public Expression analyze(StaticContext env,
                              ItemType contextItemType)
                       throws XPathException

  Type-check the expression

  Specified by:
    `analyze` in interface `Expression`
  Overrides:
    `analyze` in class `BinaryExpression`
  Returns:
    the checked expression
  Throws:
    `XPathException`

### evaluateItem

    public Item evaluateItem(XPathContext context)
                      throws XPathException

  Evaluate the expression in a given context

  Specified by:
    `evaluateItem` in interface `Expression`
  Overrides:
    `evaluateItem` in class `ComputedExpression`
  Parameters:
    `context` - the given context for evaluation
  Returns:
    a BooleanValue representing the result of the numeric comparison of the two operands
  Throws:
    `XPathException` - if any dynamic error occurs evaluating the expression

### effectiveBooleanValue

    public boolean effectiveBooleanValue(XPathContext context)
                                  throws XPathException

  Evaluate the expression in a boolean context

  Specified by:
    `effectiveBooleanValue` in interface `Expression`
  Overrides:
    `effectiveBooleanValue` in class `ComputedExpression`
  Parameters:
    `context` - the given context for evaluation
  Returns:
    a boolean representing the result of the numeric comparison of the two operands
  Throws:
    `XPathException` - if any dynamic error occurs evaluating the expression

### compare

    protected static boolean compare(AtomicValue a0,
                                     int operator,
                                     AtomicValue a1,
                                     AtomicComparer comparer,
                                     XPathContext context)
                              throws XPathException

  Compare two atomic values

  Throws:
    `XPathException`

### getItemType

    public ItemType getItemType()

  Determine the data type of the expression

  Returns:
    Type.BOOLEAN

### displayOperator

    protected java.lang.String displayOperator()

  Overrides:
    `displayOperator` in class `BinaryExpression`