net.sf.saxon.expr

Class VariableReference

public class VariableReference extends Expression implements BindingReference

Variable reference: a reference to a variable. This may be an XSLT-defined variable, a range variable defined within the XPath expression, or a variable defined in some other static context.
Field Summary
protected Bindingbinding
protected ValueconstantValue
StringdisplayName
protected SequenceTypestaticType
Constructor Summary
VariableReference()
Create a Variable Reference
VariableReference(Binding binding)
Create a Variable Reference
Method Summary
PathMap.PathMapNodeSetaddToPathMap(PathMap pathMap, PathMap.PathMapNodeSet pathMapNodeSet)
Add a representation of this expression to a PathMap.
intcomputeCardinality()
Get the static cardinality
intcomputeSpecialProperties()
Determine the special properties of this expression
Expressioncopy()
Create a clone copy of this VariableReference
booleanequals(Object other)
Test if this expression is the same as another expression.
ItemevaluateItem(XPathContext c)
ValueRepresentationevaluateVariable(XPathContext c)
Evaluate this variable
voidexplain(ExpressionPresenter destination)
Diagnostic print of expression structure.
voidfixup(Binding binding)
Fix up this variable reference to a Binding object, which enables the value of the variable to be located at run-time.
BindinggetBinding()
Get the object bound to the variable
StringgetDisplayName()
Get the display name of the variable.
intgetImplementationMethod()
An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process().
intgetIntrinsicDependencies()
ItemTypegetItemType(TypeHierarchy th)
Determine the data type of the expression, if possible
inthashCode()
get HashCode for comparing two expressions
booleanisFiltered()
Determine whether this variable reference is filtered
booleanisFlattened()
Test whether this variable reference is flattened - that is, whether it is atomized etc
booleanisInLoop()
Determine whether this variable reference appears in a loop relative to its declaration.
SequenceIteratoriterate(XPathContext c)
Get the value of this variable in a given context.
Expressionoptimize(ExpressionVisitor visitor, ItemType contextItemType)
Type-check the expression.
voidprocess(XPathContext c)
Expressionpromote(PromotionOffer offer, Expression parent)
Promote this expression if possible
voidrefineVariableType(ItemType type, int cardinality, Value constantValue, int properties, ExpressionVisitor visitor)
Provide additional information about the type of the variable, typically derived by analyzing the initializer of the variable binding
voidsetFiltered(boolean filtered)
Mark an expression as filtered: that is, it appears as the base expression in a filter expression.
voidsetFlattened(boolean flattened)
Mark an expression as being "flattened".
voidsetStaticType(SequenceType type, Value value, int properties)
Set static type.
StringtoString()
The toString() method for an expression attempts to give a representation of the expression in an XPath-like form, but there is no guarantee that the syntax will actually be true XPath.
ExpressiontypeCheck(ExpressionVisitor visitor, ItemType contextItemType)
Type-check the expression.

Field Detail

binding

protected Binding binding

constantValue

protected Value constantValue

displayName

transient String displayName

staticType

protected SequenceType staticType

Constructor Detail

VariableReference

public VariableReference()
Create a Variable Reference

VariableReference

public VariableReference(Binding binding)
Create a Variable Reference

Parameters: binding the variable binding to which this variable refers

Method Detail

addToPathMap

public PathMap.PathMapNodeSet addToPathMap(PathMap pathMap, PathMap.PathMapNodeSet pathMapNodeSet)
Add a representation of this expression to a PathMap. The PathMap captures a map of the nodes visited by an expression in a source tree.

The default implementation of this method assumes that an expression does no navigation other than the navigation done by evaluating its subexpressions, and that the subexpressions are evaluated in the same context as the containing expression. The method must be overridden for any expression where these assumptions do not hold. For example, implementations exist for AxisExpression, ParentExpression, and RootExpression (because they perform navigation), and for the doc(), document(), and collection() functions because they create a new navigation root. Implementations also exist for PathExpression and FilterExpression because they have subexpressions that are evaluated in a different context from the calling expression.

Parameters: pathMap the PathMap to which the expression should be added pathMapNodeSet the PathMapNodeSet to which the paths embodied in this expression should be added

Returns: the pathMapNodeSet representing the points in the source document that are both reachable by this expression, and that represent possible results of this expression. For an expression that does navigation, it represents the end of the arc in the path map that describes the navigation route. For other expressions, it is the same as the input pathMapNode.

computeCardinality

public int computeCardinality()
Get the static cardinality

