net.sf.saxon.expr

Class SimpleExpression

public abstract class SimpleExpression extends ComputedExpression

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.
voiddisplay(int level, NamePool pool, PrintStream out)
Diagnostic print of expression structure.
ItemevaluateItem(XPathContext context)
Evaluate an expression as a single item.
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.
IteratoriterateSubExpressions()
Get the immediate sub-expressions of this expression.
Expressionoptimize(Optimizer opt, StaticContext env, ItemType contextItemType)
voidprocess(XPathContext context)
Process the instruction, without returning any tail calls
Expressionpromote(PromotionOffer offer)
Offer promotion for this subexpression.
voidsetArguments(Expression[] sub)
Set the immediate sub-expressions of this expression.
Expressionsimplify(StaticContext env)
Simplify the expression
ExpressiontypeCheck(StaticContext env, 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

display

public void display(int level, NamePool pool, PrintStream out)
Diagnostic print of expression structure. The expression is written to the System.err output stream

Parameters: level indentation level for this expression out

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

getExpressionType

public String getExpressionType()
Return a distinguishing name for the expression, for use in diagnostics. By default the class name is used.

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

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 iterateSubExpressions()
Get the immediate sub-expressions of this expression.

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

optimize

public Expression optimize(Optimizer opt, StaticContext env, 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)
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

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

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

Returns: the simplified expression

typeCheck

public Expression typeCheck(StaticContext env, ItemType contextItemType)