|
||||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
Interface Summary | |
Binding | Binding is a interface used to represent the run-time properties and methods associated with a variable: specifically, methods to get the name, type, and value of the variable. |
BindingReference | BindingReference is a interface used to mark references to a variable declaration. |
Expression | Interface supported by an XPath expression. |
LastPositionFinder | A LastPositionFinder is an interface implemented by any SequenceIterator that is able to return the position of the last item in the sequence. |
MappingFunction | MappingFunction is an interface that must be satisfied by an object passed to a MappingIterator. |
ReversibleIterator | A ReversibleIterator is an interface implemented by any SequenceIterator that is able to deliver items in reverse order (or to supply another iterator that can do so). |
StaticContext | A StaticContext contains the information needed while an expression or pattern is being parsed. |
VariableDeclaration | Generic interface representing a variable declaration in the static context of an XPath expression. |
Class Summary | |
AppendExpression | An expression representing a sequence that is the concatenation of two given sequences. |
AppendExpression.AppendIterator | Iterator that concatenates the results of two supplied iterators |
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 |
AxisExpression | An AxisExpression is always obtained by simplifying a PathExpression. |
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 |
CastExpression | Cast Expression: implements "cast as data-type ( expression )". |
ComputedExpression | This class is an abstract superclass for different kinds of XPath expression. |
ContextItemExpression | This class represents the expression "(dot)", which always returns the context item. |
ConvertToString | A ConvertToString expression performs the string conversion required for string arguments in backwards compatibility mode. |
DifferenceEnumeration | An enumeration representing a nodeset that is teh difference of two other NodeSets. |
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. |
ExpressionParser | Parser for XPath expressions and XSLT patterns. |
ExpressionParser.ForClause | |
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 |
FunctionProxy | This class acts as a proxy for an extension function defined as a method in a user-defined class |
GeneralComparison | GeneralComparison: 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 |
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. |
MinimaxComparison | Class to handle many-to-many A less-than B comparisons by evaluating min(A) < max(B), and similarly for greater-than, etc. |
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. |
RangeExpression | A RangeExpression is an expression that represents an integer sequence as a pair of end-points (for example "x to y"). |
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. |
SingleNodeExpression | A node set expression that will always return zero or one nodes |
SingletonComparison | Class to handle comparisons of singletons. |
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 | |
Tokenizer | Tokenizer for expressions and inputs. |
TreatExpression | Treat Expression: implements "treat as data-type ( expression )". |
TypeChecker | This class provides Saxon's type checking capability. |
TypeExpression | TypeExpression: superclass for expressions involving a source expression and a type |
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, returning all other items unchanged |
UserFunctionCall | This class represents a call to a function defined in the stylesheet or query. |
UserFunctionCall.FunctionCallPackage | Inner class used to wrap up the set of actual arguments to a tail-recursive call of the containing function. |
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 |
XPathContext | This class represents a context in which an XPath expression is evaluated. |
This package provides classes associated with XPath expression handling. Generally, these
classes are not intended to be used directly by user-written applications; the API for XPath
evaluation is now provided by classes in the package net.sf.saxon.xpath
The principal classes are:
Expression:
This represents an XPath Expression. There is a static method Expression.make() which is
used to construct an Expression from a String (it is a factory method rather than a
constructor, because it typically returns some subclass of Expression according
to the syntax supplied). Subclasses of Expression represent different kinds of expression
such as StringExpression and BooleanExpression. What they all have in common is an evaluate()
method, which evaluates the expression in a given context to yield a Value, and an iterate() method,
which treats the result of the expression as a sequence, and iterates over the items in the sequence.
ExpressionParser:
This class does the work of parsing both Expressions and Patterns. Applications should not call
it directly. It uses the class Tokenizer for lexical analysis.
StaticContext:
This interface defines the information available at the time an expression is being parsed. This
includes the names of variables, the bindings of namespace prefixes, the functions that are available,
the names of collating sequences, and so on. When an XPath expression appears in a stylesheet, the
class net.sf.saxon.style.ExpressionContext
provides the StaticContext. For a free-standing XPath
expression, the class net.sf.saxon.xpath.StandaloneContext
is available, though a user-written
class that implements StaticContext
can also be used.
XPathContext:
This class defines the context information available at run-time, for example the context node, position,
and size. (It actually does this by wrapping a SequenceIterator that represents the current sequence.)
When expressions are used during an XSLT transformation, the XPathContext also provides access to the
Controller, which contains all the context information about XSLT processing (for example the current template,
the current group, and so on).
Michael H. Kay
25 April 2002
|
||||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |