Class Summary |
AppendIterator |
Iterator that concatenates the results of two supplied iterators |
ArithmeticExpression |
Arithmetic Expression: an expression using one of the operators
plus, minus, multiply, div, idiv, mod. |
ArithmeticExpression.DateAndDuration |
Inner class to handle addition or subtraction of a Date (or Time, or DateTime) and a Duration |
ArithmeticExpression.DateDifference |
Inner class to handle subtraction of a Date (or Time, or DateTime) from another, to return a Duration |
ArithmeticExpression.DurationAddition |
Inner class to handle addition and subtraction of two durations |
ArithmeticExpression.DurationDivision |
Inner class to handle division of two durations to give a number |
ArithmeticExpression.DurationMultiplication |
Inner class to handle multiplication (or division) of a duration by a number |
ArithmeticExpression.NumericArithmetic |
Inner class to handle numeric arithmetic expressions |
Assignation |
Assignation is an abstract superclass for the kinds of expression
that declare range variables: for, some, and every. |
AtomicSequenceConverter |
An AtomicSequenceConverter is an expression that performs a cast on each member of
a supplied sequence |
Atomizer |
An Atomizer is an expression corresponding essentially to the fn:data() function: it
maps a sequence by replacing nodes with their typed values |
Atomizer.AtomizingFunction |
Implement the mapping function. |
AxisExpression |
An AxisExpression is always obtained by simplifying a PathExpression. |
BinaryExpression |
Binary Expression: a numeric or boolean expression consisting of the
two operands and an operator |
BooleanExpression |
Boolean expression: two truth values combined using AND or OR. |
CardinalityChecker |
A CardinalityChecker implements the cardinality checking of "treat as": that is,
it returns the supplied sequence, checking that its cardinality is correct |
CastableExpression |
Castable Expression: implements "Expr castable as atomic-type?". |
CastAsQName |
This class supports casting a string to a QName or a notation. |
CastExpression |
Cast Expression: implements "cast as data-type ( expression )". |
ComputedExpression |
This class is an abstract superclass for different kinds of expression. |
ContextItemExpression |
This class represents the expression "(dot)", which always returns the context item. |
DifferenceEnumeration |
An enumeration representing a nodeset that is teh difference of two other NodeSets. |
EagerLetExpression |
An EagerLetExpression is the same as a LetExpression except that the variable is evaluated using
eager evaluation rather than lazy evaluation. |
EarlyEvaluationContext |
This class is an implementation of XPathContext used when evaluating constant sub-expressions at
compile time. |
ErrorExpression |
Error expression: this expression is generated when the supplied expression cannot be
parsed, and the containing element enables forwards-compatible processing. |
ExpressionLocation |
Class to hold details of the location of an expression, of an error in a source file, etc. |
ExpressionParser |
Parser for XPath expressions and XSLT patterns. |
ExpressionParser.ForClause |
|
ExpressionParser.TemporaryContainer |
|
ExpressionTool |
This class, ExpressionTool, contains a number of useful static methods
for manipulating expressions. |
FilterExpression |
A FilterExpression contains a base expression and a filter predicate, which may be an
integer expression (positional filter), or a boolean expression (qualifier) |
FilterIterator |
A FilterIterator filters an input sequence using a filter expression. |
FilterIterator.Leading |
Subclass to support the extension function saxon:leading, which terminates
the iteration at the first item whose predicate is false |
FilterIterator.NonNumeric |
Subclass to handle the common special case where it is statically known
that the filter cannot return a numeric value |
FirstItemExpression |
A FirstItemExpression returns the first item in the sequence returned by a given
base expression |
ForExpression |
A ForExpression maps an expression over a sequence. |
FunctionCall |
Abstract superclass for calls to system-defined and user-defined functions |
GeneralComparison |
GeneralComparison: a boolean expression that compares two expressions
for equals, not-equals, greater-than or less-than. |
GeneralComparison10 |
GeneralComparison10: a boolean expression that compares two expressions
for equals, not-equals, greater-than or less-than. |
IdentityComparison |
IdentityComparison: a boolean expression that compares two nodes
for equals, not-equals, greater-than or less-than based on identity and
document ordering |
IfExpression |
An IfExpression returns the value of either the "then" part or the "else" part,
depending on the value of the condition |
InstanceOfExpression |
InstanceOf Expression: implements "Expr instance of data-type" |
IntegerRangeTest |
An IntegerRangeTest is an expression of the form
E = N to M
where E, N, and M are all expressions of type integer. |
IntersectionEnumeration |
An enumeration representing a nodeset that is an intersection of two other NodeSets. |
IsLastExpression |
A position() eq last() expression, generated by the optimizer. |
ItemChecker |
A ItemChecker implements the item type checking of "treat as": that is,
it returns the supplied sequence, checking that all its items are of the correct type |
LazyExpression |
A LazyExpression is an expression that forces lazy evaluation: it must not be evaluated eagerly,
because a failure must not be reported unless the value is actually referenced. |
LetExpression |
A LetExpression is modelled on the XQuery syntax let $x := expr return expr. |
MappingIterator |
MappingIterator merges a sequence of sequences into a single flat
sequence. |
MonoIterator |
An iterator over a single object (typically a sub-expression of an expression) |
MultiIterator |
An iterator that combines the results of a sequence of iterators |
NumericPromoter |
A NumericPromoter performs numeric promotion on each item in a supplied sequence |
Optimizer |
This class doesn't actually do any optimization itself, despite the name. |
PairIterator |
An iterator over a pair of objects (typically sub-expressions of an expression) |
ParentNodeExpression |
Class ParentNodeExpression represents the XPath expression ".." or "parent::node()" |
PathExpression |
An expression that establishes a set of nodes by following relationships between nodes
in the document. |
PositionIterator |
A PositionIterator selects a subsequence of a sequence |
PositionRange |
PositionRange: a boolean expression that tests whether the position() is
within a certain range. |
PromotionOffer |
PromotionOffer is an object used transiently during compilation of an expression. |
QuantifiedExpression |
A QuantifiedExpression tests whether some/all items in a sequence satisfy
some condition. |
RangeExpression |
A RangeExpression is an expression that represents an integer sequence as
a pair of end-points (for example "x to y"). |
RangeIterator |
Iterator that produces numeric values in a monotonic sequence,
ascending or descending. |
RangeVariableDeclaration |
Represents the defining occurrence of a variable declared for local use
within an expression, for example the $x in "for $x in ...". |
RoleLocator |
A RoleLocator identifies the role in which an expression is used, for example as
the third argument of the concat() function. |
RootExpression |
An expression whose value is always a set of nodes containing a single node,
the document root. |
SimpleExpression |
An abstract implementation of Expression designed to make it easy to implement new expressions,
in particular, expressions to support extension instructions. |
SimpleMappingExpression |
A simple mapping expression is an expression A/B where B has a static type that is an atomic type. |
SingleNodeExpression |
A node set expression that will always return zero or one nodes |
SingletonAtomizer |
A SingletonAtomizer combines the functions of an Atomizer and a CardinalityChecker: it is used to
atomize a sequence of nodes, checking that the result of the atomization contains zero or one atomic
values. |
SingletonComparison |
Class to handle comparisons of singletons. |
SliceExpression |
A SliceExpression represents a FilterExpression of the form EXPR[position() > n and position() < m],
where n and m are not necessarily constants |
StackFrame |
This class represents a stack frame holding details of the variables used in a function or in
an XSLT template. |
StaticProperty |
This class contains constants identifying dependencies that an XPath expression
might have on its context. |
StringTokenIterator |
StringTokenIterator: breaks a string up into tokens,
and returns the tokens as a sequence of strings. |
SuppliedParameterReference |
Supplied parameter reference: this is an internal expression used to refer to
the value of the n'th parameter supplied on a template call (apply-templates). |
TailExpression |
A TailExpression represents a FilterExpression of the form EXPR[position() > n]
Here n is usually 2, but we allow other values |
TailExpression.TailIterator |
|
Token |
This class holds static constants and methods defining the lexical tokens used in
XPath and XQuery, and associated keywords. |
Tokenizer |
Tokenizer for expressions and inputs. |
TreatExpression |
Treat Expression: implements "treat as data-type ( expression )". |
TypeChecker |
This class provides Saxon's type checking capability. |
UnaryExpression |
Unary Expression: an expression taking a single operand expression |
UnionEnumeration |
An enumeration representing a nodeset that is a union of two other NodeSets. |
UntypedAtomicConverter |
An UntypedAtomicConverter is an expression that converts any untypedAtomic items in
a sequence to a specified type |
UserFunctionCall |
This class represents a call to a function defined in the stylesheet or query. |
ValueComparison |
ValueComparison: a boolean expression that compares two atomic values
for equals, not-equals, greater-than or less-than. |
VariableReference |
Variable reference: a reference to a variable. |
VennExpression |
An expression representing a nodeset that is a union, difference, or
intersection of two other NodeSets |
XPathContextMajor |
This class represents a "major context" in which an XPath expression is evaluated:
a "major context" object allows all aspects of the dynamic context to change, whereas
a "minor context" only allows changes to the focus and the destination for push output. |
XPathContextMajor.XSLTContext |
An XSLTContext object holds all the additional dynamic context items used in XSLT. |
XPathContextMinor |
This class represents a minor change in the dynamic context in which an XPath expression is evaluated:
a "major context" object allows all aspects of the dynamic context to change, whereas
a "minor context" only allows changes to the focus and the destination for push output. |