net.sf.saxon.expr

Class Literal

Implemented Interfaces:
EvaluableItem, InstructionInfoProvider, SequenceIterable, Serializable, SourceLocator
Known Direct Subclasses:
StringLiteral

public class Literal
extends Expression

A Literal is an expression whose value is constant: it is a class that implements the Expression interface as a wrapper around a Value. This may derive from an actual literal in an XPath expression or query, or it may be the result of evaluating a constant subexpression such as true() or xs:date('2007-01-16')

Field Summary

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

EVALUATE_METHOD, ITERATE_METHOD, PROCESS_METHOD, locationId, staticProperties

Constructor Summary

Literal(Value value)
Create a literal as a wrapper around a Value

Method Summary

PathMap.PathMapNodeSet
addToPathMap(PathMap pathMap, PathMap.PathMapNodeSet pathMapNodeSet)
Add a representation of this expression to a PathMap.
int
computeCardinality()
Determine the cardinality
int
computeSpecialProperties()
Compute the static properties of this expression (other than its type).
Expression
copy()
Copy an expression.
boolean
effectiveBooleanValue(XPathContext context)
Get the effective boolean value of the expression.
boolean
equals(Object obj)
Determine whether two literals are equal, when considered as expressions.
CharSequence
evaluateAsString(XPathContext context)
Evaluate an expression as a String.
Item
evaluateItem(XPathContext context)
Evaluate as a singleton item (or empty sequence).
void
explain(ExpressionPresenter out)
Diagnostic print of expression structure.
int
getDependencies()
Determine which aspects of the context the expression depends on.
ItemType
getItemType(TypeHierarchy th)
Determine the data type of the items in the expression, if possible
Value
getValue()
Get the value represented by this Literal
int
hashCode()
Return a hash code to support the equals() function
static boolean
isAtomic(Expression exp)
Test whether the literal wraps an atomic value.
static boolean
isConstantBoolean(Expression exp, boolean value)
Test if a literal represents the boolean value true
static boolean
isConstantOne(Expression exp)
Test if a literal represents the integer value 1
static boolean
isEmptySequence(Expression exp)
Test whether the literal explicitly wraps an empty sequence.
SequenceIterator
iterate(XPathContext context)
Return an Iterator to iterate over the values of a sequence.
static Literal
makeEmptySequence()
Make an empty-sequence literal
static Literal
makeLiteral(Value value)
Create a literal as a wrapper around a Value (factory method)
Expression
optimize(ExpressionVisitor visitor, ItemType contextItemType)
Optimize an expression
void
process(XPathContext context)
Process the value as an instruction, without returning any tail calls
Expression
simplify(ExpressionVisitor visitor)
Simplify an expression
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.
Expression
typeCheck(ExpressionVisitor visitor, ItemType contextItemType)
TypeCheck an expression

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

Constructor Details

Literal

public Literal(Value value)
Create a literal as a wrapper around a Value
Parameters:
value - the value of this literal

Method Details

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.
Overrides:
addToPathMap in interface Expression
Parameters:
pathMap - the PathMap to which the expression should be added
pathMapNodeSet -
Returns:
the pathMapNode representing the focus established by this expression, in the case where this expression is the first operand of a path expression or filter expression

computeCardinality

public int computeCardinality()
Determine the cardinality
Overrides:
computeCardinality in interface Expression

computeSpecialProperties

public int computeSpecialProperties()
Overrides:
computeSpecialProperties in interface Expression
Returns:
the value StaticProperty.NON_CREATIVE

copy

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

effectiveBooleanValue

public boolean effectiveBooleanValue(XPathContext context)
            throws XPathException
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.
Overrides:
effectiveBooleanValue in interface Expression
Parameters:
context - The context in which the expression is to be evaluated
Returns:
the effective boolean value
Throws:
XPathException - if any dynamic error occurs evaluating the expression

equals

