All Classes and Interfaces
Class
Description
This class implements the fn:abs() function
This element is a surrogate for an extension element (or indeed an xsl element)
for which no implementation is available.
Represents the path from the root of an XDM tree to a specific node, as a sequence of (name, position) pairs
Inner class representing one step in the path
An abstract implementation of XDM array items, containing methods that can be implemented generically.
Iterate over the instructions in a sequence of instructions (or an XPath comma expression),
concatenating the result of each instruction into a single combined sequence.
An abstract class providing reusable code for implementing the
Destination interfaceAbstract superclass (and factory class) for implementations of Function
A node in the XML parse tree representing an XML element, character content, or attribute.
Class AbstractNumberer is a base implementation of Numberer that provides language-independent
default numbering
This supports the xsl:number element.
AbstractCollection is an abstract superclass for the various implementations
of ResourceCollection within Saxon.
Information about a resource
An abstract and configurable implementation of the StaticContext interface,
which defines the static context of an XPath expression.
Interface defining a callback for handling warnings
This is the standard trace listener used when the -T option is specified on the command line.
Saxon implementation of the JAXP Transformer interface.
This abstract implementation of UniStringConsumer exists largely for C#, as a place to
capture the default methods defined in the interface, and avoid them proliferating into
multiple subclasses
AbstractVirtualNode is an abstract superclass for VirtualNode implementations in which
the underlying node is itself a Saxon NodeInfo.
AbstractFilterImpl is skeletal implementation of the SAX XMLFilter interface, used
for both streaming and non-streaming filters.
A class that exists to contain common code shared between XsltTransformer and Xslt30Transformer
This class supports the get_X_from_Y functions defined in XPath 2.0
Elaborator for accessor functions such as hours-from-date-Time, minutes-from-duration
Represents a single accumulator declared in an XSLT 3.0 stylesheet
Holds the values of an accumulator function for one non-streamed document
Non-streaming implementation of accumulator-before() and accumulator-after()
Manager for accumulator functions (XSLT 3.0).
Static registry for accumulators (XSLT 3.0) defined within a single package.
This class represents one of the rules making up the definition of an accumulator
A functional interface that simply encapsulates a callback action of any kind,
allowing the action to fail with an XPathException.
A completely general functional interface for functions that take
no arguments, return void, and potentially throw a
SaxonApiException.An extension of
DOMSource that implements the ActiveSource interface,
so it knows how to send itself to a ReceiverThis class extends the standard SAXSource class by providing a
ActiveSAXSource.deliver(Receiver, ParseOptions)
method, meaning that Saxon can treat it just like any other ActiveSource implementation.An ActiveSource is a Source that is capable of delivering an XML document to a Receiver;
An extension of StAXSource that makes the source active: that is, able
to deliver itself to a Saxon
Receiver.An extension of the
StreamSource object providing a ActiveStreamSource.deliver(Receiver, ParseOptions) method
so that the contents of the source can be delivered to a supplied ReceiverThis object represents the compiled form of a user-written function, template, attribute-set, etc
(the source can be either an XSLT stylesheet function or an XQuery function).
This class implements the Adaptive serialization method defined in XSLT+XQuery Serialization 3.1.
This class performs the first phase of processing in "constructing simple content":
it takes an input sequence, eliminates empty text nodes, and combines adjacent text nodes
into one.
Elaborator for an adjacent text node merging expression - inserted into a pipeline for node construction
AdjacentTextNodeMergingIterator is an iterator that eliminates zero-length text nodes
and merges adjacent text nodes from the underlying iterator
This class implements the XPath 2.0 functions
adjust-date-to-timezone(), adjust-time-timezone(), and adjust-dateTime-timezone(),
with a single argument
This class implements the XPath 2.0 functions
adjust-date-to-timezone(), adjust-time-timezone(), and adjust-dateTime-timezone(),
with two arguments
A set of constants enumerating the possible relationships between one type and another
This abstract class provides functionality common to the sum(), avg(), count(),
exists(), and empty() functions.
A whitespace stripping rule that strips all elements unless xml:space indicates that whitespace
should be preserved.
An AlphaCode is a compact, context-independent string representation of a SequenceType
This class contains static utility methods to test whether a character is alphanumeric, as defined
by the rules of xsl:number: that is, whether it is in one of the Unicode categories
Nd, Nl, No, Lu, Ll, Lt, Lm or Lo
In Saxon 9.9 the data has been regenerated from Unicode 10.0.0.
A Comparer that treats strings as an alternating sequence of alpha parts and numeric parts.
An xsl:analyze-string element in the stylesheet.
Implements the fn:analyze-string function defined in XPath 3.0.
This class enumerates the ancestor:: or ancestor-or-self:: axes,
starting at a given node.
An AncestorQualifiedPattern represents a path of the form A/B or A//B, where nodes must match the
pattern B and also have a parent/ancestor (respectively) that matches A.
This is a special pattern that matches the "anchor node".
Elaborator for an AndExpression (P and Q)
This class represents an annotation that appears in a function or variable declarations
An immutable list of function or variable annotations, or of annotation assertions
An external object is a fourth kind of Item (after nodes, atomic values, and functions):
it acts as a wrapper for a Java object (or, in C#, a .NET object).
This class represents the type of an external object returned by
an extension function, or supplied as an external variable/parameter.
An ItemType representing the type function(*).
The item type function(*) when it is preceded by one or more annotation assertions
An implementation of ItemType that matches any item (node or atomic value)
NodeTest is an interface that enables a test of whether a node has a particular
name and type.
This class has a singleton instance which represents the XML Schema built-in type xs:anySimpleType
This class has a singleton instance which represents the XML Schema built-in type xs:anyType,
also known as the urtype.
An XPath value of type xs:anyURI.
This class implements the function fn:apply(), which is a standard function in XQuery 3.1.
An xsl:apply-imports element in the stylesheet.
An xsl:apply-imports or xsl:next-match element in the stylesheet.
An instruction representing an xsl:apply-templates element in the stylesheet
An ApplyTemplatesPackage is an object that encapsulates the sequence of nodes to be processed,
the mode, the parameters to be supplied, and the execution context.
Class ARegexIterator - provides an iterator over matched and unmatched substrings.
Glue class to interface the Jakarta regex engine to Saxon
(The prefix 'A' indicates an Apache regular expression, as distinct from
a JDK regular expression).
Arithmetic Expression: an expression using one of the operators
plus, minus, multiply, div, idiv, mod.
Elaborator for an ArithmeticExpression (for example P + Q)
Arithmetic Expression: an expression using one of the operators
plus, minus, multiply, div, idiv, mod, in backwards
compatibility mode: see
ArithmeticExpression for the non-backwards
compatible case.Function signatures (and pointers to implementations) of the functions defined in XPath 3.1
Implementation of the function array:append(array, item()*) => array
Implementation of the proposed 4.0 function array:empty(array)
Implementation of the proposed 4.0 function array:exists(array)
Implementation of the function array:filter(array, function) => array
Implementation of the function array:flatten => item()*
Implementation of the function array:fold-left(array, item()*, function) => array
Implementation of the function array:fold-left(array, item()*, function) => array
Implementation of the proposed 4.0 function array:foot(array) => item()*
Implementation of the function array:for-each(array, function) => array
Implementation of the function array:for-each-pair(array, array, function) => array
Implementation of the function array:_from-sequence(item()*) => array(*) which
is used internally for the implementation of array{} and of the saxon:array extension
Abstract superclass for functions that produce an array, and that decide what kind of array implementation
to use based on past experience.
Implementation of the function array:get(array, xs:integer) => item()*
Implementation of the function array:head(array) => item()*
Implementation of the function array:insert-before(array, xs:integer, item()*) => array
Implementation of the function array:join(arrays) => array
Implementation of the function array:put(arrays, index, newValue) => array
Implementation of the function array:remove(array, xs:integer) => array
Implementation of the function array:replace(array, position, action) => array
Implementation of the function array:reverse(array, xs:integer, xs:integer) => array
Implementation of the function array:size(array) => integer
Implementation of the function array:subarray(array, xs:integer, xs:integer) => array
Implementation of the function array:tail(array) => item()*
Implementation of the function array:_to-sequence(array) => item()* which
is used internally for the implementation of array?*
Interface supported by different implementations of an XDM array item.
An instance of this class represents a specific array item type, for example
function(xs:int) as xs:boolean
ArrayIterator is used to enumerate items held in a Java array.
Parameterised subclass to accept items of a particular item type
ArrayIterator.OfNodes is a subclass of ArrayIterator where the array always
contains Nodes; it therefore implements the AxisIterator interface.
Implementation of the extension function array:sort(array, function) => array
An Iterator that produces numeric values in a monotonic sequence,
ascending or descending.
This class defines properties of the US-ASCII character set
Assignation is an abstract superclass for the kinds of expression
that declare range variables: for, some, and every.
A ATokenIterator is an iterator over the strings that result from tokenizing a string using a regular expression
A sequence of atomic values, implemented using an underlying arrayList.
Interface representing an object that can be used to compare two XPath atomic values for equality or
for ordering.
A function item representing a constructor function for an atomic type.
An integer that can be incremented atomically with thread safety
Implements the XPath 4.0 fn:atomic-equal() function.
A SequenceIterator is used to iterate over a sequence.
Marker interface to identify an object that acts as a surrogate for an atomic value, with the property
that if two atomic values are equal under the XPath 'eq' operator, then their corresponding surrogates
are equal under the Java equals() comparison (and by implication, they have equal hash codes).
Interface representing a sequence of atomic values.
An AtomicSequenceConverter is an expression that performs a cast (or other supplied conversion)
on each member of a supplied sequence
Elaborator for an AtomicSequenceConverter (including an UntypedAtomicConverter, which is
the same except that it uses a different converter internally)
Mapping function wrapped around a converter
Mapping function that converts every item in a sequence to a string
An AtomicComparer used for comparing atomic values of arbitrary item types.
Interface for atomic types (these are either built-in atomic types
or user-defined atomic types).
The AtomicValue class corresponds to the concept of an atomic value in the
XPath 2.0 data model.
Interface implemented by an iterator that can deliver atomized results.
An Atomizer is an expression corresponding essentially to the fn:data() function: it
maps a sequence by replacing nodes with their typed values
Elaborator for an Atomizer
AtomizingIterator returns the atomization of an underlying sequence supplied
as an iterator.
AttributeAxisIterator is an enumeration of all the attribute nodes of an Element.
AttributeCollectionImpl is an implementation of the SAX2 interface Attributes.
Abstract class for fixed and computed attribute constructor expressions
An AttributeGetter is an expression that returns the value of a specific attribute
of the context item, provided that it is an untyped element node.
Elaborator for an AttributeGetter expression (which gets a named attribute of the context item
and returns its value as an untyped atomic value)
A node in the "linked" tree representing an attribute.
This class contains immutable information about an attribute.
AttributeInfo.Deleted is a subclass used to mark a deleted attribute (in XQuery Update)
AttributeIterator is an iterator over all the attribute nodes of an Element in the TinyTree.
A Location corresponding to an attribute in a document (often a stylesheet)
AttributeMap represents an immutable collection of attributes available on a particular element
node.
An implementation of AttributeMap suitable for representing attributes on a mutable tree.
The compiled form of an xsl:attribute-set element in the stylesheet.
This class represents an attribute value template.
This class is an implementation of the DOM Attr class that wraps a Saxon NodeInfo
representation of an attribute or namespace node.
This class is an extension of the JAXP Source interface.
Implementation of the fn:avg function
This is an enumeration class containing constants representing the thirteen XPath axes
This iterator returns a sequence of atomic values, the result of atomizing the sequence
of nodes returned by an underlying SequenceIterator.
An AxisExpression is always obtained by simplifying a PathExpression.
Elaborator for an AxisExpression
An axis, that is a direction of navigation in the document structure.
A SequenceIterator is used to iterate over a sequence of items.
An AxisStep is a
Step that implements one of the 13 XPath Axes.A value of type xs:base64Binary
Class for handling patterns with simple non-positional boolean predicates
This class implements the fn:base-uri() function in XPath 2.0
Elaborator for simple string-valued properties of nodes such as name(), local-name(), namespace-uri(),
and generate-id()
A TransformerFactory instance can be used to create Transformer and Template
objects.
An implementation class for decimal values other than integers
An integer value: note this is a subtype of decimal in XML Schema, not a primitive type.
An Iterator that produces numeric values in a monotonic ascending or descending sequence,
where the integers may exceed the range of a Long
Binary Expression: a numeric or boolean expression consisting of the
two operands and an operator
A binary resource that might appear in a resource collection.
This class generates decodes processing instructions in text output that represent text encoded
in base64 binary or hexBinary
The Bindery class holds information about variables and their values.
A value that can be saved in a global variable to indicate that evaluation failed, and that
subsequent attempts at evaluation should also fail
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.
An expression that delivers the concatenation of the results of its subexpressions.
Elaborator for a "Block", which is typically either an XPath sequence expression (a, b, c)
or an XSLT sequence constructor
Iterate over the instructions in a sequence of instructions (or an XPath comma expression),
concatenating the result of each instruction into a single combined sequence.
An implementation of
UnicodeString that wraps a Java string which is known to contain
no surrogates.Abstract superclass for elaborators whose primary evaluation method is to return a single boolean.
Interface implemented by expressions that return a boolean result.
Boolean expression: two truth values combined using AND or OR.
A BooleanExpressionPattern is a pattern of the form .[ Expr ] introduced in XSLT 3.0.
This class supports the XPath function boolean()
A boolean XPath value
A compiled xsl:break instruction.
The abstract Builder class is responsible for taking a stream of SAX events
and constructing a Document tree.
A BuilderMonitor can be inserted into a pipeline immediately in front of a Builder.
A SAX
ContentHandler that builds a Saxon tree, and allows the node at the root of the tree
to be retrieved on completion.A BuildingStreamWriter allows a document to be constructed by calling the methods defined in the
XMLStreamWriter interface; after the document has been constructed, its root
node may be retrieved by calling the getDocumentNode() method.This class is an implementation of
XMLStreamWriter, allowing
a document to be constructed by means of a series of XMLStreamWriter method calls such
as writeStartElement(), writeAttribute(), writeCharacters(), and writeEndElement().This class represents a built-in atomic type, which may be either a primitive type
(such as xs:decimal or xs:anyURI) or a derived type (such as xs:ID or xs:dayTimeDuration).
This class is used to contain information about a set of built-in functions.
An entry in the table describing the properties of a function
This class is used to implement the built-in
list types NMTOKENS, ENTITIES, IDREFS.
Enumeration representing the permitted values of
xsl:mode/@on-no-match, decomposed into more
primitive actionsDefines a set of built-in template rules (rules for use when no user-defined template
rules match a given node)
This non-instantiable class acts as a register of Schema objects containing all the built-in types:
that is, the types defined in the "xs" namespace.
This class evaluates arithmetic expressions; it acts as a helper class to the ArithmeticExpression
class.
Arithmetic: anyAtomicType div AnyAtomicType
Arithmetic: anyAtomicType idiv AnyAtomicType
Arithmetic: anyAtomicType - AnyAtomicType
Arithmetic: anyAtomicType mod AnyAtomicType
Arithmetic: anyAtomicType + AnyAtomicType
Arithmetic: anyAtomicType * AnyAtomicType
Arithmetic: decimal div decimal (including types that promote to decimal, that is, integer)
Arithmetic: decimal idiv decimal (including types that promote to decimal, that is, integer)
Arithmetic: decimal - decimal (including types that promote to decimal, that is, integer)
Arithmetic: decimal mod decimal (including types that promote to decimal, that is, integer)
Arithmetic: decimal + decimal (including types that promote to decimal, that is, integer)
Arithmetic: decimal * decimal (including types that promote to decimal, that is, integer)
Arithmetic: double div double (including types that promote to double)
Arithmetic: double - double (including types that promote to double)
Arithmetic: double mod double (including types that promote to double)
Marker interface for operations on doubles
Arithmetic: double + double (including types that promote to double)
Arithmetic: double * double (including types that promote to double)
Arithmetic: float div float (including types that promote to float)
Arithmetic: float idiv float (including types that promote to float)
Arithmetic: float - float (including types that promote to float)
Arithmetic: float mod float (including types that promote to float)
Arithmetic: float + float (including types that promote to float)
Arithmetic: float * float (including types that promote to float)
Arithmetic: integer div integer
Arithmetic: integer idiv integer
Arithmetic: integer - integer
Arithmetic: integer mod integer
Arithmetic: integer + integer
Arithmetic: integer * integer
Abstract superclass for Date, Time, and DateTime.
A comparer specifically for comparing two date, time, or dateTime values
A generic interface for calling expressions by supplying the values of their subexpressions
An implementation of
Callable that allows the logic to be supplied as a lambda expression.A function item that wraps a Callable
A Callable that wraps another Callable and a Dynamic Context, in effect acting as a closure that
executes the original callable with a saved context.
Instruction representing an xsl:call-template element in the stylesheet.
A CallTemplatePackage is an object that encapsulates the name of a template to be called,
the parameters to be supplied, and the execution context.
Represents a match of a captured subgroup
This class contains static methods to manipulate the cardinality
property of a type.
A CardinalityChecker implements the cardinality checking of "treat as": that is,
it returns the supplied sequence, checking that its cardinality is correct
Elaborator for a
treat as expression, which is usually system-generated by
the type checking phase of the compilerCardinalityCheckingIterator returns the items in an underlying sequence
unchanged, but checks that the number of items conforms to the required
cardinality.
A StringCollator that sorts lowercase before uppercase, or vice versa.
This singleton class holds data about the case-variants of Unicode characters.
Castable Expression: implements "Expr castable as atomic-type?".
Cast Expression: implements "cast as data-type ( expression )".
Elaborator for
cast as expression, or the equivalent constructor function callCasting Expression: abstract superclass for "cast as X" and "castable as X", which share a good deal of logic
This marker interface represents a type that can be used as the target of a cast or castable
operation, that is, an atomic type, list type, or plain union type
A resource collection implemented by means of a catalog file.
The standard implementation of the
ResourceResolver interface for use with catalogs.Singleton class holding data for Regular expression character categories.
A Category is a CharacterClass represented in a regular expression as \p{Xx}.
CDATAFilter: This ProxyReceiver converts character data to CDATA sections,
if the character data belongs to one of a set of element types to be handled this way.
This class supports the ceiling() function
An EntityResolver that first tries one supplied EntityResolver, and if that
returns null, falls back to another.
An ResourceResolver that first tries one supplied ResourceResolver, and if that
returns null, falls back to another.
A character class represents a set of characters for regex matching purposes.
This class defines a character map, that is, a mapping from characters to strings used by the serializer
when mapping individual characters in the output.
CharacterMapExpander: This ProxyReceiver expands characters occurring in a character map,
as specified by the XSLT 2.0 xsl:character-map declaration
This class represents a set of named character maps.
A class that expands a character to a character reference, entity reference, etc,
and writes the resulting reference to a writer
This interface defines properties of a character set, built in to the Saxon product.
This class delivers a CharacterSet object for a given named encoding.
A filter to go on a Receiver pipeline and calculate a checksum of the data passing through the pipeline.
Compiled representation of an xsl:choose or xsl:if element in the stylesheet.
Elaborator for a "Choose" expression (which may be xsl:if, xsl:choose, or an XPath conditional expression).
A "Clause" refers specifically to one of the clauses of a FLWOR expression, for example the "for"
clause, the "let" clause, the "where" or "order by" clause.
A "trace" clause in a FLWOR expression, added by a TraceCodeInjector
This utility class exists in order to put all functionality relating to use of the Java 9 class
Cleaner in one place, to allow the product to continue to work with Java 8.A receiver that performs specified actions when closed
A Closure represents a value that has not yet been evaluated: the value is represented
by an expression, together with saved values of all the context variables that the
expression depends on.
An implementation of NodeName that encapsulates an integer fingerprint, a string prefix, and a reference to the NamePool from which
the fingerprint was allocated.
A code injector can be used to add code to the expression tree (for example, diagnostic tracing code)
during the process of parsing and tree construction
An AtomicComparer used for comparing strings, untypedAtomic values, and URIs using the Unicode codepoint
collation.
A collating sequence that uses Unicode codepoint ordering
Implements the XPath 2.0 fn:codepoint-equal() function.
Iterator over a string to produce a sequence of single character strings
This class implements the function fn:codepoints-to-string()
A function item obtained by coercing a supplied function; this adds a wrapper to perform dynamic
type checking of the arguments in any call, and type checking of the result.
An AtomicComparer used for comparing strings, untypedAtomic values, and URIs using a collation.
Abstract superclass for functions that take an optional collation argument, in which the
collation is not present as an explicit argument, either because it was defaulted in the
original function call, or because it has been bound during static analysis.
Generic class for all functions that take an optional collation argument,
where the collation argument is supplied and has not yet been resolved.
Implements the collation-key function defined in the XSLT 3.0 and XPath 3.1 specifications
A match key for comparing strings under a collation.
A CollationURIResolver accepts a collation name as input, and returns
a collation (represented by a
StringCollator as output.An instance of CollectionFinder can be registered with the Saxon configuration; it is called in response
to calls on the fn:collection() and fn:uri-collection() functions.
Implement the fn:collection() function.
A CombinedNodeTest combines two node tests using one of the operators
union (=or), intersect (=and), difference (= "and not").
This is a helper class for classes such as net.sf.saxon.Transform and net.sf.saxon.Query that process
command line options
An instruction representing an xsl:comment element in the stylesheet.
CommentImpl is an implementation of a Comment node
The CommentStripper class is a filter that removes all comments and processing instructions.
This class implements the XPath 2.0 fn:compare() function
This class implements a comparison of a computed value to a literal constant using one of the operators
eq, ne, lt, gt, le, ge.
This class implements a comparison of a numeric value to an integer constant using one of the operators
eq, ne, lt, gt, le, ge.
Elaborator for a "compare to integer constant" expression
This class implements a comparison of a computed value to a string constant using one of the operators
eq, ne, lt, gt, le, ge.
Elaborator for a "compare to string constant" expression
A
ComparisonException is a ClassCastException that
encapsulates an XPathException.Interface implemented by expressions that perform a comparison
Represents an XSLT compilation episode, compiling a single package.
This class exists to hold information associated with a specific XSLT compilation episode.
This class is used for generating complex content, that is, the content of an
element or document node.
Elaborator for element construction expressions (both fixed and computed).
A complex type as defined in XML Schema: either a user-defined complex type, or xs:anyType, or xs:untyped.
The different varieties of complex types
Represents a component as defined in the XSLT 3.0 specification: for example a function, a named template,
an attribute set, a global variable.
A ComponentBinding is a reference from one component to another; for example a variable
reference or function call.
The object represents a declaration (that is, a top-level element) in a stylesheet.
Represents an expression or instruction such as call-template, or a user function call, or
a global variable reference, that needs to be bound to a target component, and can potentially
be re-bound when the containing component is copied into another package.
A wrapper expression used to trace execution of components such as functions, templates,
and global variables in XSLT and XQuery.
A composite atomic key is a sequence of atomic values; two such keys are matched be comparing the
constituent values pairwise.
A CompoundMode is a mode representing the templates contained within an xsl:override element in a using package
together with the rules in the corresponding mode of the base package.
This class provides a compressed representation of a sequence of whitespace characters.
An instruction derived from an xsl:attribute element in stylesheet, or from
an attribute constructor in XQuery, in cases where the attribute name is not known
statically
An instruction representing an xsl:element element in an XSLT stylesheet,
or a computed element constructor in XQuery.
Elaborator for a FixedElement (literal result element) expression.
Implementation of the fn:concat() function
Implementation of the fn:concat() function as defined in XPath 2.0, 3.0, and 3.1
An iterator over nodes, that concatenates the nodes returned by two supplied iterators.
An iterator over nodes, that concatenates the nodes returned by two supplied iterators.
An iterable over arbitrary objects, that concatenates the objects returned by two supplied iterables.
An iterator (typically over nodes), that concatenates the nodes returned by two supplied iterators.
An XSLT 3.0 sequence constructor containing xsl:on-empty and/or xsl:on-non-empty instructions
This is a marker interface for Choose and Switch instructions
An expression that sorts an underlying sequence into document order if some condition is true, or that
returns the sequence "as is" (knowing that it doesn't need sorting) if the condition is false.
Elaborator for a conditional sorter, which sorts the results of a subexpression into document
order only if a supplied condition is true
A ResourceResolver that allows properties to be set and examined
This class holds details of user-selected configuration options for a set of transformations
and/or queries.
Marker interface to represent an API that is provided as a layer on top of this
ConfigurationThis class contains constants representing features of the software that may or may
not be licensed.
Class used to read a config.xml file and transfer all settings from the file to the Configuration
A ConstantFunction is a zero-argument function that always delivers the same result, supplied
at the time the function is instantiated.
An item type constructed by the
ItemTypeFactory (as distinct from one that is predefined)The ConstructorFunctionLibrary represents the collection of constructor functions for atomic types.
This expression is used as a proxy for the consuming operand of an expression such as an
arithmetic expression for which there is no explicit streaming support.
The
Container interface represents a document node or element node
under construction; there are concrete subclasses representing document nodes
and element nodes respectively.Implements the fn:contains() function, with the collation already known
Expression elaborator for a call to contains(), starts-with(), or ends-with()
Implements the fn:contains-token() function with the collation already bound.
A ContentHandlerProxy is a Receiver that converts events into the form expected by an
underlying SAX2 ContentHandler.
Create a TraceListener that will collect information about the current
location in the source document.
Implementation of the SAX Locator interface, used to supply location information to the ContentHandler.
NodeTest is an interface that enables a test of whether a node matches particular
conditions.
A ContextAccessorFunction is a function that is dependent on the dynamic context.
A comparer for comparing two "ordinary" atomic values, where the values implement the Comparable
interface and the equals() method with the appropriate XPath semantics.
This interface is implemented by AtomicValues that can be compared without regard
to context - specifically, the result of
eq and lt comparisons does not depend
on collations or on the context-dependent timezone.A ContextItemAccessorFunction is a function that takes no arguments, but operates implicitly on the
context item.
Subclass of ContextItemAccessorFunction to handle number().
Subclass of ContextItemAccessorFunction to handle string-length() and normalize-space().
This class represents the expression "(dot)", which always returns the context item.
Elaborator for the context item expression, "dot".
A data structure that represents the required type of the context item, together
with information about whether it is known to be present or absent or whether it
is not known statically whether it is present or absent.
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.
Represents a construct that is responsible for originating a new context; used in analysing the
stack of context objects for diagnostics
An entry on the context stack.
Subclass of ContextStackFrame representing an xsl:apply-templates call in XSLT
Subclass of ContextStackFrame representing a built-in template rule in XSLT
Subclass of ContextStackFrame representing the outermost stack frame,
for the calling application
Subclass of ContextStackFrame representing an xsl:call-template instruction in XSLT
Subclass of ContextStackFrame representing a call to a user-defined function
either in XSLT or XQuery
Subclass of ContextStackFrame representing the evaluation of a variable (typically a global variable)
This class provides a representation of the current runtime call stack, as represented by the stack
of XPathContext objects.
Interface implemented by expressions that switch the context, for example A/B or A[B]
The Controller underpins Saxon's implementation of the JAXP Transformer class, and represents
an executing instance of a transformation or query.
This is a marker interface used as the result of methods that convert or cast values from one type
to another.
This class defines a set of rules for converting between different atomic types.
A converter implements conversions from one atomic type to another - that is, it implements the casting
rules for a (source type, destination type) pair.
Converts base64 to hexBinary
Converts a boolean to a decimal
Converts a boolean to a double
Converts a boolean to an xs:float
Converts a boolean to an integer
Converts a dateTime to a date
Converts a dateTime to a gDay
Converts a dateTime to a gMonth
Converts a dateTime to a gMonthDay
Converts a dateTime to a gYear
Converts a dateTime to a gYearMonth
Converts a dateTime to a time
Converts a date to a dateTime
Converts a decimal to an integer.
Convers a double to a decimal
Converts a double to an integer
Converter that checks that a value belonging to a supertype is a valid
instance of a subtype, and returns an instance of the subtype
Converts a duration to a dayTimeDuration
Converts a duration to a yearMonthDuration
Converts a float to a decimal
Converts a float to an integer
Converts hexBinary to base64Binary
Converter that does nothing - it returns the input unchanged
Converts an integer to a decimal
Converts Notation to QName
Converts a numeric value to a boolean
Converts any numeric value to a decimal
Converts any numeric value to a double.
Converts any numeric value to xs:float
Converts any numeric value to an integer.
Converter that implements the promotion rules from xs:string to xs:anyURI
Converter that implements the promotion rules to a required type of xs:double
Converter that implements the promotion rules to a required type of xs:float
Converter that implements the promotion rules from xs:string to xs:anyURI
Converter that implements the promotion rules from xs:anyURI to xs:string
Converts QName to Notation
Converts any value to a string
Converts any value to untyped atomic
Converter that operates in two phases, via an intermediate type
Specialisation for converters that always succeed
Converter that does nothing except change the type annotation of the value.
Handler for xsl:copy elements in stylesheet.
A CopyInformee is an agent that receives extra information while a tree is being copied.
Exception indicating that an attempt was made to copy namespace-sensitive content
without copying its associated namespaces
An xsl:copy-of element in the stylesheet.
XSLT 3.0 function copy-of().
Non-instantiable class to define options for the
NodeInfo.copy(net.sf.saxon.event.Receiver, int, net.sf.saxon.s9api.Location) methodImplementation of the fn:count function
A "count" clause in a FLWOR expression
A tuple stream that implements a "count" clause in an XQuery 3.0 FLWOR expression
A tuple stream in push mode that implements a "count" clause in an XQuery 3.0 FLWOR expression
A filter that can be inserted into a Receiver pipeline to count the events that pass through.
This class contains dummy methods which, if called, have no effect; but calls
on these methods are detected by the Java-to-C# converter and affect the C# code
that is generated.
Annotate a Java class or interface to indicate whether the corresponding C# class should be implemented
as a delegate.
Annotate a Java interface to reference an additional interface with method definitions that
will be present in the C# product.
Annotate a Java class or interface with C# code that is to be injected literally into the body of the class
or interface when converting to C#.
This annotation appears on the declaration of a method that creates an instance of
an anonymous inner class, and it is used to define what information needs to be
passed to the generated C# inner class.
This annotation appears on the declation of a method or field if, for some reason,
the automatic generation of the correct modifiers for C# produces incorrect results.
Annotate a Java class or interface to indicate that the C# directive "#nullable enable" is to be included
in the generated C# code.
Annotate a Java method to indicate that it is to be dropped from the C# generated code
(alternative to conditional exclusion using the preprocessor)
Annotate a Java method with C# code that is to be injected literally into the body of the method
when converting to C#, replacing the Java method body.
Annotation used by the Java-to-C# transpiler: it causes any exception named
in a catch clause within a Java method to be replaced by a different exception
in the generated C#
Annotate a Java method, constructor, or field with C# code that is to replace the entire Java method.
Annotate a Java enum to indicate that a simple mapping to a C# enum should be used.
This annotation appears on the declation of a method or field if, for some reason,
the automatic generation of the correct modifiers for C# produces incorrect results.
This annotation appears on the declaration of a class using generic type
parameters if the C# code needs to have type bounds that cannot be inferred
directly from the Java declaration.
Implement the XSLT current() function
Implements the XSLT function current-group()
Implements the XSLT function current-group()
Implements the XSLT function current-grouping-key()
Implements the XSLT function current-grouping-key()
The expression is generated when compiling the current() function in XSLT.
Implements the XSLT 3.0 function current-merge-group()
Implements the XSLT function current-grouping-key()
This class implements the XSLT 3.0 function current-output-uri()
A function obtained by currying another function, that is, the result of calling
fn:partial-apply
A map implementation using a custom equality matcher, to avoid having to wrap
each entry in a wrapper object to achieve customised equality testing.
A one-way linked chain of entries in a
CustomMapA mutable set implementation using a custom equality matcher, to avoid having to wrap
each entry in a wrapper object to achieve customised equality testing.
A one-way linked chain of entries in a
CustomSetImplement XPath function fn:data() with a single argument
This element represents a top-level element in a user-defined namespace,
or a child/descendant of such an element.
This class handles URIs using the data: URI scheme defined in RFC 2397
This class implements extension functions in the
http://exslt.org/dates-and-times namespace.This class supports the dateTime($date, $time) function
A value of type
xs:dateTime.DateTimeComparable is an object that implements the XML Schema rules for comparing date/time values
A value of type Date.
A value of type xs:dayTimeDuration (or a subtype thereof).
This interface may be implemented by an external debugging tool
DecimalFormatManager manages the collection of named and unnamed decimal formats, for use by the
format-number() function.
An AtomicComparer used for sorting values that are known to be instances of xs:decimal (including xs:integer),
It also supports a separate method for getting a collation key to test equality of items
This class is modelled on Java's DecimalFormatSymbols, but it allows the use of any
Unicode character to represent symbols such as the decimal point and the grouping
separator, whereas DecimalFormatSymbols restricts these to a char (1-65535).
Abstract class representing the XDM type xs:decimal.
This interface represents the union of global variable declarations and function declarations in XQuery
modules
The built-in rule set introduced in XSLT 3.0, which performs a deep copy of any unmatched node.
XSLT 2.0 deep-equal() function, where the collation is already known.
The rule set introduced in XSLT 3.0, which (for any kind of node) simply ignores the node
and its descendants.
DefaultedArgumentExpression is a placeholder used in a function call for an argument
that is evaluated using the default value expression from the function definition, in cases where
that expression has not yet been compiled (typically because the function call precedes the
function declaration).This class supports both the descendant:: and descendant-or-self:: axes, which are
identical except for the route to the first candidate node.
This class supports both the descendant:: and descendant-or-self:: axes, which are
identical except for the route to the first candidate node.
A Comparer used for comparing descending keys.
Iterator that produces numeric values in a monotonic sequence,
ascending or descending.
A
Destination represents a place where XDM values can be sent.A helper class for implementing the
Destination interfaceA "let" clause in a FLWOR expression
Implements the trace clause in a FLWOR expression.
Implements the changes to a tuple stream effected by the Let clause in a FLWOR expression
A simple implementation of MapItem where the strings are keys, and modification is unlikely.
An enumeration representing a nodeset that is teh difference of two other NodeSets.
A wrapper around the Java cryptography classes to make a SHA-256 digest.
This class represents a resource collection containing all, or selected, files within a filestore
directory.
A
DirectResourceResolver is a ResourceResolver that resolves requests
using the direct, native capabilities of the platform.The XPath 2.0 distinct-values() function, with the collation argument already known
Iterator class to return the distinct values in a sequence
Implement the fn:doc() function - a simplified form of the Document function
Implement the saxon:doc() function - a variant of the fn:doc function with
a second argument to supply option parameters.
Implement the fn:doc-available() function
A saxon:doctype element in the stylesheet.
A
Container representing a document node.A document builder holds properties controlling how a Saxon document tree should be built, and
provides methods to invoke the tree construction.
This class implements the JAXP DocumentBuilder interface, allowing a Saxon TinyTree to be
constructed using standard JAXP parsing interfaces.
Implements the XSLT document() function
A node in the XML parse tree representing the Document itself (or equivalently, the root
node of the Document).
An instruction to create a document node.
Elaborator for an AtomicSequenceConverter (including an UntypedAtomicConverter, which is
the same except that it uses a different converter internally)
This class encapsulates a string used as the value of the document-uri() property of a document,
together with a normalized representation of the string used for equality comparisons.
A DocumentNodeTest implements the test document-node(element(~,~))
This class (which has one instance per Configuration) is used to allocate unique document
numbers.
DocumentOrderIterator takes as input an iteration of nodes in any order, and
returns as output an iteration of the same nodes in document order, eliminating
any duplicates.
This class is an implementation of the DOM Document class that wraps a Saxon DocumentInfo
representation of a document node.
An object representing the collection of documents handled during
a single transformation.
A DocumentSorter is an expression that sorts a sequence of nodes into
document order.
Elaborator for a docOrder expression - sorts nodes into document order and eliminates duplicates
This class supports the document-uri() function
DocumentValidator checks that a document is well-formed: specifically, that it contains a single element
node child and no text node children.
The tree info object for a tree implemented as a wrapper around a DOM Document.
TreeInfo class for a virtual tree that wraps a DOM4J tree
A node in the XML parse tree representing an XML element, character content, or attribute.
This class is the DOM4J implementation of Saxon's ExternalObjectModel interface; it supports
the wrapping of DOM4J documents as instances of the Saxon NodeInfo interface.
JDOMWriter is a Receiver that constructs a DOM4J document from the stream of events
Implementation of DOM NamedNodeMap used to represent the attributes of an element, for use when
Saxon element and attribute nodes are accessed using the DOM API.
This class represents a Destination (for example, the destination of the output of a transformation)
in which the results are written to a newly constructed DOM tree in memory.
DOMEnvelope is an object model representation in which DOM interfaces are wrapped around
Saxon NodeInfo nodes: that is, it implements the DOM on top of a Saxon tree implementation
such as the tiny tree or linked tree.
DOM operations only raise exceptions in "exceptional" circumstances,
i.e., when an operation is impossible to perform (either for logical
reasons, because data is lost, or because the implementation has become
unstable).
A simple implementation of the DOMImplementation interface, for use when accessing
Saxon tree structure using the DOM API.
This class wraps a list of nodes as a DOM NodeList
A node in the XML parse tree representing an XML element, character content, or attribute.
This interface must be implemented by any third-party object model that can
be wrapped with a wrapper that implements the Saxon Object Model (the NodeInfo interface).
DOMSender.java: pseudo-SAX driver for a DOM source document.
Variant of command line net.sf.saxon.Transform do build the source document
in DOM and then proceed with the transformation.
DOMWriter is a Receiver that attaches the result tree to a specified Node in the DOM Document
An AtomicComparer used for sorting values that are known to be numeric.
A numeric (double precision floating point) value
A dummy namespace resolver used when validating QName-valued attributes written to
the result tree.
The Durability of a node affects how it is handled for the purposes of caching by memo functions.
A value of type xs:duration
DurationValueComparable is a Comparable value that acts as a surrogate for a Duration,
having ordering rules that implement the XML Schema specification.
A DynamicContextAccessor is a function that takes no arguments, but operates implicitly on the
dynamic context.
This class implements the function fn:apply(), which is a standard function in XQuery 3.1.
Utility class used to perform dynamic loading of user-hook implementations
This object represents a dynamic context for query execution.
An EagerLetExpression is the same as a LetExpression except that the variable is evaluated using
eager evaluation rather than lazy evaluation.
A SequenceEvaluator that evaluates an expression eagerly, in pull mode.
A SequenceEvaluator that evaluates an expression eagerly, in push mode.
This class is an implementation of XPathContext used when evaluating constant sub-expressions at
compile time.
This class is at the heart of the mechanism for elaborating expressions.
A
Container representing an element node.This class supports the XSLT element-available function.
An instruction that creates an element node.
ElementCreationDetails is a package of information and callbacks designed
to parameterize the element construction process, to allow maximum use of
common code for direct interpreted evaluation, elaborated evaluation,
streamed evaluation, etc; supporting the variations that exist between
computed element constructors, fixed element constructors, and shallow copy.
ElementImpl implements an element node in the Linked tree model.
This class is an implementation of the DOM Element class that wraps a Saxon NodeInfo
representation of an element node.
Emitter: This abstract class defines methods that must be implemented by
components that format SAXON output.
Implementation of the fn:empty function
An implementation of AtomicSequence that contains no items.
An implementation of AttributeMap representing an empty AttributeMap
A character class represents a set of characters for regex matching purposes.
A Comparer that modifies a base comparer by sorting empty key values and NaN values last (greatest),
as opposed to the default which sorts them first.
An iterator over a zero-length sequence of integers
EmptyIterator: an iterator over an empty sequence.
An EmptySequence object represents a sequence containing no members.
This class is an implementation of the JAXP Source interface.
This class performs part of the processing in "constructing simple content":
it takes an input sequence and eliminates empty text nodes
into one.
Elaborator for an empty text node remove expression - inserted into a pipeline for node construction
A zero-length Unicode string
This class supports the function fn:encode-for-uri()
Utility class to detect the encoding of a stream by examining the initial bytes
Implements the fn:ends-with() function, with the collation already fixed
An implementation of the SAX
EntityResolver2 interface implemented by calling
a supplied ResourceResolverProposed extension for XPath 4.0: an enumeration type is a way of defining a subtype of xs:string,
with a defined set of permitted values, without recourse to a schema or schema-awareness.
A couple of utility methods for handling EnumSet objects.
Implement the XPath 3.0 fn:environment-variable() function
This interface defines a Saxon plug-in used to resolve calls on the XPath 3.0
functions available-environment-variables() and environment-variable().
A comparer for comparing two atomic values where (a) equals is defined, and is implemented
using the Java equals() method, and (b) ordering is not defined, and results in a dynamic error.
Interface representing objects used to perform equality matching.
Class containing utility methods for handling error messages
Implement XPath function fn:error()
Error expression: this expression is generated when the supplied expression cannot be
parsed, and the containing element enables forwards-compatible processing.
A SequenceIterator that throws an exception as soon as its next() method is called.
The ErrorReporter is a generic functional interface for reporting errors and
warnings.
A bridging class that allows errors in an XSLT Transformation, or in a Query,
to be reported to a JAXP
ErrorListener.This class has a singleton instance which represents the XML Schema 1.1 built-in type xs:error.
This class supports the function fn:escape-html-uri()
An EvaluateInstr is the compiled form of an xsl:evaluate instruction
Constants for different mechanisms of expression evaluation
An event is an object representing one of the events that can be passed to a receiver: for example, a startElement,
endElement, characters, or comment event.
Event representing an arbitrary item being sent to the event stream in composed form.
Event representing a comment node
Event representing end of document
Event representing the end of an element
Event representing a processing instruction node
Event representing start of document
Event representing the start of an element (including attributes or namespaces)
Event representing a text node
An
EventBuffer is a receiver of events that records the events in memory
for subsequent replay.An
EventMonitor is a filter that passes all events down the pipeline unchanged,
keeping a note of whether any data has passed through the filter.An implementation of the JAXP Source class that supplies a document in the form of a stream
of push events sent to a Receiver
A pattern formed as the difference of two other patterns
A compiled stylesheet or a query in executable form.
An ExecutableFunctionLibrary is a function library that contains definitions of functions for use at
run-time.
Implementation of the fn:exists function
An ExpandedStreamResult is similar to a StreamResult, and is created from a StreamResult.
This class represents a resource collection containing an explicitly enumerated set of resources
An export agent performs the job of exporting an expression to a SEF file.
Interface supported by an XPath expression.
General action class which can be used to process all nodes on an expression tree
An ExpressionContext represents the context for an XPath expression written
in the stylesheet.
Abstraction representing any class that can act as the container
for an expression: either an Operand of a parent expression, or a
top-level construct such as a function or template or XQuery expression
This class handles the display of an abstract expression tree in an XML format
with some slight resemblance to XQueryX
This class, ExpressionTool, contains a number of useful static methods
for manipulating expressions.
The ExpressionVisitor supports the various phases of processing of an expression tree which require
a recursive walk of the tree structure visiting each node in turn.
Implementation of the exslt-common function library.
Implement exslt:node-set
Implement exslt:object-type
This is an interface for simple external/extension functions.
This abstract class is provided to allow user-written extension functions to be implemented
with the full capabilities of functions that are an intrinsic part of the Saxon product.
This abstract class is provided to allow user-written extension functions to be implemented
with the full capabilities of functions that are an intrinsic part of the Saxon product.
This is a marker interface representing an abstract superclass of JavaExtensionFunctionFactory
and DotNetExtensionFunctionFactory.
Abstract class representing an extension instruction
This interface must be implemented by any third-party object model that can
be wrapped with a wrapper that implements the Saxon Object Model (the NodeInfo interface).
This class represents the type of an external object returned by
an extension function, or supplied as an external variable/parameter.
Represents the values of an accumulator whose evaluation has failed.
FailedResource represents an item in a collection that could not be processed because of some kind of error
The built-in rule set introduced in XSLT 3.0, which raises an error when there is no user-supplied
template rule that matches a node.
The FallbackElaborator performs elaboration of expressions for which no more specific
elaborator is available.
Feature defines a set of constants, representing the details of Saxon configuration
options which can be supplied to the Saxon method Configuration.setProperty(),
and to other interfaces
FeatureCode defines a set of integer constants, representing unique identifiers for the
features that can be configured.
FeatureKeys defines a set of constants, representing the names of Saxon configuration
options which can be supplied to the Saxon implementations of the JAXP
interfaces TransformerFactory, SchemaFactory, Validator, and ValidationHandler,
and to other interfaces such as the s9api
ProcessorA FilterExpression contains a base expression and a filter predicate, which may be an
integer expression (positional filter), or a boolean expression (qualifier)
Elaborator for a filter expression
An iterator for a filter expression in which the predicate is capable of evaluating as a number
(in which case it needs to be compared with the context position, rather than being converted
to a boolean)
An iterator for a filter expression where it is known that the filter value will not be numeric,
and can therefore be evaluated directly as a boolean
Factory class to create a ProxyReceiver which filters events on a push pipeline
This class implements the function fn:filter(), which is a standard function in XQuery 3.0
FilterImpl is an XMLFilter (a SAX2 filter) that performs a transformation
taking a SAX stream as input and producing a SAX stream as output.
A FilterIterator filters an input sequence using a filter expression.
A QName triple (prefix, URI, local) with the additional ability to hold an integer fingerprint.
A FirstItemExpression returns the first item in the sequence returned by a given
base expression
An elaborator for a "first-item" expression, typically written as
X[1] or as head(X).An instruction derived from an xsl:attribute element in stylesheet, or from
an attribute constructor in XQuery.
An instruction that creates an element node whose name is known statically.
Elaborator for a FixedElement (literal result element) expression.
This is a utility class that handles formatting of numbers as strings.
A numeric (single precision floating point) value
This class implements the fn:floor() function
This class represents a FLWOR expression, evaluated using tuple streams
An iterator that maintains the values of position() and current(),
typically implemented as a wrapper over an iterator which does not maintain these values itself.
An iterator that maintains the values of position() and current(), as a wrapper
over an iterator which does not maintain these values itself.
Implementation of aggregate functions such as sum() and avg() that supply a fold() function.
This class implements the function fn:fold-left(), which is a standard function in XPath 3.0
This class implements the function fn:fold-right(), which is a standard function in XQuery 1.1
Iterate over the following axis starting at a given node.
A "for" clause in a FLWOR expression
This class represents the tuple stream returned by a "for" clause in a FLWOR expression
This class implements the changes to the tuple stream effected by a "for" clause in a FLWOR expression
where "allowing empty" is specified
This class implements the changes to the tuple stream effected by a "for" clause in a FLWOR expression
This class implements the changes to the tuple stream effected by a "for" clause in a FLWOR expression
Handler for xsl:for-each elements in a stylesheet.
This class implements the function fn:for-each() (formerly fn:map), which is a standard function in XQuery 3.0
Handler for xsl:for-each-group elements in stylesheet.
This class implements the function fn:for-each-pair() (formerly fn:map-pairs()), which is a standard function in XQuery 3.0
A ForExpression maps an expression over a sequence.
An elaborator for a "for" expression, typically written as {for $x in SEQ return R}.
The MappingAction represents the action to be taken for each item in the
source sequence.
This class implements an xsl:fork expression.
Implement the format-date(), format-time(), and format-dateTime() functions
in XSLT 2.0 and XQuery 1.1.
Implementation of format-number() function.
Inner class to represent one sub-picture (the negative or positive subpicture)
Interface to a user-supplied class that handles XQuery annotation assertions in a particular namespace.
This class implements the function function-arity(), which is a standard function in XPath 3.0
This class implements the XSLT function-available functions.
Abstract superclass for calls to system-defined and user-defined functions
A
FunctionDefinition represents the declaration of a user-defined function in XQuery or XSLT; in 4.0
a function definition has an arity range.XDM 3.0 introduces a third kind of item, beyond nodes and atomic values: the function.
An ItemType representing the type of a function item (subclasses are used for maps and arrays)
A FunctionLibrary handles the binding of function calls in XPath (or XQuery) expressions.
A FunctionLibraryList is a list of FunctionLibraries.
A FunctionLiteral is a wrapper around a FunctionItem; it is an expression, whose value is the function
that it wraps.
This class supports the function-lookup() function in XPath 3.0.
This class implements the function function-name(), which is a standard function in XPath 3.0
An FunctionSequenceCoercer is an expression that performs function coercion on a sequence of function items:
it takes a sequence of supplied items as input, and wraps each one in a CoercedFunction value, which dynamically
converts the supplied arguments to the required type, and converts the result in the opposite direction, or
throws a type error if conversion is not possible.
Enumeration class giving the different streamability categories defined for stylesheet functions in XSLT 3.0
Abstract superclass for the primitive types containing date components: xs:date, xs:gYear,
xs:gYearMonth, xs:gMonth, xs:gMonthDay, xs:gDay
Implementation of the xs:gDay data type
GeneralComparison: a boolean expression that compares two expressions
for equals, not-equals, greater-than or less-than.
Elaborator for a general comparison expression such as (A = B).
GeneralComparison10: a boolean expression that compares two expressions
for equals, not-equals, greater-than or less-than.
The class GeneralComparison20 specializes GeneralComparison for the case where
the comparison is done with 2.0 semantics (i.e.
A GeneralNodePattern represents a pattern which, because of the presence of positional
predicates or otherwise, can only be evaluated "the hard way", by evaluating the equivalent
expression with successive ancestors of the tested node as context item.
A GeneralPositionalPattern is a pattern of the form A[P] where A is an axis expression using the child axis
and P is an expression that depends on the position.
This class supports the generate-id() function with one argument
An AtomicComparer used for comparing atomic values of arbitrary item types.
An
AtomicComparisonFunction compares two atomic values to return a result
of true or false.A generic (model-independent) implementation of the TreeInfo interface, suitable for use with all
tree models where the object representing the document node does not itself act as the TreeInfo
implementation
The Genre of an item is the top-level classification of its item type: one of Atomic, Node, Function,
Map, Array, or External
A Gizmo is a simple tool for performing a particular easily specified transformation on an XML
document, for example deleting or renaming all the elements with a particular name.
Information about the requirements placed by a query or stylesheet on the global
context item: whether it is mandatory or optional, what its type must be, and
whether it has a default value.
A Comparer used for comparing nodes in document order.
The compiled form of a global xsl:param element in an XSLT stylesheet or an
external variable declared in the prolog of a Query.
A GlobalParameterSet is a set of parameters supplied when invoking a stylesheet or query.
A compiled global variable in a stylesheet or query.
This interface provides access to a collection of global variables.
A reference to a global variable
Elaborator for a global variable reference, for example
$globalVar.Implementation of the xs:gYear data type
Implementation of the xs:gMonth data type
This interface is an extension to the SequenceIterator interface; it represents
a SequenceIterator that is based on an in-memory representation of a sequence,
and that is therefore capable of returning a Sequence containing all the items
in the sequence.
A value that exists in memory and that can be directly addressed
A class that wraps a
GroundedValue as a Java IterableA GroupAdjacentIterator iterates over a sequence of groups defined by
xsl:for-each-group group-adjacent="x".
A GroupBreakingIterator iterates over a sequence of groups defined by
xsl:for-each-group break-when="x".
This class represents an "group by" clause in a FLWOR expression
Inner class representing the contents of a tuple from the pre-grouping tuple stream;
a set of such objects consitutes a group.
Inner class representing a tuple comparison key: that is, an arbitrary object whose equals() and hashCode()
methods can be used to test whether two tuples have equivalent grouping keys
Represents the tuple stream delivered by an "group by" clause.
Represents the tuple stream delivered by an "group by" clause.
A GroupByIterator iterates over a sequence of groups defined by
xsl:for-each-group group-by="x".
A GroupEndingIterator iterates over a sequence of groups defined by
xsl:for-each-group group-ending-with="x".
A GroupIterator is an iterator that iterates over a sequence of groups.
A GroupMatchingIterator contains code shared between GroupStartingIterator and GroupEndingIterator
A GroupStartingIterator iterates over a sequence of groups defined by
xsl:for-each-group group-starting-with="x".
This class is a specialization of ObjectToBeSorted for use when the sequence
being sorted is a sequence of groups.
Implementation of the xs:gYearMonth data type
Implementation of the xs:gYear data type
This class implements the function fn:has-children($node), which is a standard function in XPath 3.0
An immutable map.
This class implements the function fn:head(), which is a standard function in XPath 3.0
A value of type xs:hexBinary
A class that represents a character as a hexadecimal character reference
and writes the result to a supplied Writer
The History object is used to avoid backtracking too far.
This class is an expression that does a run-time check of the result of a "/" expression
to ensure that (a) the results consists entirely of atomic values and function items, or entirely of nodes,
and (b) if the results are nodes, then they are deduplicated and sorted into document order.
Elaborator for a homogeneity checker, which checks that the items in a sequence are
either all nodes, or all non-nodes.
An iterator that returns the same items as its base iterator, checking to see that they are either
all nodes, or all non-nodes; if they are all nodes, it delivers them in document order.
Identifies a host language in which XPath expressions appear.
This class generates HTML 4.0 output
This class generates HTML 5.0 output
A collating sequence that compares strings according to the HTML5 rules for case-blind matching.
This class generates HTML output
HTMLIndenter: This ProxyReceiver indents HTML elements, by adding whitespace
character data where appropriate.
A simple class for testing membership of a fixed set of case-insensitive ASCII strings.
This class is used as a filter on the serialization pipeline; it performs the function
of escaping URI-valued attributes in HTML
Atomic types are the intersection of XPath item types and XSD simple types, and use multiple inheritance
to inherit methods representing the characteristics of both these kinds.
Holds the values of an accumulator function for one non-streamed document
Marker interface representing a bytecode generation service
The IdentityComparable class provides a way to compare objects for strong equality.
IdentityComparison: a boolean expression that compares two nodes
for equals, not-equals, greater-than or less-than based on identity and
document ordering
Elaborator for an identity comparison (operators
is, <<, and >> )Saxon implementation of the JAXP IdentityTransformer.
IdentityTransformerHandler implements the javax.xml.transform.sax.TransformerHandler
interface.
IDFilter is a ProxyReceiver that extracts the subtree of a document rooted at the
element with a given ID value.
Interface to a class used to perform dynamic loading of classes such as
user-hook implementations, as well as product-supplied resources like stylesheets
and DTDs.
A whitespace stripping rule that strips whitespace text node children from all elements having an element-only content
model, regardless of the value of the xml:space attribute
The IgnorableWhitespaceStripper removes whitespace text nodes belonging to elements
whose schema-defined type defines element-only content
Implementation of ArrayItem backed by a persistent immutable array, so that operations
that "update" the array do not have to copy the whole array
An immutable list implementation that only supports sequential traversal using an iterator,
prepending an item to the start, and extraction of the head()/tail() of the list.
This implementation of FunctionLibrary contains all the functions imported into a Query Module.
This class implements an AxisIterator by providing a start item, and a function
that selects the next item as a function of the previous item.
This class provides a compressed representation of a string used to represent indentation: specifically,
an integer number of newlines followed by an integer number of spaces.
An IndependentContext provides a context for parsing an XPath expression appearing
in a context other than a stylesheet.
This class replicates functionality that is available in a Java Stack, but not
in a C# Stack, for example the ability to access elements by direct index
(0-based, counting from the bottom of the stack).
Evaluator for a variable that needs to be indexed, because the optimizer has identified
that it will contain a sequence that is accessed using predicates based on the content
Note, indexing is only used in Saxon-EE; the implementation in Saxon-HE is a dummy.
The XPath 2.0 index-of() function, with the collation already known
This interface can be implemented by users (there are no implementations in Saxon itself).
This class implements the function fn:has-children(), which is a standard function in XPath 3.0
Allows the position of an input stream to be marked and reset.
This class implements the XPath 2.0 function fn:in-scope-prefixes()
The XPath 2.0 insert-before() function
Insertion iterator.
InstanceOf Expression: implements "Expr instance of data-type"
Elaborator for an
instance of expressionInterface representing a factory class for instantiating instances of a specific class
Abstract superclass for all instructions in the compiled stylesheet.
Interface implemented by instructions that contain a sequence constructor evaluated
using the rules for "constructing complex content": for example, xsl:element, xsl:copy,
xsl:document, xsl:result-document
Internal class used for instrumentation purposes.
An integer value: note this is a subtype of decimal in XML Schema, not a primitive type.
Set of int values.
Iterator class: iterate over an array of integers
Set of int values.
An immutable integer set containing all int values except those in an excluded set
This class represents a sequence of integers, for example 1 by 5 to 50.
An IntegerRangeTest is an expression of the form
E = N to M
where N and M are both expressions of type integer.
This class represents the XPath built-in type xs:integer.
Expression representing a call to a user-written extension
function implemented as a subtype of
ExtensionFunctionCallThis class checks that NodeInfo objects returned by an extension function were created
under the right Configuration
A library of integrated function calls, that is, user-written extension functions implemented
as instances of the class
ExtensionFunctionDefinition.An immutable integer set containing no integers
An enumeration representing a nodeset that is an intersection of two other NodeSets.
A pattern formed as the difference of two other patterns
An IntPredicate formed as the difference of two other predicates: it matches
an integer if the first operand matches the integer and the second does not
A hash table that maps int keys to Object values.
Set of int values.
An IntPredicate formed as the union of two other predicates: it matches
an integer if either of the operands matches the integer
An iterator over a sequence of unboxed int values.
This class allows an integer predicate (a boolean function of an integer) to be written as a lambda
expression, in a way that works both in Java and C#.
This interface represents an integer predicate (that is, a boolean function of an integer).
Set of int values.
Set of int values.
An iterator over a single integer repeated a fixed number of times
A set of integers represented as int values
A character class represents a set of characters for regex matching purposes.
An implementation of IntPredicate that tests whether a given integer is a member
of some IntSet
An iterator over a single integer
An immutable integer set containing a single integer
An iterator over a sequence of integers with regular steps, e.g.
An implementation of
IntToIntMap that relies on serial searching, and
is therefore optimized for very small map sizesA hash table that maps int keys to int values.
Interface defining a map from integers to integers
An IntPredicate formed as the union of two other predicates: it matches
an integer if either of the operands matches the integer
An immutable integer set containing every integer
An IntPredicate that matches a single specific integer
An
Invalidity is a validation error, that is, a failure of the instance document
to conform to the schema being used for validation.Interface for reporting validation errors found during validation of an instance document
against a schema.
Interface for reporting validation errors found during validation of an instance document
against a schema.
Interface for reporting validation errors found during validation of an instance document
against a schema.
This class
InvalidityReportGenerator extends the standard error handler for errors found during validation
of an instance document against a schema, used if user specifies -report option on validate.A character class represents a set of characters for regex matching purposes.
This class supports the functions encode-for-uri() and iri-to-uri()
Handles grouping separators when formatting a number in cases where the grouping separators are
not at regular intervals
This class implements the saxon:is-idref() extension function,
which is specially-recognized by the system because calls are generated by the optimizer.
A position() eq last() expression, generated by the optimizer.
Elaborator for an "isLast" expression, equivalent to
position() = last() or position() != last()This class defines properties of the ISO-8859-1 character set
An Item is an object that can occur as a member of a sequence.
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.
Elaborator for a
treat as expression, which is usually system-generated by
the type checking phase of the compilerItemCheckingIterator applies a supplied function to each item in a sequence.
A FunctionalInterface for any method that processes individual items, and which
may generate exceptions.
An
ItemElaborator is an abstract superclass for use by expressions that deliver zero or one items
as their result.Interface implemented by classes that evaluate an expression to deliver a single item
ItemMapper is an implementation of
ItemMappingFunction that wraps
a predicate function typically supplied as a lambda expression: unlike
a standard Predicate, however, the test is allowed to throw an XPathException.ItemMapper is an implementation of
ItemMappingFunction that wraps
a function typically supplied as a lambda expression.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.
An interface satisfied by all instructions that invoke templates: apply-templates,
call-template.
This class is a specialization of class ObjectToBeSorted for use when
the sequence being sorted is a sequence of items (including tuples, which
are represented as items).
An item type, as defined in the XPath/XQuery specifications.
ItemType is an interface that allows testing of whether an Item conforms to an
expected type.
ItemType representing a built-in atomic type
A mapping function for use in conjunction with an
ItemMappingIterator that checks that
all the items in a sequence are instances of a given item typeThis class is used for creating ItemType objects.
An ItemTypePattern is a pattern that consists simply of an ItemType; although
a node test is an item type, this class is used only for non-node item types,
such as atomic types, map types, array types etc.
Extension of the ItemType interface implemented by some item types, to provide
a cache of SequenceType objects based on this item type, with different
occurrence indicators.
A class representing an item together with its merge keys and the name of the merge source object
from which it derived, suitable for encapsulation as an ObjectValue.
An IterateInstr is the compiled form of an xsl:iterate instruction
Class IteratorWrapper - provides a SequenceIterator over a Java Iterator.
A JarCollection represents a collection of resources held in a JAR or ZIP archive, accessed typically
using a URI using the (Java-defined) "jar" URI scheme, or simply a "file" URI where the target
file is a JAR or ZIP file.
This class establishes properties of a character set that is
known to the Java VM but not specifically known to Saxon.
A JavaCollationFactory allows a Collation to be created given
a set of properties that the collation should have.
This class represents the type of an external Java object returned by
an extension function, or supplied as an external variable/parameter.
Implementation of the Platform class containing methods specific to the Java platform
(as distinct from .NET).
An implementation of RegularExpression that calls the JDK regular expression library directly.
This class represents a variable in an XPath expression compiled using the JAXP XPath API.
A JAXPXPathStaticContext provides a context for parsing an XPath expression
in a context other than a stylesheet.
The tree information for a tree acting as a wrapper for a JDOM2 Document.
A node in the XML parse tree representing an XML element, character content, or attribute.
This interface must be implemented by any third-party object model that can
be wrapped with a wrapper that implements the Saxon Object Model (the NodeInfo interface).
Variant of command line net.sf.saxon.Transform do build the source document
in JDOM2 and then proceed with the transformation.
Variant of command line net.sf.saxon.Transform do build the source document
in JDOM2 and then proceed with the transformation.
JDOMWriter is a Receiver that constructs a JDOM2 document from the stream of events
Handles terminal interaction for Gizmo using the JLine2 library: https://github.com/jline/jline2
This class together with its embedded subclasses handles conversion from Java values to XPath values.
Class JRegexIterator - provides an iterator over matched and unmatched substrings.
A
JsonBuilder is used to parse JSON documentsImplements the json-to-xml function defined in XSLT 3.0.
This class implements the back-end text generation of the JSON serialization method.
Default handler class for accepting the result from parsing JSON strings
Event handler for the JSON parser which constructs a structure of maps and arrays
representing the content of the JSON text.
Handler to generate an XML representation of JSON from a series of events
Parser for JSON, which notifies parsing events to a JsonHandler
A Receiver which receives a stream of XML events using the vocabulary defined for the XML representation
of JSON in XSLT 3.0, and which generates the corresponding JSON text as a string
A Resource (that is, an item in a collection) holding JSON content
This class implements the JSON serialization method defined in XSLT+XQuery Serialization 3.1.
Implements the json-to-xml function defined in XSLT 3.0.
A JTokenIterator is an iterator over the strings that result from tokenizing a string using
a regular expression, in this case a regular expression evaluated using the JDK regex engine
Corresponds to a single xsl:key declaration.
A set of xsl:key definitions in a stylesheet that share the same name
A key index is an index maintained to support xsl:key key definitions, including both user-defined
keys and keys added by the optimizer.
KeyManager manages the set of key definitions in a stylesheet, and the indexes
associated with these key definitions.
A key and a corresponding value to be held in a Map.
A generic interface for calling expressions by supplying the values of their subexpressions
An implementation of AttributeMap suitable for larger collections of attributes (say, more than five).
The segments (other than the last) have a fixed size of 65536 codepoints,
which may use one byte per codepoint, two bytes per codepoint, or three bytes per
codepoint, depending on the largest codepoint present in the segment.
A LastItemExpression returns the last item in the sequence returned by a given
base expression.
Elaborator for a "last item expression" (typically
SEQ[last()])A LastPositionFinder is an interface implemented by any SequenceIterator that is
able to return the position of the last item in the sequence.
SequenceEvaluator that evaluates an expression lazily in pull mode; that is, it delivers a
LazySequence which defers actual evaluation until the value is actually needed.A sequence that wraps an iterator, without being materialized.
A
LearningEvaluator initially performs
lazy incremental evaluation of an expression; but if this proves unproductive,
it switches after a while to eager evaluation.A "let" clause in a FLWOR expression
Implements the changes to a tuple stream effected by the Let clause in a FLWOR expression
Implements the changes to a tuple stream effected by the Let clause in a FLWOR expression
A LetExpression represents the XQuery construct let $x := expr return expr.
Elaborator for a let expression (either
let $x := SELECT return ACTION in XPath, or the
equivalent sequence constructor using local xsl:variable declarations in XSLT).A "Least Frequently Used" cache.
An entry in a least-recently-used cache
Exception thrown when there are problems with the license file
Line numbers are not held in nodes in the tree, because they are not usually needed.
Monitor construction of a document tree.
The LinkedTreeBuilder class is responsible for taking a stream of Receiver events and constructing
a Document tree using the linked tree implementation.
A function item representing a castability test for a list type
A function item representing a constructor function for a list type
Class ListIterator, iterates over a sequence of items held in a Java List.
ListIterator.OfAtomic is a subclass of ListIterator where the list always
contains atomic values; it therefore implements the AtomicIterator interface.
Interface representing a simple type of variety List
A Literal is an expression whose value is constant: it is a class that implements the
Expression
interface as a wrapper around a GroundedValue.Elaborator for a literal.
A
SequenceEvaluator for literals.This class represents a literal result element in the style sheet
(typically an HTML element to be output).
This class implements the function load-xquery-module(), which is a standard function in XPath 3.1.
Class to hold details of the location of an expression, of an error in a source file, etc.
Binding for local variables and parameters: anything that is allocated a slot on the XPathContext
stack frame.
Interface allowing localization modules for different languages to be dynamically loaded
This class supports the local-name() function
NodeTest is an interface that enables a test of whether a node has a particular
name and type.
A Comparer used for comparing nodes in document order.
The compiled form of an xsl:param element within a template in an XSLT stylesheet.
The Elaborator for this kind of expression
Represents the set of xsl:param elements at the start of an xsl:iterate instruction
A class that represents a union type declared locally, for example using
the (Saxon-extension) item-type syntax union(a,b,c), or internally in Java code.
Represents the defining occurrence of a variable declared within a FLWOR expression,
for example the $p in "for $x at $p in ...".
Variable reference: a reference to a local variable.
Elaborator for a local variable reference, for example
$var.Represents a construct that has a meaningful location for use in diagnostics
Saxon interface to represent a location, typically the location of an expression within a query
or stylesheet.
A Receiver that can be inserted into an event pipeline to copy location information.
Interface to diagnostic event logging mechanism.
A SequenceIterator is used to iterate over a sequence.
This class wraps any sequence iterator, turning it into a lookahead iterator,
by looking ahead one item
A lookup expression is an expression of the form A?*, where A must be a map or an array
A lookup expression is an expression of the form A?B.
Class to handle loop-lifting optimization, that is, extraction of subexpressions appearing within
a loop when there is no dependency on the controlling variable of the loop.
This class implements the fn:lower-case() function
Interface representing a factory class for instances of a specific type.
ManualIterator: a pseudo-iterator used while streaming.
This is a variant of the map:new() or map:merge() function which differs in that duplicate
keys are considered an error.
Function signatures (and pointers to implementations) of the functions defined in the map
namespace in XPath 3.1
Implementation of the proposed XPath 4.0 function
map:build($sequence, $key, $value, $combined) as xs:anyAtomicType) => map(*)
Implementation of the XPath 3.1 function map:contains(Map, key) => boolean
Implementation of the proposed 4.0 function map:entries(Map) => map(*)*
Implementation of the extension function map:entry(key, value) => Map
Implementation of the proposed XPath 4.0 function map:filter(Map, function(*)) => Map
Implementation of the XPath 3.1 function map:find(item()*, key) => array
Implementation of the function map:for-each(Map, Function) => item()*
Implementation of the XPath 3.1 function map:get(Map, key) => value
Implementation of the XPath 3.1 function map:keys(Map) => atomicValue*
Implementation of the function map:merge() => Map
From 9.8, map:merge is also used to implement map constructors in XPath and the xsl:map
instruction in XSLT.
Implementation of the function map:of-pairs() => Map
Implementation of the proposed 4.0 function map:pair(key, value) => record(key, value)
Implementation of the proposed 4.0 function map:pairs(Map) => record(key, value)*
Implementation of the extension function map:put() => Map
Implementation of the XPath 3.1 function map:remove(Map, key) => value
Implementation of the extension function map:size(map) => integer
Interface supported by different implementations of an XDM map item
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.
A Java Iterable which applies a mapping function to each item in a supplied Iterable
A Java Iterator which applies a mapping function to each item in an input sequence
An instance of this class represents a specific map item type, for example
map(x:integer, element(employee))
Implementation of an internal function map:untyped-contains(Map, key) => boolean,
which is like map:contains except that if the supplied key is untyped atomic, it
is converted to all the possible types present in the map and returns true if the
key after conversion is present.
This class implements the 3-argument matches() function for regular expression matching
This class implements extension functions in the
http://exslt.org/math namespace.
Abstract class providing functionality common to functions math:sin(), math:cos(), math:sqrt() etc;
contains the concrete implementations of these functions as inner subclasses
Implement math:atan2
Implement math:pi
Implement math:pow
Generic superclass for all the arity-1 trig functions
A MemoClosure represents a value that has not yet been evaluated: the value is represented
by an expression, together with saved values of all the context variables that the
expression depends on.
A
MemoClosureEvaluator is a SequenceEvaluator that evaluates an expression
lazily and incrementally; it evaluates new items in the result as and when they are needed.A user-defined function that is declared as a memo function, meaning that it remembers results
of previous calls.
A NodeSurrogate is a value that represents a node; it encapsulates a Java function that
can be called to test whether a particular node is the one that it represents.
A Sequence implementation that represents a lazy evaluation of a supplied iterator.
A ProgressiveIterator starts by reading any items already held in the reservoir;
when the reservoir is exhausted, it reads further items from the inputIterator,
copying them into the reservoir as they are read.
An iterator that groups the result of merging several xsl:merge input streams, identifying
groups of adjacent items having the same merge key value
Mapping function for items encountered during the merge; the mapping function wraps the merged
item and its merge keys into a single composite object
Inner class representing one merge source
An iterator representing the sorted merge of two merge inputs, retaining all duplicates.
A
Message represents the output of an xsl:message or
xsl:assert instruction.MessageEmitter is the default Receiver for xsl:message output.
An xsl:message or xsl:assert element in the stylesheet.
A user-written implementation of the MessageListener interface may be registered with the XsltTransformer
to receive notification of xsl:message output.
Deprecated.
This class implements a Receiver that can receive xsl:message output and send it to a
user-supplied MessageListener.
This class implements a Receiver that can receive xsl:message output and send it to a
user-supplied MessageListener.
MessageWarner is a user-selectable receiver for XSLT xsl:message output.
Represents information about a resource, as well as a pointer to the resource itself
The MetaTagAdjuster adds a meta element to the content of the head element, indicating
the required content type and encoding; it also removes any existing meta element
containing this information
This class implements the min() and max() functions, with the collation argument already known.
Concrete subclass to define the fn:max() function
Concrete subclass to define the fn:min() function
This exception occurs when an attempt is made to dereference a reference from one
schema component to another, if the target of the reference cannot be found.
A Mode is a collection of rules; the selection of a rule to apply to a given element
is determined by a Pattern.
Interface for helper classes used to process all the rules in the Mode
Interface for helper classes used to filter a chain of rules
A ModuleURIResolver is used when resolving references to
query modules.
An iterator over a single object (typically a sub-expression of an expression)
Set of int values.
An MultipleNodeKindTest is a nodetest that matches nodes belonging to any subset of possible
node kinds, for example element and document nodes, or attribute and namespace nodes
Interface representing the document node of a mutable document
An extension of the NodeInfo interface defining a node that can be updated.
This class supports the name() function with one argument
The NameChecker performs validation and analysis of XML names.
This class is a fast path iterator for the child axis in the TinyTree, where the axis specifies
an explicit name test for the required element nodes.
The runtime object corresponding to a named xsl:template element in the stylesheet.
This class attempts to identify a timezone name, given the date (including the time zone offset)
and the country.
An implementation of NodeName that gets the name of an existing NodeInfo object.
A NamePool holds a collection of expanded names, each containing a namespace URI,
and a local name.
Unchecked Exception raised when some limit in the design of the name pool is exceeded
This class is a filter that passes all Receiver events through unchanged,
except that it changes namecodes to allow for the source and the destination
using different NamePools.
Represents the binding of a prefix to a URI.
Represents a set of namespace bindings
This class is not instantiated, it exists to hold a set of constants representing known
namespaces.
A namespace constructor instruction.
This class bridges between the JAXP 1.3 NamespaceContext interface and Saxon's
equivalent NamespaceResolver interface.
Holds a set of namespace bindings as a simple immutable map from prefixes to URIs.
NamespaceDifferencer is a ProxyReceiver responsible for removing duplicate namespace
declarations.This class supports the function namespace-uri-for-prefix()
Holds a set of namespace bindings as a simple immutable map from prefixes to URIs.
This class represents a namespace node; it is used in several tree models.
NamespaceReducer is a ProxyReceiver responsible for removing duplicate namespace
declarations.Abstract class that supports lookup of a lexical QName to get the expanded QName.
This class is a NamespaceResolver that modifies an underyling NamespaceResolver
by changing the mapping of the null prefix to be a specified namespace, rather than
the one used by the underlying namespace resolver.
NodeTest is an interface that enables a test of whether a node has a particular
name and type.
This class represents a URI used as a namespace name.
This class supports the namespace-uri() function
Elaborator for the namespace-uri() function
NodeTest is an interface that enables a test of whether a node has a particular
name and type.
NameTestUnion is new in XPath 4.0.
The Navigator class provides helper classes for navigating a tree, irrespective
of its implementation
General-purpose implementation of the ancestor and ancestor-or-self axes
AxisFilter is an iterator that applies a NodeTest filter to
the nodes returned by an underlying AxisIterator.
A class that delivers the children of a node as a Java Iterable
General-purpose implementation of the descendant and descendant-or-self axes,
in terms of the child axis.
EmptyTextFilter is an iterator that applies removes any zero-length text
nodes returned by an underlying AxisIterator.
General purpose implementation of the following axis, in terms of the
ancestor, child, and following-sibling axes
Helper method to iterate over the preceding axis, or Saxon's internal
preceding-or-ancestor axis, by making use of the ancestor, descendant, and
preceding-sibling axes.
This interface is implemented by expressions that returns a boolean value, and returns an expression
whose result is the negated boolean value
Negate Expression: implements the unary minus operator.
Elaborator for a negate expression (that is, unary minus)
This class represents a dot-separated sequence of numbers such as 1.12.5, typically
used as a software version number.
Implements a xsl:next-iteration instruction within the body of xsl:iterate
An xsl:next-match element in the stylesheet
This class supports the nilled() function
Interface NodeFactory.
A node in the "linked" tree representing any kind of node except a namespace node.
The NodeInfo interface represents a node in Saxon's implementation of the XPath 2.0 data model.
NodeTest is an interface that enables a test of whether a node has a particular
name and kind.
Class ListIterator, iterates over a sequence of items held in a Java List.
This interface represents a node name.
This class supports the node-name() function with a single argument
Elaborator for the fn:node-name() function
This class implements the DOM Node interface as a wrapper around a Saxon NodeInfo object.
Interface representing a predicate applied to a node.
A NodeTest that wraps a general Predicate applied to nodes.
A NodeSetPattern is a pattern based on an expression that is evaluated to return a set of nodes;
a node matches the pattern if it is a member of this node-set.
A JAXP Source object representing a Saxon
NodeInfo.A NodeTest is a simple kind of pattern that enables a context-free test of whether
a node matches a given node kind and name.
A NodeTestPattern is a pattern that consists simply of a NodeTest
Interface defining methods common to the TinyTree and the Domino tree model.
An AxisIterator that wraps a Java Iterator.
Interface to a function that wraps nodes from an external object model in a Saxon NodeInfo
representation
This exception class is used when early (compile-time) evaluation of an expression
is attempted, and the expression requires knowledge of the current dateTime or implicit
timezone.
A whitespace stripping rule that retains all whitespace text nodes
An implementation of NodeName for the common case of a name in no namespace
This is a marker interface: if a URIResolver implements this interface and returns null from
its resolve() method, then the standard URI resolver will not be invoked.
Exception indicating that an attribute or namespace node has been written when
there is no open element to write it to
Implement the XPath normalize-space() function
Implement the XPath normalize-unicode() function (both the 1-argument and 2-argument versions)
A set of declared notations (in the sense of XSD xs:notation)
An xs:NOTATION value.
This class supports the XPath functions boolean(), not(), true(), and false()
A NullDestination is a Destination that discards all output sent to it.
Implements the XPath fn:number() function when called with one argument.
Interface Numberer supports number formatting.
Localization class for Danish.
Class Numberer_de provides localization for format-date() and xsl:number with language = "de" (German)
Numberer class for the English language.
Class Numberer_fr is a number formatter for french.
Class Numberer_frBE is a number formatter for French as used in Belgium.
Class Numberer_he does number formatting for language="he" (Hebrew).
Localization class for Italian
Localization class for Dutch.
Numberer class for the Belgian-Dutch language region.
Numberer class for the Swedish language.
Class NumberFormatter defines a method to format a ArrayList of integers as a character
string according to a supplied format specification.
This instruction performs the node-counting function of the xsl:number instruction.
This expression performs the formatting part of the logic of the xsl:number instruction
It takes as input a sequence of integers, which may either be supplied directly as the
value attribute of xsl:number, or may be computed by counting nodes.
A Comparer used for comparing sort keys when data-type="number".
A Comparer used for comparing sort keys when data-type="number".
A NumericGroupFormatter is responsible for insertion of grouping separators
into a formatted number (for example, reformatting "1234" as "1,234").
Singleton class representing the class xs:numeric as defined in XPath 3.1: a union type
whose members are xs:double, xs:decimal, and xs:float
NumericValue is an abstract superclass for IntegerValue, DecimalValue,
FloatValue, and DoubleValue
This class represents a member of a sequence that is being sorted.
An XPath value that encapsulates a Java object.
Represents one of the possible occurrence indicators in a SequenceType.
The
OnDemandFunctionSet represents a function library where the implementation classes
are loaded dynamically on demand.A sequence containing exactly one item.
A compiled xsl:on-empty instruction.
A value that is a sequence containing one or more items.
A compiled xsl:on-non-empty instruction.
A match against a fixed string of any length, within a regular expression
A back-reference in a regular expression
Beginning of Line (^) in a regular expression
Open paren (captured group) within a regular expression
A match of a single character in the input against a set of permitted characters
A choice of several branches within a regular expression
The different varieties of open content for complex types
End of program in a regular expression
End of Line ($) in a regular expression
Information about a sub-expression and its relationship to the parent expression
Defines an operand set comprising an array of operands numbered zero to N.
Interface representing a visitor of the clauses of a FLWOR expression that can process and
modify the operands of each clause
Defines the role of a child expression relative to its parent expression.
The usage of an operand defines how the containing expression makes use of the value of the operand,
as defined in the XSLT 3.0 specification.
Represents an operation or instruction in the regular expression program.
The ForceProgressIterator is used to protect against non-termination; specifically,
iterators that return an infinite number of zero-length matches.
Handle a greedy repetition (with possible min and max) where the
size of the repeated unit is fixed.
Match empty string within a regular expression
Handle a reluctant repetition (with possible min and max) where the
size of the repeated unit is fixed.
Handle a repetition (with possible min and max) where the
size of the repeated unit is variable.
A sequence of multiple pieces in a regular expression
This class performs optimizations that vary between different versions of the Saxon product.
Defines switches that can be used to control which optimizations take place.
A SequenceEvaluator for expressions that return a sequence of zero or one items.
This class implements the rules for options parameters, as used in functions such as parse-json, serialize,
json-to-XML, map:merge.
Operation that wraps a base operation and traces its execution
Handle a repetition where there is no ambiguity; if the repeated
term is matched in the string, then it cannot match anything other than
the repeated term.
This class represents an "order by" clause in a FLWOR expression
Represents the tuple stream delivered by an "order by" clause.
Represents the tuple stream delivered by an "order by" clause.
Elaborator for an "or" expression (
A or B)This class represents a function invoked using xsl:original from within an xs:override element.
A node (implementing the NodeInfo interface) representing an attribute, text node,
comment, processing instruction, or namespace that has no parent (and of course no children).
Expression class that implements the "outer for" clause of XQuery 3.0
An elaborator for a "for" expression, typically written as {for $x in SEQ return R}.
This class implements the function fn:outermost(), which is a standard function in XPath 3.0
Outputter: This interface represents a recipient of XML tree-walking (push) events.
An outputter event is an object representing one of the events that can be passed to an
Outputter :
for example, a startElement, attribute, namespace
endElement, characters, or comment event.Event representing an arbitrary item being sent to the event stream in composed form.
Event representing an attribute node
Event representing a comment node
Event representing end of document
Event representing the end of an element
Event representing a namespace node
Event representing a processing instruction node
Event representing the start of element content
Event representing start of document
Event representing the start of an element (including attributes or namespaces)
Event representing a text node
An
EventBuffer is a receiver of events that records the events in memory
for subsequent replay.This interface defines an OutputURIResolver.
This class is an implementation of the
ResultDocumentResolver interface
that wraps a supplied OutputURIResolver.Information about a unit of compilation: in XSLT, a package; in XQuery, a module.
Information about a package held in a package library; the package may or may not be loaded in memory
The PackageInspector class is a Receiver that looks at an incoming stylesheet document
and extracts the package name and version from the root element; parsing is then
abandoned.
A PackageLibrary represents a collection of packages that can be searched, typically to satisfy
an xsl:use-package declaration.
This class reads the XML exported form of a package and reconstructs the package object in memory.
A class to represent an XSLT package version such as 1.12.5 or 3.0-alpha
A class to handle a set of package version ranges
An iterator over a pair of objects (typically sub-expressions of an expression)
A ParameterSet is a set of parameters supplied when calling a template.
Data-only class to define the keywords used for parameters of built-in functions.
A Parcel is a way of wrapping an arbitrary sequence as a single item.
An abstract class to act as a common parent for instructions that create element nodes
and document nodes.
ParentNodeImpl is an implementation of a non-leaf node (specifically, an Element node
or a Document node)
Represents a content type as it appears in HTTP headers, parsed to extract
two properties: (a) a boolean indicating whether the media type is XML, and
(b) the character encoding.
This class implements the function parse-ietf-date(), which is a standard function in XPath 3.1
Implements the parse-json function, as defined in XPath 3.1
The parsing code, and the handling of options is shared with the json-to-xml function.
This class defines options for parsing and/or validating a source document.
Dummy Parser extension for syntax in XPath that is accepted only in particular product variants.
This expression class implements the operation of currying (or performing partial application) of a function.
Implement the fn:path function with one argument
This class sits in a receiver (push) pipeline and maintains the current path.
A PathMap is a description of all the paths followed by an expression.
An arc joining two nodes in the path map.
A node in the path map.
A (mutable) set of nodes in the path map
A root node in the path map.
Accumulator data for a tree that is obtained by mapping the nodes in this tree
to nodes in some other tree (specifically, the subtree from which this tree was
originally copied with copy-accumulators=yes) and getting the accumulator value
from the corresponding node in the other tree.
A Pattern represents the result of parsing an XSLT pattern string.
This is a singleton class used to convert an expression to an equivalent pattern.
Parser for XSLT patterns.
This class represents a pattern that sets the value of current() to the
node being matched, and then wraps another pattern that uses the value
of current()
Represents a pattern with a predicate, for example item[@value=3] or .[.
A PendingUpdateList is created by updating expressions in XQuery Update.
The
PIGrabber class is a ProxyReceiver that looks for xml-stylesheet processing
instructions and tests whether they match specified criteria; for those that do, it creates
a Source object referring to the relevant stylesheetA
Pingable represents an object that can receive an event with no associated information.This class is an implementation of the DOM ProcessingInstruction interface that wraps a Saxon NodeInfo
representation of a text or comment node.
A PipelineConfiguration sets options that apply to all the operations in a pipeline.
This class together with its embedded subclasses handles conversion from XPath values
to Java values
Converter for use when the source object is an atomic value, but nothing more is known
statically.
General-purpose converter when nothing more specific is available.
Converter for use when the target class is an array
Converter for use when the target class is a collection class.
Converter for use when the target class is
One, which constrains the value to be
a singletonConverter for use when the target class is
OneOrMore, which constrains the value to be
a non-empty sequenceConverter for use when the target class is
ZeroOrMore, which allows any sequence
but is a generic (parameterized) class so there is compile-time information about the type
of itemsConverter for use when the target class is
ZeroOrOne, which constrains the value to be
a singleton or an empty sequenceA "plain type" is either an atomic type, or a union type that (a) imposes no restrictions other
than those imposed by its member types, and (b) has exclusively plain types as its member types
This interface provides access to methods whose implementation depends on the chosen platform
(typically Java or .NET)
Enumerate all the nodes on the preceding axis from a given start node.
This axis cannot be requested directly in an XPath expression
but is used when evaluating xsl:number.
This class supports the preceding-sibling axis.
A character class represents a set of characters for regex matching purposes.
This non-instantiable class provides a number of useful implementations of the
Predicate
interface, designed for use when navigating streams of XDM items.A prefix pool maintains a two-way mapping from namespace prefixes (as strings) to
integer prefix codes.
This PreparedStylesheet class represents a Stylesheet that has been
prepared for execution (or "compiled").
An iterator over nodes, that prepends a given node to the nodes
returned by another iterator.
An iterator over nodes, that prepends a given node to the nodes
returned by another iterator.
This class is added to the output pipeline for the principal result destination for a transformation
if the transformation uses xsl:result-document instructions.
Represents both the stylesheet module at the root of the import tree, that is, the module
that includes or imports all the others, and also the XSLT package that has this stylesheet
module as its root.
An xsl:processing-instruction element in the stylesheet, or a processing-instruction
constructor in a query
The
Processor class serves three purposes: it allows global Saxon configuration options to be set;
it acts as a factory for generating XQuery, XPath, and XSLT compilers; and it owns certain shared
resources such as the Saxon NamePool and compiled schemas.ProcInstImpl is an implementation of ProcInstInfo used by the Propagator to construct
its trees.
ProcInstParser is used to parse pseudo-attributes within Processing Instructions.
This class implements the rules in a property such as
XMLConstants.ACCESS_EXTERNAL_SCHEMA,
which constrain the set of URIs that can be used by supplying a list of permitted protocols.A ProxyReceiver is an Receiver that filters data before passing it to another
underlying Receiver.
A pseudo-expression is an object that can appear as a node on the expression tree, but which cannot
actually be evaluated in its own right.
A PublicStylesheetFunctionLibrary filters a StylesheetFunctionLibrary to include only those functions
whose visibility is final or public.
A PullConsumer consumes all the events supplied by a PullProvider, doing nothing
with them.
Abstract implementation of
Elaborator for expressions that primarily evaluate in pull mode,
that is, by returning a SequenceIterator over the result.Interface implemented by evaluators that evaluate an expression in "pull" mode, that is,
by delivering a
SequenceIterator over the results.Enumeration of event types that can occur in the
PullProvider interfacePullFilter is a pass-through filter class that links one PullProvider to another PullProvider
in a pipeline.
PullProvider is Saxon's pull-based interface for reading XML documents and XDM sequences.
This class copies a document by using the pull interface to read the input document,
and the push interface to write the output document.
PullPushTee is a pass-through filter class that links one PullProvider to another PullProvider
in a pipeline, copying all events that are read into a push pipeline, supplied in the form
of a Receiver.
A PullSource is a JAXP Source that encapsulates a PullProvider - that is, an object
that supplies an XML document as a sequence of events that are read under the control
of the recipient.
An interface designed for applications to generate XML documents by issuing events.
Interface implemented by functions that have a "push" implementation, whereby the result
of the function is written incrementally to an
Outputter rather than being
returned as the result of a call() method.Abstract superclass for elaborators whose primary evaluation method is in push mode.
Implements the fn:put() function in XQuery Update 1.0.
The QName class represents an instance of xs:QName, as defined in the XPath 2.0 data model.
A QNameException represents an error condition whereby a QName (for example a variable
name or template name) is malformed
This class supports the fn:QName() function
Parser to handle QNames in either lexical QName or EQName syntax, including resolving any prefix against
a URIResolver.
Interface for tests against a QName.
A QName value.
A qualified name: this is an abstract superclass for QNameValue and NotationValue, representing the
XPath primitive types xs:QName and xs:NOTATION respectively
A QuantifiedExpression tests whether some/all items in a sequence satisfy
some condition.
Elaborator for a quantified expression (
some|every X in Y satisfies Z)This Query class provides a command-line interface to the Saxon XQuery processor.
A QueryLibrary represents an independently compiled set of query modules that does not include a
main module.
This class represents a query module, and includes information about the static context of the query module.
This class contains static methods used to read a query as a byte stream, infer the encoding if
necessary, and return the text of the query as a string; also methods to import functions and variables
from one module into another, and check their consistency.
This utility class takes the result sequence produced by a query, and wraps it as
an XML document.
An exception used to signal that no more input is required from the parser, and that
parsing can therefore be abandoned early (but without signaling any error to the user)
This class implements extension functions in the
http://exslt.org/random namespace.
This class implements the function random-number-generator(), which is a standard function in XPath 3.1
A RangeExpression is an expression that represents an integer sequence as
a pair of end-points (for example "x to y").
This abstract class represents an iteration over the results of a range expression
(A by B to C).
This class implements an XPath map item as a view of an XSLT key index.
An
RawDestination is a Destination that accepts a sequence output
by a stylesheet or query and returns it directly as an XdmValue, without
constructing an XML tree, and without serialization.This class is an implementation of the JAXP Result interface.
A
RebasedDocument represents a view of a real Document in which all nodes are mapped to a different
base URI and/or system ID using supplied mapping functions.A RebasedNode is a view of a node, in a virtual tree that maps the base URI and/or
system ID to new values
A map from old bindings to new bindings, maintained during a copy() operation applied
to an expression tree.
Receiver: This interface represents a recipient of XML tree-walking (push) events.
ReceiverOption defines a set of constants representing boolean flags, which can be used in
calls to methods on the Receiver interface.
ReceiverToXMLStreamWriter is a Receiver writes XML by using the XMLStreamWriter
Marker interface attached to a
Outputter that retains
serialization properties (typically, a Receiver that forms part
of the serialization pipeline).ReceivingContentHandler is a glue class that provides a standard SAX ContentHandler
interface to a Saxon Receiver.
An implementation of the Saxon
Location interface that wraps the SAX Locator
information.An implementation of
Destination that simply wraps a supplied ReceiverA regular expression compiler class.
An instance of this class represents a specific record item type, for example
record(x as xs:double, y as element(employee)).
Class representing one field definition within a record type definition,
used only while constructing a record definition
An instance of this class represents a specific record type, for example
record(x as xs:double, y as element(employee)).
Class representing a set of regular expression flags (some combination of i, m, s, x, q).
This class implements any of the functions matches(), replace(), tokenize(), analyze-string(), in the
version where a flags argument is present in the argument list
This class implements any of the functions matches(), replace(), tokenize(), analyze-string(), in which the
final "flags" argument is omitted.
This interface defines an iterator that supports the evaluation of xsl:analyze-string.
Interface defining a call-back action for processing captured groups within a regular expression
A precondition that must be true if a regular expression is to match
This interface represents a compiled regular expression.
A RegularGroupFormatter is a NumericGroupFormatter that inserts a separator
at constant intervals through a number: for example, a comma after every three
digits counting from the right.
A
RegularSequenceChecker is a filter that can be inserted into a Receiver pipeline
to check that the sequence of events passed in is a regular event sequence.The standard JAXP URIResolver is given a relative URI and a base URI and returns the resource
identified by this combination.
RE is an efficient, lightweight regular expression evaluator/matcher
class.
The XPath 2.0 remove() function
An implementation of SequenceIterator that returns all items except the one
at a specified position.
A RepairingContentHandler is a SAX filter that can be placed on the input pipeline in front of
a
ReceivingContentHandler for use in cases where the events supplied by the XML parser
are not guaranteed to satisfy all the consistency constraints.This class implements the replace() function for replacing
substrings that match a regular expression
This is a subclass of
SingletonIterator that reports to
a LearningEvaluator when the single target item is actually
read.A class that holds compiled regular expressions.
This class supports the resolve-QName function in XPath 2.0
This class supports the resolve-uri() function in XPath 2.0
This interface defines a Resource.
This interface defines a ResourceCollection.
A ResourceFactory is used for constructing a particular type of resource
The class provides a static method for loading resources from a URL.
A bundle of information made available when requesting resource resolution.
Interface for processing a resource request to deliver a resource
Convenience class to allow a ResourceResolver to be implemented as a lambda expression.
A
ResourceResolver implemented by wrapping a supplied URIResolverThe compiled form of an xsl:result-document element in the stylesheet.
The
ResultDocumentResolver interface may be implemented by a user application;
it is a callback that is called whenever an xsl:result-document instruction
is executed.Exception thrown to indicate a syntax error in a regular expression.
This class contains the part of the static context of expressions that (a) can change from one expression
to another within a query or stylesheet, and (b) are potentially needed at run-time.
This iterator applies the return expression of a FLWOR expression to each
of the tuples in a supplied tuple stream, returning the result as an iterator
The class represents the final stage in a push-mode tuple pipeline.
Implement XPath function fn:reverse()
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 RoleDiagnostic (formerly RoleLocator) identifies the role in which an expression is used,
for example as the third argument of the concat() function.
Implement the XPath 2.0 root() function with one argument
An expression whose value is always a set of nodes containing a single node,
the document root.
Elaborator for a root expression (
/)This class implements the fn:round() function
This class supports the round-to-half-even() function
Rule: common functionality representing an abstraction of a template rule, a strip-space rule,
or an accumulator rule
This class wraps a RuleBasedCollator to provide a SubstringMatcher.
A chain of rules: actually in this incarnation just a pointer to the first rule in the chain, the others
being linked together each to the next.
RuleManager maintains a set of template rules, one set for each mode
A simple class for holding stateful details of a rule search operation
This is a dummy implementation for Saxon-HE which does not optimize searching a rule chain.
A set of built-in template rules that performs the same action as an underlying set of rules,
but with the addition of a warning message saying that no user-defined template rules was found.
The target of a rule, typically a TemplateRule.
NodeTest is an interface that enables a test of whether a node has a particular
name and type.
A comment node in a sapling tree
A document node in a sapling tree.
An element node on a sapling tree.
This class represents a sapling node.
A processing-instruction node in a sapling tree
This is a non-instantiable class holding a number of convenience methods for creating
sapling nodes of different kinds.
This class represents a
Destination (for example, the destination of the output of a transformation)
in which events representing the XML document are sent to a user-supplied SAX2 ContentHandler, as
if the ContentHandler were receiving the document directly from an XML parser.An exception thrown by the Saxon s9api API.
An unchecked exception thrown by the Saxon API.
Implements the saxon:deep-equal() function, a variant of fn:deep-equal that provides
additional control over how the comparison is performed.
Saxon implementation of the JAXP class javax.xml.datatype.Duration.
The class acts as a register of Saxon-specific error codes.
Provides string constants that can be used to set
output properties for a Transformer, or to retrieve
output properties from a Transformer or Templates object.
A SaxonTransformerFactory instance can be used to create Transformer and Template
objects.
Saxon implementation of the JAXP class javax.xml.datatype.XMLGregorianCalendar.
A Scalar system function is a pure function that accepts a single item as its operand,
returns a single atomic value as its result, typically returns an empty sequence if the argument is an
empty sequence, and has no context dependencies.
This is a marker interface that represents any "schema component" as defined in the XML Schema
specification.
This is a marker interface that acts as a surrogate for an object representing
a global element or attribute declaration.
An exception that identifies an error in reading, parsing, or
validating a schema.
The SchemaManager is used to load schema documents, and to set options for the way in which they are loaded.
Marker interface for schema-element() and schema-attribute() node tests
SchemaType is an interface implemented by all schema types: simple and complex types, built-in and
user-defined types.
A SchemaURIResolver is used when resolving references to
schema documents.
Internal indicator representing progress in validating components of a schema
A
SchemaValidator is an object that is used for validating instance documents against a schema.Marker interface for elements that declare a variable which is in-scope within their body
A whitespace stripping rule that strips elected elements unless xml:space indicates that whitespace
should be preserved.
An instance of this class represents a self-reference within a record type, that is the ".."
construct in a record test such as
record(data as xs:string, next? as ..).Sender is a helper class that sends events to a Receiver from any kind of Source object
This interface represents an XDM Value, that is, a sequence of items.
This receiver is used when writing a sequence of atomic values and nodes, that
is, when xsl:variable is used with content and an "as" attribute.
Copies a sequence, supplied as a SequenceIterator, to a push pipeline, represented by
a SequenceReceiver
A sequence value implemented extensionally.
A compiled xsl:sequence instruction.
A SequenceIterator is used to iterate over any XPath 2 sequence (of values or nodes).
SequenceMapper is an implementation of
MappingFunction that wraps
a function typically supplied as a lambda expression.Implement the "sequence normalization" logic as defined in the XSLT 3.0/XQuery 3.0
serialization spec.
Implement the "sequence normalization" logic as defined in the XSLT 3.0/XQuery 3.0
serialization spec.
Implement the "sequence normalization" logic as defined in the XSLT 3.0/XQuery 3.0
serialization spec, for the case where there is no item-separator.
SequenceReceiver: this extension of the Receiver interface is used when processing
a sequence constructor.
Utility class for manipulating sequences.
A SequenceType is the combination of an ItemType and an OccurrenceIndicator
SequenceType: a sequence type consists of a primary type, which indicates the type of item,
and a cardinality, which indicates the number of occurrences permitted.
This class can be used in a push pipeline: it accepts any sequence as input, and generates
a document in which the items of the sequence are wrapped by elements containing information about
the types of the items in the input sequence.
The
SequenceWriter is used when writing a sequence of items, for
example, when xsl:variable is used with content and an "as" attribute.This class handles a set of serialization parameters provided in the form of an XDM instance
as specified in the Serialization 3.0 definition, section 3.1
Define a set of serialization properties.
Implementation of fn:serialize() as defined in XPath 3.1
A
Serializer takes a tree representation of XML and turns it into lexical XML markup.Enumeration class defining the permitted serialization properties
Helper class to construct a serialization pipeline for a given result destination
and a given set of output properties.
This class implements extension functions in the
http://exslt.org/sets namespace.
The built-in shallow-copy-all rule set proposed for XSLT 4.0, which is the same as
shallow-copy, except for maps and arrays.
The built-in rule set introduced in XSLT 3.0, which is effectively an identity template.
A built-in set of template rules that ignores the current node and does an apply-templates
to its children.
Evaluator for expressions that are evaluated in "shared append" mode.
Interface that extends NodeInfo by providing a method to get the position
of a node relative to its siblings.
This class supports both the child:: and following-sibling:: axes, which are
identical except for the route to the first candidate node.
This receiver is inserted into the output pipeline whenever on-empty or on-non-empty is used (XSLT 3.0).
A simple implementation of XDM array items, in which the array is backed by a Java List.
A simple collation that just wraps a supplied Comparator
An abstract implementation of Expression designed to make it easy to implement new expressions,
in particular, expressions to support extension instructions.
A Mode is a collection of rules; the selection of a rule to apply to a given element
is determined by a Pattern.
Interface used around a group of rules - principally at the
group start and the group end
Common superclass for XSLT instructions whose content template produces a text
value: xsl:attribute, xsl:comment, xsl:processing-instruction, xsl:namespace,
and xsl:text, and their XQuery equivalents
Abstract elaborator for expressions that evaluate simple nodes (text nodes, comments, attributes, etc) in push mode.
A SimplePositionalPattern is a pattern of the form A[N] where A is an axis expression using the child axis
and P is a numeric literal.
A SimpleStepExpression is a special case of a SlashExpression in which the
start expression selects a single item (or nothing), and the step expression is
a simple AxisExpression.
Elaborator for a simple step expression, that is X/axis::Y where X evaluates to a singleton
This interface represents a simple type, which may be a built-in simple type, or
a user-defined simple type.
This class implements equality and ordering comparisons between values of simple types:
that is, atomic values, and sequences of atomic values, following the XSD-defined rules
for equality and ordering comparisons.
This class implements equality and identity comparisons between values of simple types:
that is, atomic values, and sequences of atomic values, following the XSD-defined rules
for equality and identity comparisons.
SingletonIterator: an iterator over a sequence of exactly one atomic value
A key and a corresponding value to be held in a Map.
A
SequenceEvaluator for expressions that return a single item (exactly one,
never an empty sequence).A SingleItemFilter is an expression that selects zero or one items from a supplied sequence
SingleNodeIterator: an iterator over a sequence of 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.
An implementation of AttributeMap for use when there is exactly one attribute
A character class represents a set of characters for regex matching purposes.
A SingletonClosure represents a value that has not yet been evaluated: the value is represented
by an expression, together with saved values of all the context variables that the
expression depends on.
This expression is equivalent to (A intersect B) in the case where A has cardinality
zero-or-one.
Elaborator for a Venn expression: that is
A union B, A intersect B,
or A except BSingletonIterator: an iterator over a sequence exactly one value
The "singularity" tuple stream delivers a single empty tuple.
A Sink is a Receiver that discards all information passed to it
An Outputter that swallows (discards) all input supplied to it
A slash expression is any expression using the binary slash operator "/".
Elaborator for a slash expression.
A Unicode string consisting entirely of 16-bit BMP characters, implemented as a range
of an underlying byte array
A Unicode string consisting of 24-bit characters, implemented as a range
of an underlying byte array holding three bytes per codepoint
A Unicode string consisting entirely of 8-bit characters, implemented as a range
of an underlying byte array
A SlotManager supports functions, templates, etc: specifically, any executable code that
requires a stack frame containing local variables.
An implementation of AttributeMap suitable for small collections of attributes (typically, up to five).
XSLT 3.0 function snapshot().
This class represents a node within a tree produced by the snapshot() function, as a virtual copy of
the relevant nodes in another tree.
This class implements the function fn:sort#1, which is a standard function in XPath 3.1
This class implements the function fn:sort#2, according to the new XPath 3.1 spec in bug 29792
This class implements the function fn:sort#2, which is a higher-order function in XPath 3.1
available only in Saxon-PE and above
A SortedGroupIterator is a modified SortedIterator.
Class to do a sorted iteration
Expression equivalent to the imaginary syntax
expr sortby (sort-key)+
Elaborator for a sort expression - sorts nodes into order based on a user-supplied sort key
A SortKeyDefinition defines one component of a sort key.
The class represents a list of sort key definitions in major-to-minor sort key order.
Callback interface used to evaluate sort keys.
Helper class for xsl:variable and xsl:param elements.
Non-streamable implementation of the xsl:source-document instruction
This interface defines a SourceResolver.
A SpaceStrippedDocument represents a view of a real Document in which selected
whitespace text nodes are treated as having been stripped.
A StrippedNode is a view of a node, in a virtual tree that has whitespace
text nodes stripped from it.
Interface for deciding whether a particular element is to have whitespace text nodes stripped
An instance of this class represents a specific function item type, for example
function(xs:int) as xs:boolean
An expression that delivers a fixed size array whose members are the result of evaluating
corresponding expressions: [a,b,c,d]
This class represents a stack frame holding details of the variables used in a function or in
an XSLT template.
StandardCollationURIResolver allows a Collation to be created given
a URI starting with "http://saxon.sf.net/collation" followed by a set of query parameters.
Default implementation of the CollectionFinder interface.
This class is an abstract superclass of classes such as the
StandardErrorListener
and StandardInvalidityHandler, and exists to provide common utility methods for these
classes, and for similar user-written classes if requiredDefault implementation of the
EnvironmentVariableResolver.A default implementation of the SAX ErrorHandler interface.
StandardErrorListener is the standard error handler for XSLT and XQuery processing
errors, used if no other ErrorListener is nominated.
StandardErrorReporter is the standard error handler for processing XSLT and XQuery static
errors, used if no other error handler is nominated.
This class
StandardInvalidityHandler, despite its name, is not directly used by Saxon, and in particular
it is NOT the default InvalidityHandler.The default Logger used by Saxon on the Java platform.
This is the default implementation of the new Saxon 11 interface
for user-defined handling of
xsl:message and xsl:assert
output.This class is the standard ModuleURIResolver used to implement the "import module" declaration
in a Query Prolog.
Well-known names used in XSLT processing.
This class defines the default OutputURIResolver.
This class defines the default ResultDocumentResolver.
Default implementation of the UnparsedTextURIResolver, used if no other implementation
is nominated to the Configuration.
This class checks whether a string is a valid URI.
This class provides the service of converting a URI into an
Source.Implements the fn:starts-with() function, with the collation already known
Implement the XPath function static-base-uri()
A StaticContext contains the information needed while an expression or pattern
is being parsed.
A StaticContextAccessor is a function that takes no arguments, but operates implicitly on the
static context.
Implement the XPath function default-collation()
The StaticError interface is retained in Saxon 10.0 as a marker interface so that
the methods
XsltCompiler.setErrorList(List) and XQueryCompiler.setErrorList(List)
continue to function.A call to a function that is known statically.
This class contains constants identifying dependencies that an XPath expression
might have on its context.
StaticQueryContext contains information used to build a StaticContext for use when processing XQuery
expressions.
Factory class for creating a customized instance of StaticQueryContext
Statistics on the size of TinyTree instances, kept so that the system can learn how much space to allocate to new trees
This class implements the Saxon PullProvider API on top of a standard StAX parser
(or any other StAX XMLStreamReader implementation)
StAxResultHandler is a helper class
StAxResultHandler is used to allow a transformation result to be supplied as a StAXResult.
A
Step is a function that can be applied to an item
to return a stream of items.The SteppingNavigator is a utility class containing methods to assist with navigating a tree whose nodes
implement the
SteppingNode interfaceAn iterator over the descendant or descendant-or-self axis
This interface can be implemented by an implementation of NodeInfo to take advantage of a generic implementation
of the descendant axis found in class
SteppingNavigatorThis non-instantiable class provides a number of useful implementations of the
Step
interface, used to navigate XDM trees, typically as an argument to XdmValue.select(net.sf.saxon.s9api.streams.Step<T>).This class implements the XSLT 3.0 function stream-available()
Elaborator for the first argument of a streamable stylesheet function
StreamingFilterImpl is an XMLFilter (a SAX2 filter) that performs a transformation
taking a SAX stream as input and producing a SAX stream as output, using XSLT 3.0 streaming
to process the source
This is a special pattern that matches the node supplied as the first argument of a call to
a streamable stylesheet function; it corresponds to the
pattern match="$arg" where $arg is the first argument of the function.
Saxon implementation of the JAXP Transformer interface.
This class implements the XmlStreamWriter interface, translating the events into Saxon
Receiver events.
Implement XPath function string() with a single argument
This interface represents a "collation" as defined in XPath, that is, a set of rules for comparing strings
Contains constants representing some frequently used strings, either as a
UnicodeString
or in some cases as a byte array.A
Converter that accepts a string as input.Converts string to anyURI
Converts string to base64
Converts a string to a boolean
Converts a string to a date
Converts a string to a dateTime
Converts a string to a dateTimeStamp
Converts a string to a dayTimeDuration
Converts a string to an xs:decimal
Converts from xs;string to a user-defined type derived from a built-in subtype of xs:string
Converts a string to a duration
Converts a string to xs:float
Converts a string to a gDay
Converts a string to a gMonth
Converts a string to a gMonthDay
Converts a string to a gYear
Converts a string to a gYearMonth
Converts a string to hexBinary
Converts a string to an integer
Converts a string to a built-in subtype of integer
Converts from xs:string to xs:language
Converts from xs:string to xs:Name
Converts from xs:string to xs:NCName, xs:ID, xs:IDREF, or xs:ENTITY
Converts from xs:string to xs:NMTOKEN
Converter from string to a derived type (derived from a type other than xs:string),
where the derived type needs to retain the original
string for validating against lexical facets such as pattern.
Converts from xs:string to xs:normalizedString
Converts String to NOTATION
Converts String to QName
Converts from xs:string or xs:untypedAtomic to xs:String
Converts from xs:string to a user-defined type derived directly from xs:string
Converts a string to a time
Converts from xs:string to xs:token
Converter from string to plain union types
Converts from xs:string or xs:untypedAtomic to xs:untypedAtomic
Converts a string to a yearMonthDuration
An abstract Elaborator for expressions that evaluate their result as a single string (that is, as an instance
of
UnicodeString); they may also return null to indicate that the result is an empty sequence.A StringEvaluator is a function that typically encapsulates the logic for
evaluating an expression that returns a string.
fn:string-join(string* $sequence, string $separator)
Implement the XPath string-length() function
Subclass of Literal used specifically for string literals, as this is a common case
This class supports the function string-to-codepoints()
This class converts a string to an xs:double according to the rules in XML Schema 1.0
Convert a string to a double using the rules of XML Schema 1.1
An atomic value of type xs:string.
CharacterIterator is used to iterate over the characters in a string,
returning them as integers representing the Unicode code-point.
An implementation of the UnicodeString interface that wraps an ordinary Java string.
The
Stripper class performs whitespace stripping according to the rules of
the xsl:strip-space and xsl:preserve-space instructions.This class provides an economical representation of a QName triple (prefix, URI, and localname).
Abstract superclass for all element nodes in the stylesheet.
Class StyleNodeFactory.
A cache of the stylesheets (as XsltExecutables) used in calls to the fn:transform function, in a stylesheet or query.
This interface is implemented by all top-level XSL elements that can contain local variable declarations.
A StylesheetFunctionLibrary contains functions defined by the user in a stylesheet.
A stylesheet module represents a module of a stylesheet.
A (compiled) stylesheet package.
A whitespace stripping rule that strips whitespace according to the rules defined for XSLT stylesheets
A SubscriptExpression represents a FilterExpression of the form EXPR[n]
where n is known to be singleton numeric and to be independent of the focus; it does not need to be constant
An elaborator for a "subscript" expression, typically written as
X[$n] where $n is an
integer or a numeric expression.Implements the XPath 2.0 subsequence() function with two arguments
Implements the XPath 2.0 subsequence() function with three arguments
A SubsequenceIterator selects a subsequence of a sequence
This class implements the XPath substring() function
Implements the fn:substring-after() function with the collation already known
Implements the fn:substring-before() function with the collation already known
This interface is implemented by a collation that is capable of supporting
the XPath functions that require matching of a substring: namely contains(),
starts-with, ends-with, substring-before, and substring-after.
Implementation of the fn:sum function
Implementation of Fold class to do the summation in push mode
The XPath id() or element-with-id() function
XPath 2.0 version: accepts any sequence as the first parameter; each item in the sequence
is taken as an IDREFS value, that is, a space-separated list of ID values.
Supplied parameter reference: this is an internal expression used to refer to
the value of the n'th parameter supplied on a template call or a call to an inline function.
A comparer that compares atomic values for equality, with the properties:
- non-comparable types compare false
- NaN compares equal to NaN
Used for comparisons in XQuery Switch expressions
Class to handle comparisons for XQuery switch expressions.
The symbolic name of a component consists of the component kind (e.g.
Subclass of SymbolicName used for function names (including the arity)
Abstract superclass for calls to functions in the standard function library
A call to a system-defined function (specifically, a function implemented as an instance
of
SystemFunction)Subclass representing a system function call that has been optimized; this overrides the
optimize() method to do nothing, thus ensuring that optimization converges.
Elaborator for a system function call, used in cases where the specific function call has no custom support
A Callable that wraps another Callable and a Dynamic Context, in effect acting as a closure that
executes the original callable with a saved context.
System IDs are not held in nodes in the tree, because they are usually the same
for a whole document.
An implementation of Saxon's
Logger interface that writes all messages through to
a supplied java.util.logging.Logger.Implementation of the XSLT system-property() function
Interface representing a Tail Call.
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 valuesElaborator for a tail expression
This class implements the function fn:tail(), which is a standard function in XPath 3.0
TailIterator iterates over a base sequence starting at an element other than the first.
Interface for a simple line-based question/answer dialog with the user
A TeeDestination allows writing to two destinations at once.
TeeOutputter: a SequenceReceiver that duplicates received events to two different destinations
The runtime object corresponding to an xsl:template element in the stylesheet.
A trace listener for XSLT that only handles invocation of template rules; enabled
using saxon:trace="yes" on the xsl:mode declaration
TemplatesHandlerImpl implements the javax.xml.transform.sax.TemplatesHandler
interface.
Saxon implementation of the JAXP Templates interface.
An exception thrown by xsl:message terminate="yes".
A Comparer used for comparing sort keys when data-type="text".
This class generates TEXT output
This class represents a temporary tree whose root document node owns a single text node.
A node in the XML parse tree representing character content.
An iterator that iterates over a file line by line, returning each line as a
StringValueThe built-in rule set used for 1.0 and 2.0, which for document and element nodes does an apply-templates
to children, and for text nodes and attribute nodes copies the node.
This class represents a DOM text node that is the child of a DOM attribute node.
This class is an implementation of the DOM Text and Comment interfaces that wraps a Saxon NodeInfo
representation of a text or comment node.
Define the static context for expressions appearing between curly braces in a text value template.
A text node in an XSLT 3.0 stylesheet that may or may not contain a text value template
Utility class for collecting and reporting timing information, used only under diagnostic control
A value of type xs:time
A code injector that wraps the body of a template or function in a TraceExpression, which causes
the TimingTraceListener to be notified at the start and end of the function/template evaluation
A trace listener that records timing information for templates and functions, outputting this
information as an HTML report to a specified destination when the transformation completes.
A node in the XML parse tree representing an attribute.
The TinyBuilder class is responsible for taking a stream of SAX events and constructing
a Document tree, using the "TinyTree" implementation.
Variant of the TinyBuilder to create a tiny tree in which multiple text nodes or attribute
nodes sharing the same string value economize on space by only holding the value once.
Monitor construction of a TinyTree.
TinyCommentImpl is a comment node in the TinyTree
A node in the XML parse tree representing the Document itself (or equivalently, the root
node of the Document).
A node in the XML parse tree representing an XML element.
A node in a TinyTree representing an XML element, character content, or attribute.
TinyParentNodeImpl is an implementation of a non-leaf node (specifically, an Element node
or a Document node)
TinyProcInstImpl is a node in the TinyTree representing a processing instruction
A node in the XML parse tree representing character content
An element node in the TinyTree that has no attributes or namespace declarations and that
has a single text node child.
Inner class representing the text node; this is created on demand
A data structure to hold the contents of a tree.
This class holds static constants and methods defining the lexical tokens used in
XPath and XQuery, and associated keywords.
This class implements the single-argument tokenize() function introduced in XPath 3.1
This class implements the 3-argument tokenize() function for regular expression matching.
Tokenizer for expressions and inputs.
Class to perform lowercase conversion.
Provides an iterable over a stack that iterates in order from top to bottom.
Class to perform uppercase conversion.
This class supports the XPath 2.0 function trace().
A construct whose execution can be notified to a TraceListener.
A construct whose execution can be notified to a TraceListener.
A "trace" clause in a FLWOR expression, added by a TraceCodeInjector for diagnostic
tracing, debugging, profiling or similar purposes.
This class represents the tuple stream delivered as the output of a trace clause in a
FLWOR expression.
This class represents the tuple stream delivered as the output of a trace clause in a
FLWOR expression.
A code injector that wraps every expression (other than a literal) in a TraceExpression, which causes
a TraceListener to be notified when the expression is evaluated
A class which implements efficient and thread-safe multi-cast event
dispatching for the TraceListener evants.
A wrapper expression used to trace expressions in XSLT and XQuery.
This interface defines methods that are called by Saxon during the execution of
a stylesheet or query, if tracing is switched on.
A filter that can be inserted into a Receiver pipeline to trace the events that pass through.
This Transform class is the command-line entry point to the Saxon XSLT Processor.
A TransformerFactory instance can be used to create Transformer and Template
objects.
TransformerHandlerImpl implements the javax.xml.transform.sax.TransformerHandler
interface.
Saxon implementation of the JAXP Transformer interface.
TransformerReceiver is similar in concept to the JAXP TransformerHandler,
except that it implements Saxon's Receiver interface rather than the standard
SAX2 interface.
This class implements the function transform(), which is a standard function in XPath 3.1
Implement the XPath translate() function
Treat Expression: implements "treat as data-type ( expression )".
This class supports the XPath 2.0 functions exactly-one(), one-or-more(), zero-or-one().
This interface represents information about a tree as a whole.
A TreeModel represents an implementation of the Saxon NodeInfo interface, which itself
is essentially an implementation of the XDM model defined in W3C specifications (except
that Saxon's NodeInfo understands the 13 XPath axes, rather than merely supporting
parent and child properties).
A TreeReceiver acts as a bridge between a SequenceReceiver, which can receive
events for constructing any kind of sequence, and an ordinary Receiver, which
only handles events relating to the building of trees.
This class implements a try/catch expression.
A tuple, as it appears in an XQuery tuple stream handled by extended FLWOR expressions.
A tuple expression is an expression that returns a FLWOR tuple.
Abtract class representing a tuple stream (used to evaluate a FLWOR expression) in pull mode
(where the consumer of tuples activates the provider of those tuples)
Abtract class representing a tuple stream (used to evaluate a FLWOR expression) in push mode
(where the provider of tuples activates the consumer of those tuples)
Twine16 is a Unicode string consisting entirely of codepoints in the range 0-65535
(that is, the basic multilingual plane), excluding surrogates.Twine24 is Unicode string that accommodates any codepoint value up to 24 bits.Twine8 is Unicode string whose codepoints are all in the range 0-255 (that is, Latin-1).Interface that accepts a a sequence of Unicode codepoints.
An iterator over a pair of objects (typically sub-expressions of an expression)
This class contains static information about types and methods for constructing type codes.
Manager for xsl:item-type declarations in a stylesheet.
This class supports the XSLT fn:type-available() function.
This class provides Saxon's type checking capability.
This class provides type checking capability with XPath 1.0 backwards compatibility enabled.
A filter on the push pipeline that performs type checking, both of the item type and the
cardinality.
A
StreamSource augmented with ContentType information,
which potentially provides the media type and encodingThis class exists to provide answers to questions about the type hierarchy.
This class implements the DOM TypeInfo interface as a wrapper over the Saxon SchemaType
interface.
A TypeStrippedDocument represents a view of a real Document in which all nodes are
untyped
A TypeStrippedNode is a view of a node, in a virtual tree that has type
annotations stripped from it.
This class implements (an approximation to) the UCA Collation Algorithm
relying solely on the built-in Java support (that is, without using the
ICU library).
Unary Expression: an expression taking a single operand expression
An UnboundFunctionLibrary is not a real function library; rather, it is used to keep track of function calls
that cannot yet be bound to a known declared function, but will have to be bound when all user-declared functions
are available.
When implementing certain interfaces Saxon is not able to throw a checked exception because
the interface definition does not allow it.
This class is used when the decision on which serialization method to use has to be delayed until the first
element is read.
An UndeclaredVariable object is created when a reference is encountered to a variable
that has not yet been declared.
PullProvider is Saxon's pull-based interface for reading XML documents and XDM sequences.
This singleton class provides knowledge of the names and contents of Unicode character blocks,
as referenced using the
\p{IsXXXXX} construct in a regular expression.Builder class to construct a UnicodeString by appending text incrementally
A UnicodeString containing a single codepoint
UnicodeNormalizer: This ProxyReceiver performs unicode normalization on the contents
of attribute and text nodes.
A UnicodeString is a sequence of Unicode codepoints that supports codepoint addressing.
A StringEvaluator is a function that typically encapsulates the logic for
evaluating an expression that returns a string, in the form of a
UnicodeStringInterface that accepts strings in the form of
UnicodeString objects,
which are written to some destination.An UnicodeWriterResult encapsulates a UnicodeWriter to act as the destination for a transformation
or serialization
Implementation of
UnicodeWriter that converts Unicode strings to ordinary
Java strings and sends them to a supplied WriterFunction to test castability to a union type
Function to perform a cast to a union type
An enumeration representing a nodeset that is a union of two other NodeSets.
A multi-way union delivering the sorted results obtained from a number
of sorted input iterators
A pattern formed as the union (or) of two other patterns
A QNameTest that is the union of a number of supplied QNameTests
Interface representing a union type.
Interface that accepts a string in the form of a sequence of CharSequences,
which are conceptually concatenated (though in some implementations, the final
string may never be materialized in memory)
The UniversalPattern matches everything
The class is an implementation of the generic Resource object (typically an item in a collection)
representing a resource whose type is not yet known - typically because it uses an unregistered
file extension.
XPath 2.0 unordered() function
Implements the unparsed-entity-uri() function defined in XSLT 1.0
and the unparsed-entity-public-id() function defined in XSLT 2.0
This class is used to represent unparsed entities in the PullProvider interface
Implementation of fn:unparsed-text() - with one argument or two
Abstract superclass containing common code supporting the functions
unparsed-text(), unparsed-text-lines(), and unparsed-text-available()
Class UnparsedTextIterator, iterates over a file line by line
This class implements th interface Resource.
An UnparsedTextURIResolver accepts an absolute URI and optionally an encoding name as input,
and returns a Reader as its result.
An enumeration defining possible strategies for resolving unprefixed element names appearing
as name tests in the steps of a path expression or XSLT match pattern
This class has a singleton instance which represents the complex type xdt:untyped,
used for elements that have not been validated.
AtomizingIterator returns the atomization of an underlying sequence supplied
as an iterator.
A specialist comparer that implements the rules for comparing an untypedAtomic value
(always the first operand) to a numeric value (always the second operand)
An UntypedSequenceConverter is an expression that performs a cast on each member of
a supplied sequence that is an untypedAtomic value, while leaving other items unchanged
A Converter that converts untyped atomic values to the required type, while
leaving other values unchanged
Elaborator for an UntypedSequenceConverter
An UpdateAgent is a callback class that is called to handle a document after it has been updated.
Abstract evaluator for XQuery Update expressions.
Interface implemented by XQuery Update expressions, to evaluate an update expression by
adding update primitives to a supplied pending update list.
This class implements the fn:upper-case() function
This interface defines a method for checking whether a string is considered to be a valid URI.
Implement the fn:uri-collection() function (new in XQuery 3.0/XSLT 3.0).
A set of query parameters on a URI passed to the collection() or document() function
A FilenameFilter that tests file names against a regular expression
This instruction corresponds to a single QName appearing within a use-attribute-sets attribute on a
literal result element, xsl:element, or xsl:copy instruction.
Describes an xsl:use-package requirement from within a package,
in terms of a name and a set of version ranges
This object represents the compiled form of a user-written function
(the source can be either an XSLT stylesheet function or an XQuery function).
This class represents a call to a user-defined function in the stylesheet or query.
Run-time object representing a formal argument to a user-defined function
A UserFunctionReference is an expression in the form local:f#1 where local:f is a user-defined function.
A BoundUserFunction represents a user-defined function seen as a component.
A reference to a function; typically a forwards reference to a user-defined function in XQuery
that has not yet been compiled.
Function signatures (and pointers to implementations) of the functions available for use
in static expressions (including use-when expressions) in XSLT 3.0 stylesheets
This is a filter inserted into the input pipeline for processing stylesheet modules, whose
task is to evaluate use-when expressions and discard those parts of the stylesheet module
for which the use-when attribute evaluates to false.
This class implements the static context used for evaluating use-when and other
static expressions in XSLT 3.0
A new instance of this class is created for each use-when expression encountered; there are
therefore no issues with reusability.
A class to hold some static constants and methods associated with processing UTF16 and surrogate pairs
This class defines properties of the UTF-8 character set
Specialized buffering UTF-8 writer.
A UType is a union of primitive (atomic, node, or function) item types.
Interface implemented by instructions that have validation and type attributes
This class contains constants and static methods to manipulate the validation
property of a type.
This exception indicates a failure when validating an instance against a type
defined in a schema.
This exception indicates a failure when validating an instance against a type
defined in a schema.
Enumeration class defining different schema validation (or construction) modes
This class represents a collection of parameter values for use in schema validation;
it defines values for the parameters declared using the saxon:param XSD extension.
Defines a class that is notified of validation statistics at the end of a validation episode
ValueComparison: a boolean expression that compares two atomic values
for equals, not-equals, greater-than or less-than.
Elaborator for a value comparison (such as
A eq B), including the case
where a general comparison is reduced to a value comparison by the optimiserAn xsl:value-of element in the stylesheet.
ValueTailIterator iterates over a base sequence starting at an element other than the first.A Valve is a general-purpose component for use in a pipeline of receivers.
Variable reference: a reference to a variable.
Implementation of vendor functions in the Saxon namespace, available in Saxon-HE because they
are used internally.
Implementation of the function saxon:array-as-sequence-of-maps(array)
Implement saxon:dynamic-error-info
Implement saxon:has-local-namespaces.
Implement saxon:has-uniform-namespaces.
Implement saxon:is-whole-number
Implementation of the function saxon:map-as-sequence-of-maps(array)
An expression representing a nodeset that is a union, difference, or
intersection of two other NodeSets
Elaborator for a Venn expression: that is
A union B, A intersect B,
or A except BAbstract pattern formed as the union, intersection, or difference of two other patterns;
concrete subclasses are used for the different operators.
The Version class holds the SAXON version information.
This class represents the combination of an XSLT package name (that is, a URI) and a version
number
Holds the values of an accumulator function for a virtual copy of a document (where the accumulator values
are copies of those on the underlying document)
This class represents a node that is a virtual copy of another node: that is, it behaves as a node that's the
same as another node, but has different identity.
VirtualCopier implements the XPath axes as applied to a VirtualCopy node.
This interface is implemented by NodeInfo implementations that act as wrappers
on some underlying tree.
Implementation of TreeInfo for a Virtual Copy tree
This class represents a virtual copy of a node with type annotations stripped
Enumeration class giving the different visibility levels defined for components in XSLT 3.0
Indicates where the visibility property of a component came from
A "where" clause in a FLWOR expression
This class represents the tuple stream delivered as the output of a where clause in a
FLWOR expression: that is, it returns all the tuples in its input stream that satisfy
a specified predicate.
This class represents the tuple stream delivered as the output of a where clause in a
FLWOR expression: that is, it supplies all the tuples in its input stream that satisfy
a specified predicate.
A compiled xsl:where-populated instruction (formerly xsl:conditional-content).
This class acts as a filter on a push pipeline, allowing through only those items
that are deemed non-empty according to the rules of the xsl:where-populated
instruction.
A "where" clause in a FLWOR expression
This class represents the tuple stream delivered as the output of a while clause in a
FLWOR expression: that is, it returns all the tuples in its input stream that satisfy
a specified predicate, until it finds one that doesn't.
This class represents the tuple stream delivered as the output of a while clause in a
FLWOR expression: that is, it supplies all the tuples in its input stream that satisfy
a specified predicate until it finds one that doesn't.
This class provides helper methods and constants for handling whitespace
An iterator that splits a string on whitespace boundaries, corresponding to the XPath 3.1 function tokenize#1
This abstract class represents a couple of different implementations of strings
containing whitespace only.
WhitespaceStrippingPolicy is class defining the possible policies for handling
whitespace text nodes in a source document.
A node in the XML parse tree representing a text node with compressed whitespace content
Implements an XQuery 3.0 sliding or tumbling window clause within a FLWOR expression
Information about a window: the items making up the window, as well as the variables relating to the
start and end of the window, and the status of the winoow in relation to the processing of the current
input sequence.
Implement a sliding or tumbling window clause of a FLWOR expression in tuple-pull mode.
Implement a sliding or tumbling window clause of a FLWOR expression in tuple-push mode.
An object derived from a xsl:with-param element in the stylesheet.
Callback to create a VirtualNode that wraps a given NodeInfo
A WrappingIterator delivers wrappers for the nodes delivered
by its underlying iterator.
A Java Iterator which wraps a supplied unfailing SequenceIterator
An array in the XDM data model.
The class XdmAtomicValue represents an item in an XPath sequence that is an atomic value.
This class contains a number of static methods that deliver implementations of the
Collector
interface suitable for use with streams processing XDM nodes and other items.Unchecked exception that occurs when a collector method such as
XdmCollectors.asAtomic() or XdmCollectors.asOptionalNode()
is called, and the sequence contains more than one item.An
XdmDestination is a Destination in which an XdmNode
is constructed to hold the output of a query or transformation:
that is, a tree using Saxon's implementation of the XDM data modelThe class
XdmEmptySequence represents an empty sequence in the XDM Data Model.The class XdmExternalObject represents an XDM item that wraps an external (Java or .NET) object.
The class XdmFunctionItem represents a function item
The class XdmItem represents an item in a sequence, as defined by the XDM data model.
A map in the XDM data model.
This class represents a node in the XDM data model.
Enumeration class defining the seven kinds of node defined in the XDM model
An iterator over an XPath sequence.
XdmStream extends the capabilities of the standard JDK Stream class.A value in the XDM data model.
XHTMLEmitter is an Emitter that generates XHTML 1 output.
XHTML5Emitter is an Emitter that generates XHTML 5 output.
Filter to change elements in the XHTML, SVG, or MathML namespaces so they have no prefix (that is,
to make these the default namespace).
This class performs URI escaping for the XHTML output method.
This class is used on the serialization pipeline to check that the document conforms
to XML 1.0 rules.
This module contains data regarding the classification of characters in XML 1.0 and XML 1.1, and a number
of interrogative methods to support queries on this data.
XMLEmitter is an Emitter that generates XML output
to a specified destination.
XMLIndenter: This ProxyReceiver indents elements, by adding character data where appropriate.
An unchecked exception, triggered when a user-supplied
ErrorReporter requests
that processing should be abortedThe XmlProcessingError class contains information about an error detected during
compilation or execution of a stylesheet, query, XPath expression, or schema
The XmlProcessingException class is a concrete implementation of the
XmlProcessingError
interface that wraps an XPathException object.The XmlProcessingIncident class is a concrete implementation of the
XmlProcessingError
interface that holds all the required information internally.The class is an implementation of the generic Resource object (typically an item in a collection)
representing an XML document
XMLStreamWriterDestination is a s9api
Destination that writes output to a supplied XMLStreamWriterImplement the XML to JSON conversion as a built-in function - fn:xml-to-json()
The root node of an XPath tree.
A node in the XML parse tree representing an XML element, character content,
or attribute.
This interface must be implemented by any third-party object model that can
be wrapped with a wrapper that implements the Saxon Object Model (the NodeInfo interface).
XOMWriter is a Receiver that constructs a XOM document from the stream of events
Function signatures (and pointers to implementations) of the functions defined in XPath 2.0
Function signatures (and pointers to implementations) of the functions defined in XPath 3.0 without the
Higher-Order-Functions feature
Function signatures (and pointers to implementations) of the functions defined in XPath 3.1 without the
Higher-Order-Functions feature
This interface sometimes represents an XPath atomic value where the Java comparison semantics (using the
compareTo method) match the XPath equality and ordering semantics; and sometimes it represents
a surrogate for an XPath atomic value, chosen so that the Java comparison semantics match the XPath rules.An
XPathCompiler object allows XPath queries to be compiled.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.
The ThreadManager is used to manage asynchronous execution of xsl:result-document instructions in Saxon-EE.
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.
Container for cached value of the last() function.
This object represents the dynamic XPath execution context for use in the free-standing Saxon XPath API.
This class provides a native Saxon API for free-standing evaluation of XPath expressions.
XPathEvaluator implements the JAXP API for standalone XPath processing (that is,
executing XPath expressions in the absence of an XSLT stylesheet).
XPathException is used to indicate an error (static or dynamic) in an XPath expression,
or in a query or stylesheet.
Subclass of XPathException used to report circularities
Subclass of XPathException used to report stack overflow
An XPathExecutable represents the compiled form of an XPath expression.
This class is a representation of an XPath Expression for use with the
XPathEvaluator class.The JAXP XPathExpression interface represents a compiled XPath expression that can be repeatedly
evaluated.
Saxon implementation of the JAXP 1.3 XPathFactory
This class is an expression that calls an external function supplied using the
JAXP XPathFunction interface
The XPathFunctionLibrary is a FunctionLibrary that supports binding of XPath function
calls to instances of the JAXP XPathFunction interface returned by an XPathFunctionResolver.
Parser for XPath expressions and XSLT patterns.
A nested location: for use with XPath expressions and queries nested within some
larger document.
An XPathSelector represents a compiled and loaded XPath expression ready for execution.
This interface defines methods that must be provided when Saxon's free-standing XPath API is used.
An object representing an XPath variable for use in the standalone XPath API.
An
XQueryCompiler object allows XQuery 1.0 queries to be compiled.An
XQueryEvaluator represents a compiled and loaded query ready for execution.An XQueryExecutable represents the compiled form of a query.
XQueryExpression represents a compiled query.
A user-defined function in an XQuery module
Function annotation handler for annotations in the built-in namespace
http://www.w3.org/2012/xquery.
XQueryFunctionBinder is an extension of the FunctionLibrary interface used for function libraries
that contain user-written XQuery functions.
An XQueryFunctionLibrary is a function library containing all the user-defined functions available for use within a
particular XQuery module: that is, the functions declared in that module, and the functions imported from other
modules.
Inner class containing information about a reference to a function whose declaration
has not yet been encountered.
This class defines extensions to the XPath parser to handle the additional
syntax supported in XQuery
A code injector designed to support the -T tracing option in XQuery
A Simple trace listener for XQuery that writes messages (by default) to System.err
Represents an xsl:accept element in an XSLT 3.0 package manifest.
Handler for xsl:accept and xsl:expose elements in stylesheet.
Handler for xsl:accumulator elements in a stylesheet (XSLT 3.0).
Handler for xsl:accumulator-rule elements in a stylesheet (XSLT 3.0).
An xsl:analyze-string elements in the stylesheet.
An xsl:apply-imports element in the stylesheet
An xsl:apply-templates element in the stylesheet
An xsl:assert element in an XSLT 3.0 stylesheet.
xsl:attribute element in stylesheet.
An xsl:attribute-set element in the stylesheet.
A xsl:break element in the stylesheet
Abstract class containing functionality common to xsl:break and xsl:next-iteration
An xsl:call-template element in the stylesheet
Handler for xsl:catch elements in stylesheet.
An xsl:character-map declaration in the stylesheet.
An xsl:choose element in the stylesheet.
An xsl:choose or xsl:switch element in the stylesheet.
An xsl:comment elements in the stylesheet.
An xsl:context-item element in the stylesheet.
Handler for xsl:copy elements in stylesheet.
An xsl:copy-of element in the stylesheet.
Handler for xsl:decimal-format elements in stylesheet.
An xsl:document instruction in the stylesheet.
An xsl:element element in the stylesheet.
Handler for xsl:evaluate elements in XSLT 3.0 stylesheet.
Represents an xsl:expose element in an XSLT 3.0 package manifest.
xsl:fallback element in stylesheet.
Handler for xsl:for-each elements in stylesheet.
Handler for xsl:for-each-group elements in stylesheet.
Handler for xsl:fork elements in XSLT 3.0 stylesheet.
Handler for xsl:function elements in stylesheet (XSLT 2.0).
Abstract class to represent an xsl:include or xsl:import element in the stylesheet.
This class defines common behaviour across xsl:variable, xsl:param, and xsl:with-param
An xsl:global-context-item declaration in the stylesheet
An xsl:param element representing a global parameter (stylesheet parameter) in the stylesheet.
Handler for xsl:variable elements appearing as a child of xsl:stylesheet.
Handler for xsl:if elements in stylesheet.
xsl:import element in the stylesheet.
Compile-time representation of an xsl:import-schema declaration
in a stylesheet
xsl:include element in the stylesheet.
The class implements a xsl:item-type declaration in a stylesheet.
Handler for xsl:iterate elements in stylesheet.
Handler for xsl:key elements in stylesheet.
Common superclass for XSLT elements whose content template produces a text
value: xsl:text, xsl:value-of, xsl:attribute, xsl:comment, xsl:namespace, and xsl:processing-instruction
An xsl:param element representing a local parameter (template or function parameter) in the stylesheet.
Handler for xsl:variable elements acting as local variable declarations in a stylesheet.
Handler for xsl:map instructions in an XSLT 3.0 stylesheet.
Handler for xsl:map-entry instructions in an XSLT 3.0 stylesheet.
Handler for xsl:matching-substring and xsl:non-matching-substring elements in stylesheet.
Handler for xsl:merge elements in stylesheet.
An xsl:merge-key element in the stylesheet.
Implements the xsl:merge-source element available in XSLT 3.0 as a child of xsl:merge.
An xsl:message element in the stylesheet.
Handler for xsl:mode elements in stylesheet.
Class representing xsl:stylesheet, xsl:transform, or xsl:package
An xsl:namespace element in the stylesheet.
An xsl:namespace-alias element in the stylesheet.
An xsl:next-iteration element in the stylesheet
An xsl:next-match element in the stylesheet
An xsl:number element in the stylesheet.
An xsl:on-completion element in the stylesheet (XSLT 3.0).
An xsl:on-empty element in the stylesheet.
An xsl:on-non-empty element in the stylesheet.
A function library that recognizes the function name "xsl:original", which may appear within xsl:override
Handler for xsl:otherwise elements in stylesheet.
An xsl:output element in the stylesheet.
An xsl:output-character element in the stylesheet.
Represents an xsl:override element in a package manifest.
Handler for xsl:package elements.
Handler for xsl:perform-sort elements in stylesheet (XSLT 2.0).
An xsl:preserve-space or xsl:strip-space elements in stylesheet.
An xsl:processing-instruction element in the stylesheet.
An xsl:result-document element in the stylesheet.
An xsl:sequence element in the stylesheet.
An xsl:sort element in the stylesheet.
Handler for xsl:source-document element in XSLT 3.0 stylesheet.
An xsl:stylesheet or xsl:transform element in the stylesheet.
An xsl:switch element in the stylesheet (XSLT 4.0).
Function signatures (and pointers to implementations) of the functions defined in XSLT 3.0.
An
Xslt30Transformer represents a compiled and loaded stylesheet ready for execution.An XsltCompiler object allows XSLT stylesheets to be compiled.
This class is an extension of the Controller class, used when executing XSLT stylesheets.
An xsl:template element in the style sheet.
An XsltExecutable represents the compiled form of a stylesheet.
Inner class containing information about a global parameter to a compiled stylesheet
Handler for xsl:text elements in stylesheet.
An XsltPackage object represents the result of compiling an XSLT 3.0 package, as
represented by an XML document containing an
xsl:package element.Handler for xsl:try elements in stylesheet.
A code injector that wraps every expression (other than a literal) in a TraceExpression, which causes
a TraceListener to be notified when the expression is evaluated
A Simple trace listener for XSLT that writes messages (by default) to System.err
An
XsltTransformer represents a compiled and loaded stylesheet ready for execution.Handler for xsl:use-package elements in stylesheet.
An xsl:value-of element in the stylesheet.
Handler for xsl:when elements in stylesheet.
An xsl:where-populated element in the stylesheet.
An xsl:with-param element in the stylesheet.
A value of type xs:yearMonthDuration (or a subtype thereof).
An implementation of sequences as a list-of-lists, where the sublists at the
end of the master list tend to be small, and the sublists at the start tend
to be larger (or the other way around if the list is built by prepending items
rather than appending them).
A (Java) Iterator over a ZenoChain
An immutable XDM sequence implemented as a ZenoChain.
A SequenceIterator over a ZenoSequence
A ZenoString is an implementation of UnicodeString that comprises a list
of segments representing substrings of the total string.
A sequence value implemented extensionally.
A value that is a sequence containing zero or one items.