net.sf.saxon.expr.instruct

Class OnEmptyExpr

java.lang.Object

net.sf.saxon.expr.Expression

net.sf.saxon.expr.UnaryExpression

net.sf.saxon.expr.instruct.OnEmptyExpr

All Implemented Interfaces:

ExportAgent, Locatable, IdentityComparable

public class OnEmptyExpr
extends UnaryExpression

A compiled xsl:on-empty instruction. The instruction will always be a child of a ConditionalBlock.

Field Summary

Fields inherited from class net.sf.saxon.expr.Expression

EFFECTIVE_BOOLEAN_VALUE, EVALUATE_METHOD, ITEM_FEED_METHOD, ITERATE_METHOD, MAX_COST, MAX_SEQUENCE_LENGTH, MAX_STRING_LENGTH, PROCESS_METHOD, staticProperties, UNBOUNDED_LOWER, UNBOUNDED_UPPER, UPDATE_METHOD, WATCH_METHOD

Constructor Summary

Constructors

Constructor and Description
OnEmptyExpr(Expression base) Create the instruction

Method Summary

Modifier and Type	Method and Description
boolean	allowExtractingCommonSubexpressions() Ask whether common subexpressions found in the operands of this expression can be extracted and evaluated outside the expression itself.
Expression	copy(RebindingMap rebindings) Copy an expression.
void	export(ExpressionPresenter out) Diagnostic print of expression structure.
java.lang.String	getExpressionName() Get a name identifying the kind of expression, in terms meaningful to a user.
int	getImplementationMethod() An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process().
int	getIntrinsicDependencies() Determine the intrinsic dependencies of an expression, that is, those which are not derived from the dependencies of its subexpressions.
protected OperandRole	getOperandRole() Get the usage (in terms of streamability analysis) of the single operand
java.lang.String	getStreamerName() Get the (partial) name of a class that supports streaming of this kind of expression
boolean	isInstruction() Ask whether this expression is an instruction.
SequenceIterator<?>	iterate(XPathContext context) Return an Iterator to iterate over the values of a sequence.
Expression	optimize(ExpressionVisitor visitor, ContextItemStaticInfo contextInfo) Perform optimisation of an expression and its subexpressions.
void	process(XPathContext context) Process the instruction, without returning any tail calls
Expression	typeCheck(ExpressionVisitor visitor, ContextItemStaticInfo contextInfo) Type-check the expression.

Methods inherited from class net.sf.saxon.expr.UnaryExpression

computeCardinality, computeHashCode, computeSpecialProperties, displayOperator, equals, getBaseExpression, getItemType, getOperand, operands, setBaseExpression, toShortString, toString

Methods inherited from class net.sf.saxon.expr.Expression

addToPathMap, adoptChildExpression, checkedOperands, checkForUpdatingSubexpressions, checkPermittedContents, computeDependencies, computeStaticProperties, dynamicError, effectiveBooleanValue, evaluateAsString, evaluateItem, evaluatePendingUpdates, explain, getCardinality, getConfiguration, getConstructType, getCost, getDependencies, getEvaluationMethod, getExtraProperty, getIntegerBounds, getInterpretedExpression, getLocalRetainedStaticContext, getLocation, getNetCost, getObjectName, getPackageData, getParentExpression, getProperties, getProperty, getRetainedStaticContext, getScopingExpression, getSlotsUsed, getSpecialProperties, getStaticBaseURI, getStaticBaseURIString, getStaticType, getStaticUType, hasCompatibleStaticContext, hashCode, hasSpecialProperty, hasVariableBinding, identityHashCode, implementsStaticTypeCheck, isCallOn, isEqual, isIdentical, isLiftable, isMultiThreaded, isStaticPropertiesKnown, isSubtreeExpression, isUpdatingExpression, isVacuousExpression, markTailFunctionCalls, operandList, operandSparseList, optimizeChildren, prepareForStreaming, resetLocalStaticProperties, restoreParentPointers, setEvaluationMethod, setExtraProperty, setFiltered, setFlattened, setLocation, setParentExpression, setRetainedStaticContext, setRetainedStaticContextLocally, setRetainedStaticContextThoroughly, setStaticProperty, simplify, simplifyChildren, staticTypeCheck, suppressValidation, toPattern, typeCheckChildren, typeError, unordered, verifyParentPointers

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

OnEmptyExpr

public OnEmptyExpr(Expression base)

Create the instruction

Method Detail

isInstruction

