net.sf.saxon.expr
public final class FilterExpression extends ComputedExpression
Constructor Summary | |
---|---|
FilterExpression(Expression start, Expression filter, StaticContext env)
Constructor |
Method Summary | |
---|---|
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, PrintStream out)
Diagnostic print of expression structure |
boolean | equals(Object other)
Is this expression the same as another expression? |
Expression | getBaseExpression()
Get the underlying expression |
Expression | getFilter()
Get the filter expression |
ItemType | getItemType(TypeHierarchy th)
Get the data type of the items returned |
int | hashCode()
get HashCode for comparing two expressions |
boolean | isIndexable() |
boolean | isPositional(TypeHierarchy th)
Determine if the filter is positional |
SequenceIterator | iterate(XPathContext context)
Iterate over the results, returning them in the correct order |
Iterator | iterateSubExpressions()
Get the immediate subexpressions of this expression |
Expression | optimize(Optimizer opt, StaticContext env, ItemType contextItemType)
Perform optimisation of an expression and its subexpressions.
|
Expression | promote(PromotionOffer offer)
Promote this expression if possible |
Expression | simplify(StaticContext env)
Simplify an expression |
Expression | typeCheck(StaticContext env, ItemType contextItemType)
Type-check the expression |
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
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
Returns: the dependencies
Returns: the static properties of the expression, as a bit-significant value
Parameters: level the indentation level out
Parameters: other the expression to be compared with this one
Returns: true if the two expressions are statically equivalent
Returns: the expression being filtered
Returns: the expression acting as the filter predicate
Parameters: th
Returns: an integer representing the data type
Returns: the hash code
Parameters: th the Type Hierarchy (for cached access to type information)
Returns: true if the value of the filter depends on the position of the item against which it is evaluated
Parameters: context the dynamic context for the evaluation
Returns: an iterator over the expression results
Throws: XPathException if any dynamic error occurs
Returns: the subexpressions, as an array
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.
Parameters: opt the optimizer in use. This provides access to supporting functions; it also allows different optimization strategies to be used in different circumstances. 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 ITEM_TYPE
Returns: the original expression, rewritten if appropriate to optimize execution
Throws: net.sf.saxon.trans.StaticError if an error is discovered during this phase (typically a type error)
Parameters: offer details of the promotion that is possible
Returns: the promoted expression (or the original expression, unchanged)
Returns: the simplified expression
Throws: XPathException if any failure occurs
Parameters: env the static context
Returns: the expression after type-checking (potentially modified to add run-time checks and/or conversions)