| 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?".
|
| CastExpression |
Cast Expression: implements "cast as data-type ( expression )".
|
| CollationMap |
This object maps collation URIs to collations.
|
| CompareToIntegerConstant |
This class implements a comparison of a numeric value to an integer constant using one of the operators
eq, ne, lt, gt, le, ge.
|
| 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.
|
| ContextMappingIterator |
ContextMappingIterator merges a sequence of sequences into a single flat
sequence.
|
| CurrentItemExpression |
The expression is generated when compiling the current() function in XSLT.
|
| 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
|
| ItemMappingIterator |
ItemMappingIterator applies a mapping function to each item in a sequence.
|
| 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.
|
| LocalVariableReference |
Variable reference: a reference to a local variable.
|
| 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).
|
| TailCallLoop |
A TailCallLoop wraps the body of a function that contains tail-recursive function calls.
|
| 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.
|