public boolean isInstruction()

Ask whether this expression is an instruction. In XSLT streamability analysis this is used to distinguish constructs corresponding to XSLT instructions from other constructs.

Overrides:

isInstruction in class Expression

Returns:

true if this construct originates as an XSLT instruction

getOperandRole

protected OperandRole getOperandRole()

Get the usage (in terms of streamability analysis) of the single operand

Specified by:

getOperandRole in class UnaryExpression

Returns:

the operand usage

getIntrinsicDependencies

public int getIntrinsicDependencies()

Determine the intrinsic dependencies of an expression, that is, those which are not derived from the dependencies of its subexpressions. For example, position() has an intrinsic dependency on the context position, while (position()+1) does not. The default implementation of the method returns 0, indicating "no dependencies".

Overrides:

getIntrinsicDependencies in class Expression

Returns:

a set of bit-significant flags identifying the "intrinsic" dependencies. The flags are documented in class net.sf.saxon.value.StaticProperty

allowExtractingCommonSubexpressions

public boolean allowExtractingCommonSubexpressions()

Ask whether common subexpressions found in the operands of this expression can be extracted and evaluated outside the expression itself. The result is irrelevant in the case of operands evaluated with a different focus, which will never be extracted in this way, even if they have no focus dependency.

Overrides:

allowExtractingCommonSubexpressions in class Expression

Returns:

false for this kind of expression

typeCheck

public Expression typeCheck(ExpressionVisitor visitor,
                            ContextItemStaticInfo contextInfo)
                     throws XPathException

Type-check the expression. Default implementation for unary operators that accept any kind of operand

Overrides:

typeCheck in class UnaryExpression

Parameters:

visitor - an expression visitor

contextInfo - Information available statically about the context item: whether it is (possibly) absent; its static type; its streaming posture.

Returns:

the original expression, rewritten to perform necessary run-time type checks, and to perform other type-related optimizations

Throws:

XPathException - if an error is discovered during this phase (typically a type error)

optimize

public Expression optimize(ExpressionVisitor visitor,
                           ContextItemStaticInfo contextInfo)
                    throws XPathException

Perform optimisation of an expression and its subexpressions.

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.

Overrides:

optimize in class UnaryExpression

Parameters:

visitor - an expression visitor

contextInfo - 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 Type.ITEM_TYPE

Returns:

the original expression, rewritten if appropriate to optimize execution

Throws:

XPathException - if an error is discovered during this phase (typically a type error)

copy

public Expression copy(RebindingMap rebindings)

Description copied from class: Expression

Copy an expression. This makes a deep copy.

Specified by:

copy in class Expression

Parameters:

rebindings - a mutable list of (old binding, new binding) pairs that is used to update the bindings held in any local variable references that are copied.

Returns:

the copy of the original expression

getImplementationMethod

public int getImplementationMethod()

An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process(). This method indicates which of these methods is provided directly. The other methods will always be available indirectly, using an implementation that relies on one of the other methods.

Specified by:

getImplementationMethod in class Expression

Returns:

the implementation method, for example Expression.ITERATE_METHOD or Expression.EVALUATE_METHOD or Expression.PROCESS_METHOD

getExpressionName

public java.lang.String getExpressionName()

Get a name identifying the kind of expression, in terms meaningful to a user.

Overrides:

getExpressionName in class Expression

Returns:

a name identifying the kind of expression, in terms meaningful to a user. The name will always be in the form of a lexical XML QName, and should match the name used in export() output displaying the expression.

process

public void process(XPathContext context)
             throws XPathException

Process the instruction, without returning any tail calls

Overrides:

process in class Expression

Parameters:

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

Throws:

XPathException - if a dynamic error occurs

iterate

public SequenceIterator<?> iterate(XPathContext context)
                            throws XPathException

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.

Overrides:

iterate in class Expression

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

export

public void export(ExpressionPresenter out)
            throws XPathException

Description copied from class: UnaryExpression

Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.

Specified by:

export in interface ExportAgent

Overrides:

export in class UnaryExpression

Parameters:

out - the expression presenter used to display the structure

Throws:

XPathException - if the export fails, for example if an expression is found that won't work in the target environment.

getStreamerName

public java.lang.String getStreamerName()

Get the (partial) name of a class that supports streaming of this kind of expression

Overrides:

getStreamerName in class Expression

Returns:

the partial name of a class that can be instantiated to provide streaming support in Saxon-EE, or null if there is no such class