net.sf.saxon.expr

Class LazyExpression

public class LazyExpression extends UnaryExpression

A LazyExpression is an expression that forces lazy evaluation: it must not be evaluated eagerly, because a failure must not be reported unless the value is actually referenced. This is used for an expression that has been moved out of a loop. If the loop iterates zero times, the expression will not be evaluated, and in particular, it will not cause a dynamic error.
Method Summary
protected StringdisplayOperator(NamePool pool)
ItemevaluateItem(XPathContext context)
Evaluate an expression as a single item.
SequenceIteratoriterate(XPathContext context)
Return an Iterator to iterate over the values of a sequence.
static ExpressionmakeLazyExpression(Expression operand)
voidprocess(XPathContext context)
Process the instruction, without returning any tail calls

Method Detail

displayOperator

protected String displayOperator(NamePool pool)

evaluateItem

public Item evaluateItem(XPathContext context)
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

Returns: the node or atomic value that results from evaluating the expression; or null to indicate that the result is an empty sequence

Throws: net.sf.saxon.trans.XPathException if any dynamic error occurs evaluating the expression

iterate

public SequenceIterator iterate(XPathContext context)
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 handles iteration for expressions that return singleton values: for non-singleton expressions, the subclass must provide its own implementation.

Parameters: context supplies the context for evaluation

Returns: a SequenceIterator that can be used to iterate over the result of the expression

Throws: net.sf.saxon.trans.XPathException if any dynamic error occurs evaluating the expression

makeLazyExpression

public static Expression makeLazyExpression(Expression operand)

process

public void process(XPathContext context)
Process the instruction, without returning any tail calls

Parameters: context The dynamic context, giving access to the current node, the current variables, etc.