Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.saxonica.extra
Class GeneralComparisonSA

    java.lang.Object
      net.sf.saxon.expr.ComputedExpression
          net.sf.saxon.expr.BinaryExpression
              net.sf.saxon.expr.GeneralComparison
                  com.saxonica.extra.GeneralComparisonSA

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

public class GeneralComparisonSA
extends GeneralComparison

This class provides an implementation of the GeneralComparison "=" operator, which deals efficiently with comparing two sequences.

See Also:
  Serialized Form

Field Summary

Fields inherited from class net.sf.saxon.expr.GeneralComparison
`comparer, 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
`GeneralComparisonSA(Expression p0, int op, Expression p1)` Create a relational expression identifying the two operands and the operator

Method Summary
`boolean` | `effectiveBooleanValue(XPathContext context)` Evaluate the expression in a boolean context
`protected GeneralComparison` | `getInverseComparison()`
`static boolean` | `hashJoin(SequenceIterator iter1, SequenceIterator iter2, XPathContext context, AtomicComparer comparer)` Implement the XPath "=" operator for comparing two arbitrary sequences.

Methods inherited from class net.sf.saxon.expr.GeneralComparison
`compare, computeCardinality, displayOperator, evaluateItem, getItemType, optimize, typeCheck`

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

Methods inherited from class net.sf.saxon.expr.ComputedExpression
`adoptChildExpression, checkPermittedContents, computeDependencies, computeStaticProperties, doPromotion, dynamicError, dynamicError, evaluateAsString, getCardinality, getColumnNumber, getConstructType, getDependencies, getExecutable, getHostLanguage, getImplementationMethod, getInstructionInfo, getIntrinsicDependencies, getLineNumber, getLocationId, getLocationProvider, getParentExpression, getPublicId, getSlotsUsed, getSpecialProperties, getSystemId, hasBadParentPointer, iterate, markTailFunctionCalls, process, resetStaticProperties, setLocationId, setParentExpression, suppressValidation, typeError, typeError`

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

Constructor Detail

### GeneralComparisonSA

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

  Create a relational expression 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

### 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 `GeneralComparison`
  Parameters:
    `context` - the given context for evaluation
  Returns:
    a boolean representing the result of the numeric comparison of the two operands
  Throws:
    `XPathException`

### hashJoin

    public static boolean hashJoin(SequenceIterator iter1,
                                   SequenceIterator iter2,
                                   XPathContext context,
                                   AtomicComparer comparer)
                            throws XPathException

  Implement the XPath "=" operator for comparing two arbitrary sequences. The comparison is true if any item in the first sequence is equal to any item from the second. This implementation uses a hash join algorithm, modified to cater for the fact that untypedAtomic values act as "wild cards". This algorithm does not handle the special rules for backwards compatibility mode, and is not invoked if BCM is in force.

  Parameters:
    `iter1` - The first sequence
    `iter2` - The second sequence
    `context` - The dynamic context
    `comparer` - The comparer (which embodies the collation to be used)
  Returns:
    true if there is a pair of values that are equal, false if not
  Throws:
    `XPathException` - if there is a pair of non-comparable values, or if an untyped atomic value cannot be cast to the type of the other operand.

### getInverseComparison

    protected GeneralComparison getInverseComparison()

  Overrides:
    `getInverseComparison` in class `GeneralComparison`

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD