## net.sf.saxon.expr
Class FilterExpression

    java.lang.Object
      net.sf.saxon.expr.ComputedExpression
          net.sf.saxon.expr.FilterExpression

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

public final class FilterExpression
extends ComputedExpression

A FilterExpression contains a base expression and a filter predicate, which may be an integer expression (positional filter), or a boolean expression (qualifier)

See Also:
  Serialized Form

Field Summary

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
`FilterExpression(Expression start, Expression filter, StaticContext env)` Constructor

Method Summary
`Expression` `analyze(StaticContext env, ItemType contextItemType)` Type-check the expression
`int` `computeCardinality()` Get the static cardinality of this expression
`int` `computeDependencies()` Determine which aspects of the context the expression depends on.
`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
`boolean` `equals(java.lang.Object other)` Is this expression the same as another expression?
`Expression` `getBaseExpression()` Get the underlying expression
`Expression` `getFilter()` Get the filter expression
`ItemType` `getItemType()` Get the data type of the items returned
`int` `hashCode()` get HashCode for comparing two expressions
`boolean` `isPositional()` Determine if the filter is positional
`SequenceIterator` `iterate(XPathContext context)` Iterate over the results, returning them in the correct order
`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 an expression

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

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

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

Constructor Detail

### FilterExpression

    public FilterExpression(Expression start,
                            Expression filter,
                            StaticContext env)
                     throws StaticError

  Constructor

Parameters:
  `start` - A node-set expression denoting the absolute or relative set of nodes from which the navigation path should start.
  `filter` - An expression defining the filter predicate

Method Detail

### getItemType

    public ItemType getItemType()

  Get the data type of the items returned

  Returns:
    an integer representing the data type

### getBaseExpression

    public Expression getBaseExpression()

  Get the underlying expression

  Returns:
    the expression being filtered

### getFilter

    public Expression getFilter()

  Get the filter expression

  Returns:
    the expression acting as the filter predicate

### isPositional

    public boolean isPositional()

  Determine if the filter is positional

  Returns:
    true if the value of the filter depends on the position of the item against which it is evaluated

### simplify

    public Expression simplify(StaticContext env)
                        throws XPathException

  Simplify an expression

  Specified by:
    `simplify` in interface `Expression`
  Overrides:
    `simplify` in class `ComputedExpression`
  Returns:
    the simplified expression
  Throws:
    `XPathException` - if any failure occurs

### analyze

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

  Type-check the expression

  Parameters:
    `env` - the static context
    `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 expression after type-checking (potentially modified to add run-time checks and/or conversions)
  Throws:
    `XPathException`

### 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 promotion that is possible
  Returns:
    the promoted expression (or the original expression, unchanged)
  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:
    the subexpressions, as an array

### computeCardinality

    public int computeCardinality()

  Get the static cardinality of this expression

  Specified by:
    `computeCardinality` in class `ComputedExpression`
  Returns:
    the cardinality. The method attempts to determine the case where the filter predicate is guaranteed to select at most one item from the sequence being filtered

### computeSpecialProperties

    public int computeSpecialProperties()

  Get the static properties of this expression (other than its type). The result is bit-significant. 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`
  Returns:
    the static properties of the expression, as a bit-significant value

### equals

    public boolean equals(java.lang.Object other)

  Is this expression the same as another expression?

  Parameters:
    `other` - the expression to be compared with this one
  Returns:
    true if the two expressions are statically equivalent

### hashCode

    public int hashCode()

  get HashCode for comparing two expressions

  Returns:
    the hash code

### iterate

    public SequenceIterator iterate(XPathContext context)
                             throws XPathException

  Iterate over the results, returning them in the correct order

  Specified by:
    `iterate` in interface `Expression`
  Overrides:
    `iterate` in class `ComputedExpression`
  Parameters:
    `context` - the dynamic context for the evaluation
  Returns:
    an iterator over the expression results
  Throws:
    `XPathException` - if any dynamic error occurs

### computeDependencies

    public int computeDependencies()

  Determine which aspects of the context the expression depends on. The result is a bitwise-or'ed value composed from constants such as XPathContext.VARIABLES and XPathContext.CURRENT_NODE

  Overrides:
    `computeDependencies` in class `ComputedExpression`
  Returns:
    the dependencies

### display

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

  Diagnostic print of expression structure

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