public boolean equals(Object obj)
Determine whether two literals are equal, when considered as expressions.
Parameters:
obj - the other expression
Returns:
true if the two literals are equal

evaluateAsString

public CharSequence evaluateAsString(XPathContext context)
            throws XPathException
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.
Overrides:
evaluateAsString in interface Expression
Parameters:
context - The context in which the expression is to be evaluated
Returns:
the value of the expression, evaluated in the current context. The expression must return a string or (); if the value of the expression is (), this method returns "".
Throws:
XPathException - if any dynamic error occurs evaluating the expression

evaluateItem

public Item evaluateItem(XPathContext context)
            throws XPathException
Evaluate as a singleton item (or empty sequence). Note: this implementation returns the first item in the sequence. The method should not be used unless appropriate type-checking has been done to ensure that the value will be a singleton.
Specified by:
evaluateItem in interface EvaluableItem
Overrides:
evaluateItem in interface Expression

explain

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

getDependencies

public final int getDependencies()
Determine which aspects of the context the expression depends on. The result is a bitwise-or'ed value composed from constants such as StaticProperty.VARIABLES and StaticProperty.CURRENT_NODE
Overrides:
getDependencies in interface Expression
Returns:
for a Value, this always returns zero.

getItemType

public ItemType getItemType(TypeHierarchy th)
Determine the data type of the items in the expression, if possible
Overrides:
getItemType in interface Expression
Parameters:
th - The TypeHierarchy. Can be null if the target is an AtomicValue.
Returns:
for the default implementation: AnyItemType (not known)

getValue

public Value getValue()
Get the value represented by this Literal
Returns:
the constant value

hashCode

public int hashCode()
Return a hash code to support the equals() function

isAtomic

public static boolean isAtomic(Expression exp)
Test whether the literal wraps an atomic value. (Note, if this method returns false, this still leaves the possibility that the literal wraps a sequence that happens to contain a single atomic value).
Parameters:
exp - an expression
Returns:
if the expression is a literal and the literal wraps an AtomicValue

isConstantBoolean

public static boolean isConstantBoolean(Expression exp,
                                        boolean value)
Test if a literal represents the boolean value true
Parameters:
exp - an expression
value - true or false
Returns:
if the expression is a literal and the literal represents the boolean value given in the second argument

isConstantOne

public static boolean isConstantOne(Expression exp)
Test if a literal represents the integer value 1
Parameters:
exp - an expression
Returns:
if the expression is a literal and the literal represents the integer value 1

isEmptySequence

public static boolean isEmptySequence(Expression exp)
Test whether the literal explicitly wraps an empty sequence. (Note, if this method returns false, this still leaves the possibility that the literal wraps a sequence that happens to be empty).
Parameters:
exp - an expression
Returns:
if the expression is a literal and the literal wraps an AtomicValue

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

makeEmptySequence

public static Literal makeEmptySequence()
Make an empty-sequence literal
Returns:
a literal whose value is the empty sequence

makeLiteral

public static Literal makeLiteral(Value value)
Create a literal as a wrapper around a Value (factory method)
Parameters:
value - the value of this literal
Returns:
the Literal

optimize

public final Expression optimize(ExpressionVisitor visitor,
                                 ItemType contextItemType)
Optimize an expression
Overrides:
optimize in interface Expression
Returns:
for a Value, this always returns the value unchanged

process

public void process(XPathContext context)
            throws XPathException
Process the value as an 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.

simplify

public final Expression simplify(ExpressionVisitor visitor)
Simplify an expression
Overrides:
simplify in interface Expression
Parameters:
visitor - an expression visitor
Returns:
for a Value, this always returns the value unchanged

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
Overrides:
toString in interface Expression

typeCheck

public final Expression typeCheck(ExpressionVisitor visitor,
                                  ItemType contextItemType)
TypeCheck an expression
Overrides:
typeCheck in interface Expression
Returns:
for a Value, this always returns the value unchanged