net.sf.saxon.instruct
public class ForEach extends Instruction implements ContextMappingFunction
Constructor Summary | |
---|---|
ForEach(Expression select, Expression action, boolean containsTailCall)
Create an xsl:for-each instruction |
Method Summary | |
---|---|
PathMap.PathMapNodeSet | addToPathMap(PathMap pathMap, PathMap.PathMapNodeSet pathMapNodeSet)
Add a representation of this expression to a PathMap. |
void | checkPermittedContents(SchemaType parentType, StaticContext env, boolean whole)
Check that any elements and attributes constructed or returned by this expression are acceptable
in the content model of a given complex type. |
int | computeDependencies()
Compute the dependencies of an expression, as the union of the
dependencies of its subexpressions. |
Expression | copy()
Copy an expression. |
boolean | createsNewNodes()
Determine whether this instruction creates new nodes.
|
void | explain(ExpressionPresenter out)
Diagnostic print of expression structure. |
Expression | getActionExpression()
Get the action expression (the content of the for-each) |
int | getImplementationMethod()
An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process().
|
int | getInstructionNameCode()
Get the name of this instruction for diagnostic and tracing purposes |
ItemType | getItemType(TypeHierarchy th)
Determine the data type of the items returned by this expression |
boolean | hasLoopingSubexpression(Expression child)
Given an expression that is an immediate child of this expression, test whether
the evaluation of the parent expression causes the child expression to be
evaluated repeatedly |
SequenceIterator | iterate(XPathContext context)
Return an Iterator to iterate over the values of the sequence.
|
Iterator<Expression> | iterateSameFocusSubExpressions()
Get the immediate sub-expressions of this expression that are evaluated with the
same focus (context item, position, and size) as the parent expression. |
Iterator<Expression> | iterateSubExpressions()
Get all the XPath expressions associated with this instruction
(in XSLT terms, the expression present on attributes of the instruction,
as distinct from the child instructions in a sequence construction) |
SequenceIterator | map(XPathContext context)
Map one item to a sequence. |
Expression | optimize(ExpressionVisitor visitor, ItemType contextItemType) |
TailCall | processLeavingTail(XPathContext context) |
protected void | promoteInst(PromotionOffer offer)
Handle promotion offers, that is, non-local tree rewrites. |
boolean | replaceSubExpression(Expression original, Expression replacement)
Replace one subexpression by a replacement subexpression |
Expression | simplify(ExpressionVisitor visitor)
Simplify an expression. |
Expression | typeCheck(ExpressionVisitor visitor, ItemType contextItemType) |
Parameters: select the select expression action the body of the xsl:for-each loop
The default implementation of this method assumes that an expression does no navigation other than the navigation done by evaluating its subexpressions, and that the subexpressions are evaluated in the same context as the containing expression. The method must be overridden for any expression where these assumptions do not hold. For example, implementations exist for AxisExpression, ParentExpression, and RootExpression (because they perform navigation), and for the doc(), document(), and collection() functions because they create a new navigation root. Implementations also exist for PathExpression and FilterExpression because they have subexpressions that are evaluated in a different context from the calling expression.
Parameters: pathMap the PathMap to which the expression should be added pathMapNodeSet the set of nodes in the path map that are affected
Returns: the pathMapNode representing the focus established by this expression, in the case where this expression is the first operand of a path expression or filter expression. For an expression that does navigation, it represents the end of the arc in the path map that describes the navigation route. For other expressions, it is the same as the input pathMapNode.
Returns: the depencies, as a bit-mask
Returns: the copy of the original expression
Returns: the body of the for-each loop
Returns: the code for name xsl:for-each
Parameters: th the type hierarchy cache
Returns: the data type
Parameters: child the immediate subexpression
Returns: true if the child expression is evaluated repeatedly
Parameters: context supplies the context for evaluation
Returns: a SequenceIterator that can be used to iterate over the result of the expression
Throws: XPathException if any dynamic error occurs evaluating the expression
Returns: an iterator containing those sub-expressions of this expression that are evaluated with the same focus as the parent expression
Parameters: context The processing context. This is supplied only for mapping constructs that set the context node, position, and size. Otherwise it is null.
Returns: either (a) a SequenceIterator over the sequence of items that the supplied input item maps to, or (b) an Item if it maps to a single item, or (c) null if it maps to an empty sequence.
Parameters: offer The type of rewrite being offered
Throws: XPathException
Parameters: original the original subexpression replacement the replacement subexpression
Returns: true if the original subexpression is found
Parameters: visitor the expression visitor
Returns: the simplified expression
Throws: XPathException if an error is discovered during expression rewriting