net.sf.saxon.instruct
public class ForEachGroup extends Instruction implements ContextMappingFunction, SortKeyEvaluator
Field Summary | |
---|---|
static int | GROUP_ADJACENT |
static int | GROUP_BY |
static int | GROUP_BY_SINGLETON |
static int | GROUP_ENDING |
static int | GROUP_STARTING |
Constructor Summary | |
---|---|
ForEachGroup(Expression select, Expression action, byte algorithm, Expression key, StringCollator collator, Expression collationNameExpression, String baseURI, SortKeyDefinition[] sortKeys)
Create a for-each-group 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.
|
Item | evaluateSortKey(int n, XPathContext c)
Callback for evaluating the sort keys |
void | explain(ExpressionPresenter out)
Diagnostic print of expression structure. |
Expression | getActionExpression()
Get the action expression (the content of the for-each-group) |
Expression | getGroupingKey()
Get the grouping key expression expression (the group-by or group-adjacent expression, or a
PatternSponsor containing the group-starting-with or group-ending-with expression) |
int | getInstructionNameCode()
Get the name of this instruction for diagnostic and tracing purposes |
ItemType | getItemType(TypeHierarchy th)
Get the item type of the items returned by evaluating this instruction
|
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 a 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 (selects the population to be grouped) action the body of the for-each-group (applied to each group in turn) algorithm one of group-by, group-adjacent, group-starting-with, group-ending-with key expression to evaluate the grouping key collator user for comparing strings collationNameExpression expression that yields the name of the collation to be used baseURI static base URI of the expression sortKeys list of xsl:sort keys for sorting the groups
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
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 xsl:for-each-group instruction
Returns: the expression used to calculate grouping keys
Returns: the name of the instruction
Parameters: th the type hierarchy cache
Returns: the static item type of the instruction
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 an expression visitor
Returns: the simplified expression
Throws: XPathException if an error is discovered during expression rewriting