net.sf.saxon.expr

Class SimpleExpression

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
protected Expression[]arguments
static Expression[]NO_ARGUMENTS
Constructor Summary
SimpleExpression()
Constructor
Method Summary
intcomputeCardinality()
Determine the static cardinality of the expression.
intcomputeDependencies()
Compute the dependencies of an expression, as the union of the dependencies of its subexpressions.
Expressioncopy()
Copy an expression.
ItemevaluateItem(XPathContext context)
Evaluate an expression as a single item.
voidexplain(ExpressionPresenter destination)
Diagnostic print of expression structure.
StringgetExpressionType()
Return a distinguishing name for the expression, for use in diagnostics.
ItemTypegetItemType(TypeHierarchy th)
Determine the data type of the items returned by this expression.
SequenceIteratoriterate(XPathContext context)
Return an Iterator to iterate over the values of a sequence.
Iterator<Expression>iterateSubExpressions()
Get the immediate sub-expressions of this expression.
Expressionoptimize(ExpressionVisitor visitor, ItemType contextItemType)
voidprocess(XPathContext context)
Process the instruction, without returning any tail calls
Expressionpromote(PromotionOffer offer, Expression parent)
Offer promotion for this subexpression.
booleanreplaceSubExpression(Expression original, Expression replacement)
Replace one subexpression by a replacement subexpression
voidsetArguments(Expression[] sub)
Set the immediate sub-expressions of this expression.
Expressionsimplify(ExpressionVisitor visitor)
Simplify the expression
ExpressiontypeCheck(ExpressionVisitor visitor, ItemType contextItemType)

Field Detail

arguments

protected Expression[] arguments

NO_ARGUMENTS

public static final Expression[] NO_ARGUMENTS

Constructor Detail

SimpleExpression

public SimpleExpression()
Constructor

Method Detail

computeCardinality

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

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.

Returns: the depencies, as a bit-mask

copy

public Expression copy()
Copy an expression. This makes a deep copy.

Returns: the copy of the original expression

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: 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.

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.

Parameters: th the type hierarchy cache

Returns: the data type

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: XPathException if any dynamic error occurs evaluating the expression

iterateSubExpressions

public Iterator<Expression> iterateSubExpressions()
Get the immediate sub-expressions of this expression.

Returns: an array containing the sub-expressions of this expression

optimize

public Expression optimize(ExpressionVisitor visitor, ItemType contextItemType)

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.

promote

public Expression promote(PromotionOffer offer, Expression parent)
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.

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 parent

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

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)
Simplify the expression

Parameters: visitor an expression visitor

Returns: the simplified expression

typeCheck

public Expression typeCheck(ExpressionVisitor visitor, ItemType contextItemType)