## net.sf.saxon.expr
Class VennExpression

    java.lang.Object
      |
      +--net.sf.saxon.expr.ComputedExpression
            |
            +--net.sf.saxon.expr.BinaryExpression
                  |
                  +--net.sf.saxon.expr.VennExpression

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

public class VennExpression
extends net.sf.saxon.expr.BinaryExpression

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

See Also:
  Serialized Form

Field Summary
`protected Expression` `operand0`
`protected Expression` `operand1`
`protected int` `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
`VennExpression(Expression p1, int op, Expression p2)` Constructor

Method Summary
`Expression` `analyze(StaticContext env, ItemType contextItemType)` Type-check the expression
`int` `computeCardinality()` Determine the static cardinality of the expression
`int` `computeSpecialProperties()` Get the static properties of this expression (other than its type).
`void` `display(int level, NamePool pool, java.io.PrintStream out)` Diagnostic print of expression structure
`protected java.lang.String` `displayOperator()`
`boolean` `effectiveBooleanValue(XPathContext context)` Get the effective boolean value.
`boolean` `equals(java.lang.Object other)` Is this expression the same as another expression?
`ItemType` `getItemType()` Determine the data type of the items returned by this expression
`int` `hashCode()` Is this expression the same as another expression?
`protected static boolean` `isCommutative(int operator)`
`SequenceIterator` `iterate(XPathContext c)` Iterate over the value of the expression.
`java.util.Iterator` `iterateSubExpressions()` Get the immediate subexpressions of this expression
`Expression` `promote(PromotionOffer offer)` Promote this expression if possible
`Expression` `simplify(StaticContext env)` Simplify the expression

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

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

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

Field Detail

### operand0

    protected Expression operand0

### operand1

    protected Expression operand1

### operator

    protected int operator

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

### getItemType

    public final ItemType getItemType()

  Determine the data type of the items returned by this expression

  Returns:
    the data type

### computeCardinality

    public final int computeCardinality()

  Determine the static cardinality of the expression

  Overrides:
    `computeCardinality` in class `net.sf.saxon.expr.BinaryExpression`

### 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 `ComputedExpression`

### simplify

    public Expression simplify(StaticContext env)
                        throws XPathException

  Simplify the expression

  Specified by:
    `simplify` in interface `Expression`
  Overrides:
    `simplify` in class `net.sf.saxon.expr.BinaryExpression`
  Returns:
    the simplified expression
    `XPathException`

### analyze

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

  Type-check the expression

  Specified by:
    `analyze` in interface `Expression`
  Overrides:
    `analyze` in class `net.sf.saxon.expr.BinaryExpression`
  Parameters:
    `env` - the static context of the expression
    `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
    `XPathException`

### hashCode

    public int hashCode()

  Is this expression the same as another expression?

  Overrides:
    `hashCode` in class `net.sf.saxon.expr.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 `Expression`
  Overrides:
    `iterate` in class `ComputedExpression`
  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

  Specified by:
    `effectiveBooleanValue` in interface `Expression`
  Overrides:
    `effectiveBooleanValue` in class `ComputedExpression`
  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

### promote

    public Expression promote(PromotionOffer offer)
                       throws XPathException

  Promote this expression if possible

  Specified by:
    `promote` in interface `Expression`
  Overrides:
    `promote` in class `ComputedExpression`
  Parameters:
    `offer` - details of the offer, for example the offer to move expressions that don't depend on the context to an outer level in the containing expression
  Returns:
    if the offer is not accepted, return this expression unchanged. Otherwise return the result of rewriting the expression to promote this subexpression
  Throws:
    `XPathException` - if any error is detected

### iterateSubExpressions

    public java.util.Iterator iterateSubExpressions()

  Get the immediate subexpressions of this expression

  Specified by:
    `iterateSubExpressions` in interface `Expression`
  Overrides:
    `iterateSubExpressions` in class `ComputedExpression`
  Returns:
    an iterator containing the sub-expressions of this expression

### isCommutative

    protected static boolean isCommutative(int operator)

### equals

    public boolean equals(java.lang.Object other)

  Is this expression the same as another expression?

  Overrides:
    `equals` in class `java.lang.Object`

### display

    public void display(int level,
                        NamePool pool,
                        java.io.PrintStream out)

  Diagnostic print of expression structure

  Parameters:
    `level` - indentation level for this expression
    `pool` - NamePool used to expand any names appearing in the expression
    `out` - Output destination

### displayOperator

    protected java.lang.String displayOperator()