computeSpecialProperties

public int computeSpecialProperties()
Determine the special properties of this expression

Returns: NON_CREATIVE (unless the variable is assignable using saxon:assign)

copy

public Expression copy()
Create a clone copy of this VariableReference

Returns: the cloned copy

equals

public boolean equals(Object other)
Test if this expression is the same as another expression. (Note, we only compare expressions that have the same static and dynamic context).

evaluateItem

public Item evaluateItem(XPathContext c)

evaluateVariable

public ValueRepresentation evaluateVariable(XPathContext c)
Evaluate this variable

Parameters: c the XPath dynamic context

Returns: the value of the variable

Throws: XPathException if any error occurs

explain

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

fixup

public void fixup(Binding binding)
Fix up this variable reference to a Binding object, which enables the value of the variable to be located at run-time.

getBinding

public Binding getBinding()
Get the object bound to the variable

Returns: the Binding which declares this variable and associates it with a value

getDisplayName

public String getDisplayName()
Get the display name of the variable. This is taken from the variable binding if possible

Returns: the display name (a lexical QName

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. This implementation provides both all three methods natively.

getIntrinsicDependencies

public int getIntrinsicDependencies()

getItemType

public ItemType getItemType(TypeHierarchy th)
Determine the data type of the expression, if possible

Parameters: th the type hierarchy cache

Returns: the type of the variable, if this can be determined statically; otherwise Type.ITEM (meaning not known in advance)

hashCode

public int hashCode()
get HashCode for comparing two expressions

isFiltered

public boolean isFiltered()
Determine whether this variable reference is filtered

Returns: true if the value of the variable is filtered by a predicate

isFlattened

public boolean isFlattened()
Test whether this variable reference is flattened - that is, whether it is atomized etc

Returns: true if the value of the variable is atomized, or converted to a string or number

isInLoop

public boolean isInLoop()
Determine whether this variable reference appears in a loop relative to its declaration. By default, when in doubt, returns true. This is calculated during type-checking.

Returns: true if this variable reference occurs in a loop, where the variable declaration is outside the loop

iterate

public SequenceIterator iterate(XPathContext c)
Get the value of this variable in a given context.

Parameters: c the XPathContext which contains the relevant variable bindings

Returns: the value of the variable, if it is defined

Throws: XPathException if the variable is undefined

optimize

public Expression optimize(ExpressionVisitor visitor, ItemType contextItemType)
Type-check the expression. At this stage details of the static type must be known. If the variable has a compile-time value, this is substituted for the variable reference

process

public void process(XPathContext c)

promote

public Expression promote(PromotionOffer offer, Expression parent)
Promote this expression if possible

refineVariableType

public void refineVariableType(ItemType type, int cardinality, Value constantValue, int properties, ExpressionVisitor visitor)
Provide additional information about the type of the variable, typically derived by analyzing the initializer of the variable binding

Parameters: type the item type of the variable cardinality the cardinality of the variable constantValue the actual value of the variable, if this is known statically, otherwise null properties additional static properties of the variable's initializer visitor an ExpressionVisitor

setFiltered

public void setFiltered(boolean filtered)
Mark an expression as filtered: that is, it appears as the base expression in a filter expression. This notification currently has no effect except when the expression is a variable reference.

setFlattened

public void setFlattened(boolean flattened)
Mark an expression as being "flattened". This is a collective term that includes extracting the string value or typed value, or operations such as simple value construction that concatenate text nodes before atomizing. The implication of all of these is that although the expression might return nodes, the identity of the nodes has no significance. This is called during type checking of the parent expression. At present, only variable references take any notice of this notification.

setStaticType

public void setStaticType(SequenceType type, Value value, int properties)
Set static type. This is a callback from the variable declaration object. As well as supplying the static type, it may also supply a compile-time value for the variable. As well as the type information, other static properties of the value are supplied: for example, whether the value is an ordered node-set.

Parameters: type the static type of the variable value the value of the variable if this is a compile-time constant properties static properties of the expression to which the variable is bound

toString

public String toString()
The toString() method for an expression attempts to give a representation of the expression in an XPath-like form, but there is no guarantee that the syntax will actually be true XPath. In the case of XSLT instructions, the toString() method gives an abstracted view of the syntax

typeCheck

public Expression typeCheck(ExpressionVisitor visitor, ItemType contextItemType)
Type-check the expression. At this stage details of the static type must be known. If the variable has a compile-time value, this is substituted for the variable reference