Package net.sf.saxon.expr


package net.sf.saxon.expr
  • Class
    Description
    Iterator that concatenates the results of two supplied iterators
    Arithmetic Expression: an expression using one of the operators plus, minus, multiply, div, idiv, mod.
    Inner class to handle addition or subtraction of a Date (or Time, or DateTime) and a Duration
    Inner class to handle subtraction of a Date (or Time, or DateTime) from another, to return a Duration
    Inner class to handle addition and subtraction of two durations
    Inner class to handle division of two durations to give a number
    Inner class to handle multiplication (or division) of a duration by a number
    Inner class to handle numeric arithmetic expressions
    Assignation is an abstract superclass for the kinds of expression that declare range variables: for, some, and every.
    An AtomicSequenceConverter is an expression that performs a cast on each member of a supplied sequence
    An Atomizer is an expression corresponding essentially to the fn:data() function: it maps a sequence by replacing nodes with their typed values
    Implement the mapping function.
    An AxisExpression is always obtained by simplifying a PathExpression.
    Binary Expression: a numeric or boolean expression consisting of the two operands and an operator
    Binding is a interface used to represent the run-time properties and methods associated with a variable: specifically, a method to get the value of the variable.
    BindingReference is a interface used to mark references to a variable declaration.
    Boolean expression: two truth values combined using AND or OR.
    A CardinalityChecker implements the cardinality checking of "treat as": that is, it returns the supplied sequence, checking that its cardinality is correct
    Castable Expression: implements "Expr castable as atomic-type?".
    Cast Expression: implements "cast as data-type ( expression )".
    This object maps collation URIs to collations.
    This class implements a comparison of a numeric value to an integer constant using one of the operators eq, ne, lt, gt, le, ge.
    Interface implemented by expressions that perform a comparison
    This class is an abstract superclass for different kinds of expression.
    A Container is something that can act as the parent of an expression.
    This class represents the expression "(dot)", which always returns the context item.
    ContextMappingFunction is an interface that must be satisfied by an object passed to a ContextMappingIterator.
    ContextMappingIterator merges a sequence of sequences into a single flat sequence.
    The expression is generated when compiling the current() function in XSLT.
    An enumeration representing a nodeset that is teh difference of two other NodeSets.
    An EagerLetExpression is the same as a LetExpression except that the variable is evaluated using eager evaluation rather than lazy evaluation.
    This class is an implementation of XPathContext used when evaluating constant sub-expressions at compile time.
    Error expression: this expression is generated when the supplied expression cannot be parsed, and the containing element enables forwards-compatible processing.
    Interface supported by an XPath expression.
    Class to hold details of the location of an expression, of an error in a source file, etc.
    Parser for XPath expressions and XSLT patterns.
     
     
    This class, ExpressionTool, contains a number of useful static methods for manipulating expressions.
    A FilterExpression contains a base expression and a filter predicate, which may be an integer expression (positional filter), or a boolean expression (qualifier)
    A FilterIterator filters an input sequence using a filter expression.
    Subclass to support the extension function saxon:leading, which terminates the iteration at the first item whose predicate is false
    Subclass to handle the common special case where it is statically known that the filter cannot return a numeric value
    A FirstItemExpression returns the first item in the sequence returned by a given base expression
    A ForExpression maps an expression over a sequence.
    Abstract superclass for calls to system-defined and user-defined functions
    GeneralComparison: a boolean expression that compares two expressions for equals, not-equals, greater-than or less-than.
    GeneralComparison10: a boolean expression that compares two expressions for equals, not-equals, greater-than or less-than.
    IdentityComparison: a boolean expression that compares two nodes for equals, not-equals, greater-than or less-than based on identity and document ordering
    An IfExpression returns the value of either the "then" part or the "else" part, depending on the value of the condition
    InstanceOf Expression: implements "Expr instance of data-type"
    An IntegerRangeTest is an expression of the form E = N to M where E, N, and M are all expressions of type integer.
    An enumeration representing a nodeset that is an intersection of two other NodeSets.
    A position() eq last() expression, generated by the optimizer.
    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
    ItemMappingFunction is an interface that must be satisfied by an object passed to a ItemMappingIterator.
    ItemMappingIterator applies a mapping function to each item in a sequence.
    A LastPositionFinder is an interface implemented by any SequenceIterator that is able to return the position of the last item in the sequence.
    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.
    A LetExpression is modelled on the XQuery syntax let $x := expr return expr.
    Variable reference: a reference to a local variable.
    MappingFunction is an interface that must be satisfied by an object passed to a MappingIterator.
    MappingIterator merges a sequence of sequences into a single flat sequence.
    An iterator over a single object (typically a sub-expression of an expression)
    An iterator that combines the results of a sequence of iterators
    A NumericPromoter performs numeric promotion on each item in a supplied sequence
    This class doesn't actually do any optimization itself, despite the name.
    An iterator over a pair of objects (typically sub-expressions of an expression)
    Class ParentNodeExpression represents the XPath expression ".." or "parent::node()"
    An expression that establishes a set of nodes by following relationships between nodes in the document.
    A PositionIterator selects a subsequence of a sequence
    PositionRange: a boolean expression that tests whether the position() is within a certain range.
    PromotionOffer is an object used transiently during compilation of an expression.
    A QuantifiedExpression tests whether some/all items in a sequence satisfy some condition.
    A RangeExpression is an expression that represents an integer sequence as a pair of end-points (for example "x to y").
    Iterator that produces numeric values in a monotonic sequence, ascending or descending.
    Represents the defining occurrence of a variable declared for local use within an expression, for example the $x in "for $x in ...".
    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).
    A RoleLocator identifies the role in which an expression is used, for example as the third argument of the concat() function.
    An expression whose value is always a set of nodes containing a single node, the document root.
    An abstract implementation of Expression designed to make it easy to implement new expressions, in particular, expressions to support extension instructions.
    A simple mapping expression is an expression A/B where B has a static type that is an atomic type.
    A node set expression that will always return zero or one nodes
    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.
    Class to handle comparisons of singletons.
    A SliceExpression represents a FilterExpression of the form EXPR[position() > n and position() invalid input: '<' m], where n and m are not necessarily constants
    This class represents a stack frame holding details of the variables used in a function or in an XSLT template.
    A StaticContext contains the information needed while an expression or pattern is being parsed.
    This class contains constants identifying dependencies that an XPath expression might have on its context.
    StringTokenIterator: breaks a string up into tokens, and returns the tokens as a sequence of strings.
    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).
    A TailCallLoop wraps the body of a function that contains tail-recursive function calls.
    A TailExpression represents a FilterExpression of the form EXPR[position() > n] Here n is usually 2, but we allow other values
     
    This class holds static constants and methods defining the lexical tokens used in XPath and XQuery, and associated keywords.
    Tokenizer for expressions and inputs.
    Treat Expression: implements "treat as data-type ( expression )".
    This class provides Saxon's type checking capability.
    Unary Expression: an expression taking a single operand expression
    An enumeration representing a nodeset that is a union of two other NodeSets.
    An UntypedAtomicConverter is an expression that converts any untypedAtomic items in a sequence to a specified type
    This class represents a call to a function defined in the stylesheet or query.
    ValueComparison: a boolean expression that compares two atomic values for equals, not-equals, greater-than or less-than.
    Generic interface representing a variable declaration in the static context of an XPath expression.
    Variable reference: a reference to a variable.
    An expression representing a nodeset that is a union, difference, or intersection of two other NodeSets
    This class represents a context in which an XPath expression is evaluated.
    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.
    An XSLTContext object holds all the additional dynamic context items used in XSLT.
    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.