|
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. |