## net.sf.saxon.expr
Class VennExpression

    java.lang.Object
      net.sf.saxon.expr.Expression
          net.sf.saxon.expr.BinaryExpression
              net.sf.saxon.expr.VennExpression

All Implemented Interfaces:
  Serializable, SourceLocator, LocationProvider, SaxonLocator, EvaluableItem, SequenceIterable, InstructionInfo, Locator

Direct Known Subclasses:
  SingletonIntersectExpression

    public class VennExpression

extends BinaryExpression

An expression representing a nodeset that is a union, difference, or intersection of two other NodeSets

See Also:
  Serialized Form

Field Summary

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

Fields inherited from class net.sf.saxon.expr.Expression
`EVALUATE_METHOD, EVENT_FEED_METHOD, ITEM_FEED_METHOD, ITERATE_METHOD, locationId, PROCESS_METHOD, PUSH_SELECTION, staticProperties, WATCH_METHOD`

Constructor Summary
`VennExpression(Expression p1, int op, Expression p2)` Constructor

Method Summary
`int` `computeCardinality()` Determine the static cardinality of the expression
`int` `computeSpecialProperties()` Get the static properties of this expression (other than its type).
`Expression` `copy()` Copy an expression.
`boolean` `effectiveBooleanValue(XPathContext context)` Get the effective boolean value.
`boolean` `equals(Object other)` Is this expression the same as another expression?
`void` `gatherComponents(int operator, Set set)` Gather the component operands of a union or intersect expression
`String` `getExpressionName()` Get a name identifying the kind of expression, in terms meaningful to a user.
`ItemType` `getItemType(TypeHierarchy th)` Determine the data type of the items returned by this expression
`int` `hashCode()` Get a hashCode for comparing two expressions.
`SequenceIterator` `iterate(XPathContext c)` Iterate over the value of the expression.
`Expression` `optimize(ExpressionVisitor visitor, ItemType contextItemType)` Perform optimisation of an expression and its subexpressions.
`Expression` `simplify(ExpressionVisitor visitor)` Simplify the expression
`Expression` `typeCheck(ExpressionVisitor visitor, ItemType contextItemType)` Type-check the expression

Methods inherited from class net.sf.saxon.expr.BinaryExpression
`displayOperator, explain, explainExtraAttributes, getOperands, getOperator, isAssociative, isCommutative, isInverse, iterateSubExpressions, promote, replaceSubExpression, setFlattened, toString`

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

`addToPathMap, adoptChildExpression, checkForUpdatingSubexpressions, checkPermittedContents, computeDependencies, computeStaticProperties, doPromotion, dynamicError, evaluateAsString, evaluateItem, evaluatePendingUpdates, explain, getCardinality, getColumnNumber, getColumnNumber, getConstructType, getContainer, getDependencies, getEvaluationMethod, getExecutable, getHostLanguage, getImplementationMethod, getIntrinsicDependencies, getLineNumber, getLineNumber, getLocationId, getLocationProvider, getObjectName, getProperties, getProperty, getPublicId, getSlotsUsed, getSpecialProperties, getSystemId, getSystemId, hasLoopingSubexpression, implementsStaticTypeCheck, isSubtreeExpression, isUpdatingExpression, isVacuousExpression, iterateEvents, iterateSameFocusSubExpressions, markTailFunctionCalls, process, resetLocalStaticProperties, setContainer, setEvaluationMethod, setFiltered, setLocationId, staticTypeCheck, suppressValidation, typeError`

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

Constructor Detail

### VennExpression

    public VennExpression(Expression p1,
                          int op,
                          Expression p2)

  Constructor

  Parameters:
    `p1` - the left-hand operand
    `op` - the operator (union, intersection, or difference)
    `p2` - the right-hand operand

Method Detail

### getExpressionName

    public String getExpressionName()

  Get a name identifying the kind of expression, in terms meaningful to a user.

  Overrides:
    `getExpressionName` in class `Expression`
  Returns:
    a name identifying the kind of expression, in terms meaningful to a user. The name will always be in the form of a lexical XML QName, and should match the name used in explain() output displaying the expression.

### getItemType

    public final ItemType getItemType(TypeHierarchy th)

  Determine the data type of the items returned by this expression

  Specified by:
    `getItemType` in class `Expression`
  Parameters:
    `th` - the type hierarchy cache
  Returns:
    the data type

