net.sf.saxon.expr

Class SimpleExpression

Implemented Interfaces:
EvaluableItem, InstructionInfoProvider, SequenceIterable, Serializable, SourceLocator

public abstract class SimpleExpression
extends Expression

An abstract implementation of Expression designed to make it easy to implement new expressions, in particular, expressions to support extension instructions.

Field Summary

static Expression[]
NO_ARGUMENTS
protected Expression[]
arguments

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

EVALUATE_METHOD, ITERATE_METHOD, PROCESS_METHOD, locationId, staticProperties

Constructor Summary

SimpleExpression()
Constructor

Method Summary

int
computeCardinality()
Determine the static cardinality of the expression.
int
computeDependencies()
Compute the dependencies of an expression, as the union of the dependencies of its subexpressions.
Expression
copy()
Copy an expression.
Item
evaluateItem(XPathContext context)
Evaluate an expression as a single item.
void
explain(ExpressionPresenter destination)
Diagnostic print of expression structure.
String
getExpressionType()
Return a distinguishing name for the expression, for use in diagnostics.
ItemType
getItemType(TypeHierarchy th)
Determine the data type of the items returned by this expression.
SequenceIterator
iterate(XPathContext context)
Return an Iterator to iterate over the values of a sequence.
Iterator
iterateSubExpressions()
Get the immediate sub-expressions of this expression.
Expression
optimize(ExpressionVisitor visitor, ItemType contextItemType)
void
process(XPathContext context)
Process the instruction, without returning any tail calls
Expression
promote(PromotionOffer offer)
Offer promotion for this subexpression.
boolean
replaceSubExpression(Expression original, Expression replacement)
Replace one subexpression by a replacement subexpression
void
setArguments(Expression[] sub)
Set the immediate sub-expressions of this expression.
Expression
simplify(ExpressionVisitor visitor)
Simplify the expression
Expression
typeCheck(ExpressionVisitor visitor, ItemType contextItemType)

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

addToPathMap, adoptChildExpression, checkPermittedContents, computeCardinality, computeDependencies, computeSpecialProperties, computeStaticProperties, copy, display, doPromotion, dynamicError, effectiveBooleanValue, evaluateAsString, evaluateItem, explain, explain, findParentOf, getCardinality, getColumnNumber, getConstructType, getContainer, getDependencies, getExecutable, getHostLanguage, getImplementationMethod, getInstructionInfo, getIntrinsicDependencies, getItemType, getLineNumber, getLocationId, getLocationProvider, getPublicId, getSlotsUsed, getSpecialProperties, getSystemId, hasLoopingSubexpression, implementsStaticTypeCheck, iterate, iterateEvents, iterateSubExpressions, markTailFunctionCalls, optimize, process, promote, replaceSubExpression, resetLocalStaticProperties, setContainer, setFiltered, setFlattened, setLocationId, simplify, staticTypeCheck, suppressValidation, toString, typeCheck, typeError

Field Details

NO_ARGUMENTS

public static final Expression[] NO_ARGUMENTS

arguments

protected Expression[] arguments

Constructor Details

SimpleExpression

public SimpleExpression()
Constructor

Method Details

computeCardinality

public int computeCardinality()
Determine the static cardinality of the expression. This implementation returns "zero or more", which can be overridden in a subclass.
Overrides:
computeCardinality in interface Expression

computeDependencies

public int computeDependencies()
Compute the dependencies of an expression, as the union of the dependencies of its subexpressions. (This is overridden for path expressions and filter expressions, where the dependencies of a subexpression are not all propogated). This method should be called only once, to compute the dependencies; after that, getDependencies should be used.
Overrides:
computeDependencies in interface Expression
Returns:
the depencies, as a bit-mask

copy

public Expression copy()
Copy an expression. This makes a deep copy.
Overrides:
copy in interface Expression
Returns:
the copy of the original expression

evaluateItem

public Item evaluateItem(XPathContext context)
            throws XPathException
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.
Specified by:
evaluateItem in interface EvaluableItem
Overrides:
evaluateItem in interface Expression
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:
XPathException - if any dynamic error occurs evaluating the expression

explain

public void explain(ExpressionPresenter destination)
Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.
Overrides:
explain in interface Expression

getExpressionType

public String getExpressionType()
Return a distinguishing name for the expression, for use in diagnostics. By default the class name is used.
Returns:
a distinguishing name for the expression (defaults to the name of the implementation class)

getItemType

public ItemType getItemType(TypeHierarchy th)
Determine the data type of the items returned by this expression. This implementation returns "item()", which can be overridden in a subclass.
Overrides:
getItemType in interface Expression
Parameters:
th - the type hierarchy cache
Returns:
the data type

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.
Specified by:
iterate in interface SequenceIterable
Overrides:
iterate in interface 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

iterateSubExpressions

public Iterator iterateSubExpressions()
Get the immediate sub-expressions of this expression.
Overrides:
iterateSubExpressions in interface Expression
Returns:
an array containing the sub-expressions of this expression

optimize

public Expression optimize(ExpressionVisitor visitor,
                           ItemType contextItemType)
            throws XPathException
Overrides:
optimize in interface Expression

process

public void process(XPathContext context)
            throws XPathException
Process the instruction, without returning any tail calls
Overrides:
process in interface Expression
Parameters:
context - The dynamic context, giving access to the current node, the current variables, etc.

promote

public Expression promote(PromotionOffer offer)
            throws XPathException
Offer promotion for this subexpression. The offer will be accepted if the subexpression is not dependent on the factors (e.g. the context item) identified in the PromotionOffer. By default the offer is not accepted - this is appropriate in the case of simple expressions such as constant values and variable references where promotion would give no performance advantage. This method is always called at compile time.
Overrides:
promote in interface Expression
Parameters:
offer - details of the offer, for example the offer to move expressions that don't depend on the context to an outer level in the containing expression
Returns:
if the offer is not accepted, return this expression unchanged. Otherwise return the result of rewriting the expression to promote this subexpression
Throws:
XPathException - if any error is detected

replaceSubExpression

public boolean replaceSubExpression(Expression original,
                                    Expression replacement)
Replace one subexpression by a replacement subexpression
Overrides:
replaceSubExpression in interface Expression
Parameters:
original - the original subexpression
replacement - the replacement subexpression
Returns:
true if the original subexpression is found

setArguments

public void setArguments(Expression[] sub)
Set the immediate sub-expressions of this expression.
Parameters:
sub - an array containing the sub-expressions of this expression

simplify

public Expression simplify(ExpressionVisitor visitor)
            throws XPathException
Simplify the expression
Overrides:
simplify in interface Expression
Parameters:
visitor - an expression visitor
Returns:
the simplified expression

typeCheck

public Expression typeCheck(ExpressionVisitor visitor,
                            ItemType contextItemType)
            throws XPathException
Overrides:
typeCheck in interface Expression