| java.lang.Object
 net.sf.saxon.expr.ComputedExpression
All known Subclasses: net.sf.saxon.instruct.SimpleContentConstructor, net.sf.saxon.instruct.Instruction, net.sf.saxon.expr.FilterExpression, net.sf.saxon.expr.ContextItemExpression, net.sf.saxon.expr.ErrorExpression, net.sf.saxon.expr.CastAsQName, net.sf.saxon.expr.TailExpression, net.sf.saxon.expr.FunctionCall, net.sf.saxon.expr.BinaryExpression, net.sf.saxon.sort.SortExpression, net.sf.saxon.expr.SingleNodeExpression, net.sf.saxon.expr.VariableReference, net.sf.saxon.sort.TupleExpression, net.sf.saxon.expr.IntegerRangeTest, net.sf.saxon.expr.SuppliedParameterReference, net.sf.saxon.expr.SimpleMappingExpression, net.sf.saxon.expr.IfExpression, net.sf.saxon.expr.Assignation, net.sf.saxon.expr.PathExpression, net.sf.saxon.expr.AxisExpression, net.sf.saxon.expr.UnaryExpression, net.sf.saxon.expr.IsLastExpression, net.sf.saxon.instruct.NumberInstruction, net.sf.saxon.sort.TupleSorter, net.sf.saxon.expr.PositionRange, net.sf.saxon.expr.SimpleExpression,
| ComputedExpression | | abstract public class ComputedExpression implements Serializable,Expression,InstructionInfoProvider,Container(Code) | | This class is an abstract superclass for different kinds of expression. This includes
XSLT instructions, which are treated just like XPath expressions.
Every expression is either a constant Value, or a ComputedExpression.
There are three principal methods for evaluating an expression: iterate(), which
an iterator over the result of the expression as a sequence; evaluateItem(), which returns an
object that is an instance of net.sf.saxon.om.Item; and process(), which pushes the results of
the expression to a Receiver. All three methods take an
XPathContext object to supply the evaluation context; for an expression that is
a Value, this argument is ignored and may be null. This root class provides an implementation
of iterate() in terms of evaluateItem() that works only for singleton expressions, and an implementation
of evaluateItem() in terms of iterate() that works only for non-singleton expressions. Subclasses
of expression must therefore provide either iterate() or evaluateItem() or process(): they do not have to provide
all three.
Note that the methods that take an XPathContext argument are run-time methods.
The methods without such an argument are compile-time methods. Run-time methods must not
modify the state of the Expression object.
|
| Method Summary | |
| public void | adoptChildExpression(Expression child)
| | public void | checkPermittedContents(SchemaType parentType, StaticContext env, boolean whole)
Check that any elements and attributes constructed or returned by this expression are acceptable
in the content model of a given complex type. | | abstract protected int | computeCardinality()
| | public int | computeDependencies()
Compute the dependencies of an expression, as the union of the
dependencies of its subexpressions. | | public int | computeSpecialProperties()
| | final public void | computeStaticProperties()
Compute the static properties. | | final public Expression | doPromotion(Expression subexpression, PromotionOffer offer)
| | protected void | dynamicError(String message, XPathContext context)
| | protected void | dynamicError(String message, String code, XPathContext context)
| | public boolean | effectiveBooleanValue(XPathContext context)
Get the effective boolean value of the expression. | | public String | evaluateAsString(XPathContext context)
Evaluate an expression as a String. | | public Item | evaluateItem(XPathContext context)
Evaluate an expression as a single item. | | public int | getCardinality()
Determine the static cardinality of the expression. | | public int | getColumnNumber()
| | protected int | getConstructType()
| | public int | getDependencies()
Determine which aspects of the context the expression depends on. | | public Executable | getExecutable()
| | public int | getImplementationMethod()
An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process(). | | public InstructionInfo | getInstructionInfo()
| | public int | getIntrinsicDependencies()
Determine the intrinsic dependencies of an expression, that is, those which are not derived
from the dependencies of its subexpressions. | | public int | getLineNumber()
| | final public int | getLocationId()
| | public LocationProvider | getLocationProvider()
Get the LocationProvider allowing location identifiers to be resolved. | | public Container | getParentExpression()
Get the expression that immediately contains this expression. | | final public String | getPublicId()
| | public int[] | getSlotsUsed()
Get the local variables (identified by their slot numbers) on which this expression depends. | | final public int | getSpecialProperties()
Get the static properties of this expression (other than its type). | | public String | getSystemId()
| | public boolean | hasBadParentPointer()
| | public SequenceIterator | iterate(XPathContext context)
Return an Iterator to iterate over the values of a sequence. | | public Iterator | iterateSubExpressions()
Get the immediate sub-expressions of this expression. | | public boolean | markTailFunctionCalls()
Mark tail-recursive calls on stylesheet functions. | | public void | process(XPathContext context)
| | public Expression | promote(PromotionOffer offer)
Offer promotion for this subexpression. | | final public void | resetStaticProperties()
Reset the static properties. | | public void | setLocationId(int id)
Set the location ID on an expression. | | public void | setParentExpression(Container parent)
| | public Expression | simplify(StaticContext env)
Simplify an expression. | | public void | suppressValidation(int validationMode)
Suppress validation on contained element constructors, on the grounds that the parent element
is already performing validation. | | protected void | typeError(String message, XPathContext context)
| | protected void | typeError(String message, String errorCode, XPathContext context)
|
| locationId | | protected int locationId(Code) | | |
| staticProperties | | protected int staticProperties(Code) | | |
| checkPermittedContents | | public void checkPermittedContents(SchemaType parentType, StaticContext env, boolean whole) throws XPathException(Code) | | Check that any elements and attributes constructed or returned by this expression are acceptable
in the content model of a given complex type. It's always OK to say yes, since the check will be
repeated at run-time. The process of checking element and attribute constructors against the content
model of a complex type also registers the type of content expected of those constructors, so the
static validation can continue recursively.
|
| computeCardinality | | abstract protected int computeCardinality()(Code) | | |
| computeDependencies | | public int computeDependencies()(Code) | | 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.
the depencies, as a bit-mask |
| computeSpecialProperties | | public int computeSpecialProperties()(Code) | | |
| computeStaticProperties | | final public void computeStaticProperties()(Code) | | Compute the static properties. This should only be done once for each
expression.
|
| doPromotion | | final public Expression doPromotion(Expression subexpression, PromotionOffer offer) throws XPathException(Code) | | Promote a subexpression if possible, and if the expression was changed, carry out housekeeping
to reset the static properties and correct the parent pointers in the tree
|
| effectiveBooleanValue | | public boolean effectiveBooleanValue(XPathContext context) throws XPathException(Code) | | Get the effective boolean value of the expression. This returns false if the value
is the empty sequence, a zero-length string, a number equal to zero, or the boolean
false. Otherwise it returns true.
Parameters:
context - The context in which the expression is to be evaluated
exception:
XPathException - if any dynamic error occurs evaluating theexpression the effective boolean value |
| evaluateAsString | | public String evaluateAsString(XPathContext context) throws XPathException(Code) | | Evaluate an expression as a String. This function must only be called in contexts
where it is known that the expression will return a single string (or where an empty sequence
is to be treated as a zero-length string). Implementations should not attempt to convert
the result to a string, other than converting () to "". This method is used mainly to
evaluate expressions produced by compiling an attribute value template.
exception:
XPathException - if any dynamic error occurs evaluating theexpression
exception:
ClassCastException - if the result type of theexpression is not xs:string?
Parameters:
context - The context in which the expression is to be evaluated the value of the expression, evaluated in the current context.The expression must return a string or (); if the value of theexpression is (), this method returns "". |
| evaluateItem | | public Item evaluateItem(XPathContext context) throws XPathException(Code) | | 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
exception:
XPathException - if any dynamic error occurs evaluating theexpression the node or atomic value that results from evaluating theexpression; or null to indicate that the result is an emptysequence |
| getCardinality | | public int getCardinality()(Code) | | Determine the static cardinality of the expression. This establishes how many items
there will be in the result of the expression, at compile time (i.e., without
actually evaluating the result.
one of the values Cardinality.ONE_OR_MORE,Cardinality.ZERO_OR_MORE, Cardinality.EXACTLY_ONE,Cardinality.ZERO_OR_ONE, Cardinality.EMPTY. This defaultimplementation returns ZERO_OR_MORE (which effectively gives noinformation). |
| getColumnNumber | | public int getColumnNumber()(Code) | | Get the column number of the expression
|
| getConstructType | | protected int getConstructType()(Code) | | Get the type of this expression for use in tracing and diagnostics
the type of expression, as enumerated in class Location |
| getDependencies | | public int getDependencies()(Code) | | Determine which aspects of the context the expression depends on. The result is
a bitwise-or'ed value composed from constants such as XPathContext.VARIABLES and
XPathContext.CURRENT_NODE. The default implementation combines the intrinsic
dependencies of this expression with the dependencies of the subexpressions,
computed recursively. This is overridden for expressions such as FilterExpression
where a subexpression's dependencies are not necessarily inherited by the parent
expression.
a set of bit-significant flags identifying the dependencies ofthe expression |
| getExecutable | | public Executable getExecutable()(Code) | | Get the executable containing this expression
|
| getImplementationMethod | | public int getImplementationMethod()(Code) | | An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process().
This method indicates which of these methods is prefered.
|
| getInstructionInfo | | public InstructionInfo getInstructionInfo()(Code) | | Get InstructionInfo for this expression
|
| getIntrinsicDependencies | | public int getIntrinsicDependencies()(Code) | | 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".
a set of bit-significant flags identifying the "intrinsic"dependencies. The flags are documented in class net.sf.saxon.value.StaticProperty |
| getLineNumber | | public int getLineNumber()(Code) | | Get the line number of the expression
|
| getLocationId | | final public int getLocationId()(Code) | | Get the location ID of the expression
|
| getLocationProvider | | public LocationProvider getLocationProvider()(Code) | | Get the LocationProvider allowing location identifiers to be resolved.
|
| getParentExpression | | public Container getParentExpression()(Code) | | Get the expression that immediately contains this expression. This method
returns null for an outermost expression; it also return null in the case
of literal values. For an XPath expression occurring within an XSLT stylesheet,
this method returns the XSLT instruction containing the XPath expression.
the expression that contains this expression, if known; return nullif there is no containing expression or if the containing expression is unknown. |
| getPublicId | | final public String getPublicId()(Code) | | Get the publicId of the module containing the expression (to satisfy the SourceLocator interface)
|
| getSlotsUsed | | public int[] getSlotsUsed()(Code) | | Get the local variables (identified by their slot numbers) on which this expression depends.
Should only be called if the caller has established that there is a dependency on local variables.
|
| getSpecialProperties | | final public int getSpecialProperties()(Code) | | Get the static properties of this expression (other than its type). The result is
bit-signficant. These properties are used for optimizations. In general, if
property bit is set, it is true, but if it is unset, the value is unknown.
a set of flags indicating static properties of this expression |
| getSystemId | | public String getSystemId()(Code) | | Get the systemId of the module containing the expression
|
| hasBadParentPointer | | public boolean hasBadParentPointer()(Code) | | Diagnostic method: search the tree for an expression whose parent expression is incorrectly set
|
| iterate | | public SequenceIterator iterate(XPathContext context) throws XPathException(Code) | | 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.
exception:
XPathException - if any dynamic error occurs evaluating theexpression
Parameters:
context - supplies the context for evaluation a SequenceIterator that can be used to iterate over the resultof the expression |
| iterateSubExpressions | | public Iterator iterateSubExpressions()(Code) | | Get the immediate sub-expressions of this expression. Default implementation
returns a zero-length array, appropriate for an expression that has no
sub-expressions.
an iterator containing the sub-expressions of this expression |
| markTailFunctionCalls | | public boolean markTailFunctionCalls()(Code) | | Mark tail-recursive calls on stylesheet functions. For most expressions, this does nothing.
true if a tail recursive call was found and if this callaccounts for the whole of the value. |
| process | | public void process(XPathContext context) throws XPathException(Code) | | 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) throws XPathException(Code) | | 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 moveexpressions that don't depend on the context to an outer level inthe containing expression
exception:
net.sf.saxon.trans.XPathException - if any error is detected if the offer is not accepted, return this expression unchanged.Otherwise return the result of rewriting the expression to promotethis subexpression |
| resetStaticProperties | | final public void resetStaticProperties()(Code) | | Reset the static properties. This should be done whenever the expression is changed in a way that might
affect the properties. It causes the properties to be recomputed next time they are needed.
|
| setLocationId | | public void setLocationId(int id)(Code) | | Set the location ID on an expression.
|
| simplify | | public Expression simplify(StaticContext env) throws XPathException(Code) | | Simplify an expression. This performs any static optimization (by rewriting the expression
as a different expression). The default implementation does nothing.
exception:
XPathException - if an error is discovered during expressionrewriting the simplified expression |
| suppressValidation | | public void suppressValidation(int validationMode)(Code) | | Suppress validation on contained element constructors, on the grounds that the parent element
is already performing validation. The default implementation does nothing.
|
|
|