### computeCardinality

    public final int computeCardinality()

  Determine the static cardinality of the expression

  Overrides:
    `computeCardinality` in class `BinaryExpression`
  Returns:
    the computed cardinality, as one of the values `StaticProperty.ALLOWS_ZERO_OR_ONE`, `StaticProperty.EXACTLY_ONE`, `StaticProperty.ALLOWS_ONE_OR_MORE`, `StaticProperty.ALLOWS_ZERO_OR_MORE`

### computeSpecialProperties

    public int computeSpecialProperties()

  Get the static properties of this expression (other than its type). The result is bit-signficant. These properties are used for optimizations. In general, if property bit is set, it is true, but if it is unset, the value is unknown.

  Overrides:
    `computeSpecialProperties` in class `BinaryExpression`
  Returns:
    `StaticProperty.NON_CREATIVE`. This is overridden for some subclasses.

### gatherComponents

    public void gatherComponents(int operator,
                                 Set set)

  Gather the component operands of a union or intersect expression

  Parameters:
    `operator` - union or intersect
    `set` - the set into which the components are to be gathered. If the operator is union, this follows the tree gathering all operands of union expressions. Ditto, mutatis mutandis, for intersect expressions.

### simplify

    public Expression simplify(ExpressionVisitor visitor)
                        throws XPathException

  Simplify the expression

  Overrides:
    `simplify` in class `BinaryExpression`
  Parameters:
    `visitor` - an expression visitor
  Returns:
    the simplified expression
  Throws:
    `XPathException` - if an error is discovered during expression rewriting

### typeCheck

    public Expression typeCheck(ExpressionVisitor visitor,
                                ItemType contextItemType)
                         throws XPathException

  Type-check the expression

  Overrides:
    `typeCheck` in class `BinaryExpression`
  Parameters:
    `visitor` - an expression visitor
    `contextItemType` - the static type of "." at the point where this expression is invoked. The parameter is set to null if it is known statically that the context item will be undefined. If the type of the context item is not known statically, the argument is set to `Type.ITEM_TYPE`
  Returns:
    the original expression, rewritten to perform necessary run-time type checks, and to perform other type-related optimizations
  Throws:
    `XPathException` - if an error is discovered during this phase (typically a type error)

### optimize

    public Expression optimize(ExpressionVisitor visitor,
                               ItemType contextItemType)
                        throws XPathException

  Perform optimisation of an expression and its subexpressions.

  This method is called after all references to functions and variables have been resolved to the declaration of the function or variable, and after all type checking has been done.

  Overrides:
    `optimize` in class `BinaryExpression`
  Parameters:
    `visitor` - an expression visitor
    `contextItemType` - the static type of "." at the point where this expression is invoked. The parameter is set to null if it is known statically that the context item will be undefined. If the type of the context item is not known statically, the argument is set to `Type.ITEM_TYPE`
  Returns:
    the original expression, rewritten if appropriate to optimize execution
  Throws:
    `XPathException` - if an error is discovered during this phase (typically a type error)

### copy

    public Expression copy()

  Copy an expression. This makes a deep copy.

  Specified by:
    `copy` in class `Expression`
  Returns:
    the copy of the original expression

### equals

    public boolean equals(Object other)

  Is this expression the same as another expression?

  Overrides:
    `equals` in class `BinaryExpression`

### hashCode

    public int hashCode()

  Description copied from class: `BinaryExpression`
  Get a hashCode for comparing two expressions. Note that this hashcode gives the same result for (A op B) and for (B op A), whether or not the operator is commutative.

  Overrides:
    `hashCode` in class `BinaryExpression`

### iterate

    public SequenceIterator iterate(XPathContext c)
                             throws XPathException

  Iterate over the value of the expression. The result will always be sorted in document order, with duplicates eliminated

  Specified by:
    `iterate` in interface `SequenceIterable`
  Overrides:
    `iterate` in class `Expression`
  Parameters:
    `c` - The context for evaluation
  Returns:
    a SequenceIterator representing the union of the two operands
  Throws:
    `XPathException` - if any dynamic error occurs evaluating the expression

### effectiveBooleanValue

    public boolean effectiveBooleanValue(XPathContext context)
                                  throws XPathException

  Get the effective boolean value. In the case of a union expression, this is reduced to an OR expression, for efficiency

  Overrides:
    `effectiveBooleanValue` in class `Expression`
  Parameters:
    `context` - The context in which the expression is to be evaluated
  Returns:
    the effective boolean value
  Throws:
    `XPathException` - if any dynamic error occurs evaluating the expression

Copyright (c) 2004-2010 Saxonica Limited. All rights reserved.