| java.lang.Object
 net.sf.saxon.expr.ComputedExpression
net.sf.saxon.instruct.Instruction
net.sf.saxon.instruct.Choose
| Choose | | public class Choose extends Instruction (Code) | | Compiled representation of an xsl:choose or xsl:if element in the stylesheet.
Also used for typeswitch in XQuery.
|
| Method Summary | |
| public 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. | | final public boolean | createsNewNodes()
Determine whether this instruction creates new nodes. | | public void | display(int level, NamePool pool, PrintStream out)
Diagnostic print of expression structure. | | public Item | evaluateItem(XPathContext context)
Evaluate an expression as a single item. | | public int | getInstructionNameCode()
Get the name of this instruction for diagnostic and tracing purposes
We assume that if there was
only one condition then it was an xsl:if; this is not necessarily so, but
it's adequate for tracing purposes. | | public ItemType | getItemType(TypeHierarchy th)
| | public SequenceIterator | iterate(XPathContext context)
Return an Iterator to iterate over the values of a sequence. | | public Iterator | iterateSubExpressions()
| | public Expression | optimize(Optimizer opt, StaticContext env, ItemType contextItemType)
| | public TailCall | processLeavingTail(XPathContext context)
Process this instruction, that is, choose an xsl:when or xsl:otherwise child
and process it.
Parameters:
context - the dynamic context of this transformation
throws:
XPathException - if any non-recoverable dynamic error occurs a TailCall, if the chosen branch ends with a call of call-template orapply-templates. | | protected void | promoteInst(PromotionOffer offer)
Handle promotion offers, that is, non-local tree rewrites. | | public Expression | simplify(StaticContext env)
Simplify an expression. | | public Expression | typeCheck(StaticContext env, ItemType contextItemType)
|
| Choose | | public Choose(Expression[] conditions, Expression[] actions)(Code) | | Construct an xsl:choose instruction
Parameters:
conditions - the conditions to be tested, in order
Parameters:
actions - the actions to be taken when the corresponding condition is true |
| checkPermittedContents | | public void checkPermittedContents(SchemaType parentType, StaticContext env, boolean whole) throws XPathException(Code) | | Check that any elements and attributes constructed or returned by this expression are acceptable
in the content model of a given complex type. It's always OK to say yes, since the check will be
repeated at run-time. The process of checking element and attribute constructors against the content
model of a complex type also registers the type of content expected of those constructors, so the
static validation can continue recursively.
|
| createsNewNodes | | final public boolean createsNewNodes()(Code) | | Determine whether this instruction creates new nodes.
This implementation returns true if any of the "actions" creates new nodes.
(Nodes created by the conditions can't contribute to the result).
|
| display | | public void display(int level, NamePool pool, PrintStream out)(Code) | | Diagnostic print of expression structure. The expression is written to the System.err
output stream
Parameters:
level - indentation level for this expression
Parameters:
out - |
| evaluateItem | | public Item evaluateItem(XPathContext context) throws XPathException(Code) | | Evaluate an expression as a single item. This always returns either a single Item or
null (denoting the empty sequence). No conversion is done. This method should not be
used unless the static type of the expression is a subtype of "item" or "item?": that is,
it should not be called if the expression may return a sequence. There is no guarantee that
this condition will be detected.
Parameters:
context - The context in which the expression is to be evaluated
exception:
XPathException - if any dynamic error occurs evaluating theexpression the node or atomic value that results from evaluating theexpression; or null to indicate that the result is an emptysequence |
| getInstructionNameCode | | public int getInstructionNameCode()(Code) | | Get the name of this instruction for diagnostic and tracing purposes
We assume that if there was
only one condition then it was an xsl:if; this is not necessarily so, but
it's adequate for tracing purposes.
|
| getItemType | | public ItemType getItemType(TypeHierarchy th)(Code) | | Get the item type of the items returned by evaluating this instruction
the static item type of the instruction
Parameters:
th - |
| iterate | | public SequenceIterator iterate(XPathContext context) throws XPathException(Code) | | Return an Iterator to iterate over the values of a sequence. The value of every
expression can be regarded as a sequence, so this method is supported for all
expressions. This default implementation relies on the process() method: it
"pushes" the results of the instruction to a sequence in memory, and then
iterates over this in-memory sequence.
In principle instructions should implement a pipelined iterate() method that
avoids the overhead of intermediate storage.
exception:
XPathException - if any dynamic error occurs evaluating theexpression
Parameters:
context - supplies the context for evaluation a SequenceIterator that can be used to iterate over the resultof the expression |
| iterateSubExpressions | | public Iterator iterateSubExpressions()(Code) | | 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)
|
| processLeavingTail | | public TailCall processLeavingTail(XPathContext context) throws XPathException(Code) | | Process this instruction, that is, choose an xsl:when or xsl:otherwise child
and process it.
Parameters:
context - the dynamic context of this transformation
throws:
XPathException - if any non-recoverable dynamic error occurs a TailCall, if the chosen branch ends with a call of call-template orapply-templates. It is the caller's responsibility to execute such a TailCall.If there is no TailCall, returns null. |
| simplify | | public Expression simplify(StaticContext env) throws XPathException(Code) | | Simplify an expression. This performs any static optimization (by rewriting the expression
as a different expression).
exception:
XPathException - if an error is discovered during expressionrewriting the simplified expression |
|
|