All Classes and Interfaces
Class
Description
This element is a surrogate for an extension element (or indeed an xsl element)
for which no implementation is available.
Abstract superclass containing helper methods for various implementations of IntSet
Class AbstractNumberer is a base implementation of Numberer that provides language-independent
default numbering
This supports the xsl:number element.
An abstract and configurable implementation of the StaticContext interface,
which defines the static context of an XPath expression.
This is the standard trace listener used when the -T option is specified on the command line.
AbstractVirtualNode is an abstract superclass for VirtualNode implementations in which
the underlying node is itself a Saxon NodeInfo.
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.
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().
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.
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
A Comparer that treats strings as an alternating sequence of alpha parts and numeric parts.
Mapping function that maps the sequence of matching/non-matching strings to the
sequence delivered by applying the matching-substring and non-matching-substring
expressions respectively to each such string
An xsl:analyze-string element in the stylesheet.
This class enumerates the ancestor:: or ancestor-or-self:: axes,
starting at a given node.
This is a special pattern that matches the "anchor node"; it is not used for XSLT patterns,
but for the selectors that arise when evaluating XPath expressions in streaming mode; the anchor
node is the context node for the streamed XPath evaluation.
An AnyChildNodePattern is the pattern node(), which matches any node except a root node,
an attribute node, or a namespace node: in other words, any node that is the child of another
node.
An ItemType representing the type function().
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.
Defines a CharSequence to which characters can be appended
An xsl:apply-imports element in the stylesheet
An instruction representing an xsl:apply-templates element in the stylesheet
Arithmetic Expression: an expression using one of the operators
plus, minus, multiply, div, idiv, mod.
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.ArrayIterator is used to enumerate items held in an array.
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.
Interface representing an object that can be used to compare two XPath atomic values for equality or
for ordering.
An AtomicSequenceConverter is an expression that performs a cast on each member of
a supplied sequence
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.
An Atomizer is an expression corresponding essentially to the fn:data() function: it
maps a sequence by replacing nodes with their typed values
Implement the mapping function.
AtomizingIterator returns the atomization of an underlying sequence supplied
as an iterator.
AttributeCollection represents the collection of attributes available on a particular element
node.
AttributeCollectionImpl is an implementation of both the SAX2 interface Attributes
and the Saxon equivalent AttributeCollection.
Abstract class for fixed and computed attribute constructor expressions
AttributeEnumeration is an enumeration of all the attribute nodes of an Element.
AttributeEnumeration is an iterator over all the attribute nodes of an Element.
A node in the "linked" tree representing an attribute.
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.
This class supports the XSLT element-available, function-available, and type-available functions.
Implementation of the fn:avg function
An axis, that is a direction of navigation in the document structure.
This is an enumeration class containaing 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 AxisIterator.
An AxisExpression is always obtained by simplifying a PathExpression.
A SequenceIterator is used to iterate over a sequence.
A SequenceIterator is used to iterate over a sequence.
This class wraps any SequenceIterator as an AxisIterator.
A value of type xs:base64Binary
This class supports the base-uri() function in XPath 2.0
An integer value: note this is a subtype of decimal in XML Schema, not a primitive type.
A Comparable that performs comparison of BigInteger values either with other
BigInteger values or with other representations of XPath numeric values
Binary Expression: a numeric or boolean expression consisting of the
two operands and an operator
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.
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.
Iterate over the instructions in a Block, concatenating the result of each instruction
into a single combined sequence.
Iterate over the instructions in the Block, concatenating the result of each instruction
into a single combined sequence.
Boolean expression: two truth values combined using AND or OR.
This class supports the XPath functions boolean(), not(), true(), and false()
A boolean XPath value
The class is an EventIterator that handles the events arising from a document node constructor:
that is, the start/end event pair for the document node, bracketing a sequence of events for the
content of the document.
The class is an EventIterator that handles the events arising from an element constructor:
that is, the start/end event pair for the element node, bracketing a sequence of events for the
content of the element.
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 completionA 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 implement the built-in
list types NMTOKENS, ENTITIES, IDREFS.
Defines 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)
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
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.
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
CardinalityCheckingIterator 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 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 )".
Casting Expression: abstract superclass for "cast as X" and "castable as X", which share a good deal of logic
Data for Regular expression character categories.
CDATAFilter: This ProxyEmitter 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 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.
This is an implementation of the JDK 1.4 CharSequence interface: it implements
a CharSequence as a view of an array.
Compiled representation of an xsl:choose or xsl:if element in the stylesheet.
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
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 namecode and a reference to the NamePool from which
it 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
XPath 2.0 codepoint-equal() function.
This class supports the function codepoints-to-string
An AtomicComparer used for comparing strings, untypedAtomic values, and URIs using a collation.
Abstract superclass for all functions that take an optional collation argument
Interface implemented by SaxonCollation, which is not available in Saxon-HE
This object maps collation URIs to collations.
A CollationURIResolver accepts a collation name as input, and returns
a collation (represented by a
StringCollator as output.Implement the fn:collection() function.
This interface defines a CollectionURIResolver.
A CombinedNodeTest combines two nodetests 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 extension functions in the
http://exslt.org/common namespace.
A comparer for comparing two "ordinary" atomic values, where the values implement the Comparable
interface and the equals() method with the appropriate XPath semantics.
XSLT 2.0 compare() function
This class implements a comparison of a numeric value to an integer constant using one of the operators
eq, ne, lt, gt, le, ge.
Interface implemented by expressions that perform a comparison
An object used as a comparison key.
This class exists to hold information associated with a specific XSLT compilation episode.
Abtract class representing a function call that is always rewritten at compile-time:
it can never be executed
This class is used for generating complex content, that is, the content of an
element or document node.
The ComplexContentProcessor is an EventIterator that deals with the events occurring between
a startElement and endElement (or startDocument and endDocument) according to the XSLT/XQuery
rules for constructing complex content.
A complex type as defined in XML Schema: either a user-defined complex type, or xs:anyType, or xs:untyped.
This class supports the get_X_from_Y functions defined in XPath 2.0
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.
Implementation of the fn:concat() function
A ConditionalPattern tests a node against one of a number of patterns depending on the value of a condition.
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.
This class holds details of user-selected configuration options for a set of transformations
and/or queries.
This 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
An item type constructed by the ItemTypeFactory (as distinct from one that is predefined)
This class is not user-visible.
The ConstructorFunctionLibrary represents the collection of constructor functions for atomic types.
A Container is something other than an expression that can act as the container of an expression.
Implements the fn:contains() function
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 Locator, used to supply location information to the ContentHandler.
NodeTest is an interface that enables a test of whether a node matches particular
conditions.
This class represents the expression "(dot)", which always returns the context item.
ContextMappingFunction is an interface that must be satisfied by an object passed to a
ContextMappingIterator.
ContextMappingIterator merges a sequence of sequences into a single flat
sequence.
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 is 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 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 does nothing except change the type annotation of the value.
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
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 to a required type of xs:double
Converter that implements the promotion rules to a required type of xs:float
Converts QName to Notation
Converts string to base64
Converts any value to a string
Converts any value to untyped atomic
Converter that operates in two phases, via an intermediate type
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.
Non-instantiable class to define options for the
NodeInfo.copy(net.sf.saxon.event.Receiver, int, int) methodImplementation of the fn:count function
Implement the XSLT current() function
This class implements the XPath 2.0 functions
current-date(), current-time(), and current-dateTime(), as
well as the function implicit-timezone().
Implements the XSLT function current-group()
Implements the XSLT function current-grouping-key()
The expression is generated when compiling the current() function in XSLT.
Implement XPath function fn:data()
This element represents a top-level element in a user-defined namespace,
or a child/descendant of such an element.
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 DateTime
A value of type Date.
A value of type xs:dayTimeDuration
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).
A decimal value
A Comparable that performs comparison of a DecimalValue either with another
DecimalValue or with some other representation of an XPath numeric value
This interface represents the union of global variable declarations and function declarations in XQuery
modules
The object represents a declaration (that is, a top-level element) in a stylesheet.
This class takes a sequence of pull events and turns it into fully-decomposed form, that is, it
takes and document and element nodes in the sequence and turns them into a subsequence consisting of a
start element|document event, a content sequence, and an end element|document event, recursively.
This implementation of the XPath static context is mainly used when XPath expressions are hosted
in other Saxon processing contexts, for example in xsl:evaluate, or in XSD assertions
XSLT 2.0 deep-equal() function.
Implement the XPath 2.0 default-collation() function
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.
A Destination represents a place where XML can be sent.
This class provides a diagnostic wrapper for the real NamePool.
An enumeration representing a nodeset that is teh difference of two other NodeSets.
The XPath 2.0 distinct-values() function
Iterator class to return the distinct values in a sequence
This interface is implemented by instructions that can be executed in streaming mode.
Implement the fn:doc() function - a simplified form of the Document function
Implement the fn:doc-available() function
A saxon:doctype element in the stylesheet.
A document builder holds properties controlling how a Saxon document tree should be built, and
provides methods to invoke the tree construction.
Deprecated.
since 9.3.
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).
This interface represents a document node as defined in the XPath 2.0 data model.
An instruction to create a document node.
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.
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.
This class supports the document-uri() function
The document node of a tree implemented as a wrapper around a DOM Document.
The root node of an XPath tree.
The root node of an XPath tree.
The root node of an XPath tree.
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 JDOM 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
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.
A value of type xs:duration
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.
This class is an implementation of XPathContext used when evaluating constant sub-expressions at
compile time.
This class supports the XSLT element-available and function-available functions.
An instruction that creates an element node.
ElementImpl implements an element with no attributes or namespace declarations.
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:exists function
An AxisIterator over an empty sequence
This class is an EventIterator over an empty sequence.
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.
NodeTest is an interface that enables a test of whether a node has a particular
name and type.
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.
Pull event representing the end of a document
Pull event representing the end of an element node
Implements the fn:ends-with() function
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.
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.
This class has a singleton instance which represents the XML Schema 1.1 built-in type xs:error
This class supports the functions encode-for-uri() and iri-to-uri()
This class is an EventIterator that filters a stream of pull events setting
the type annotation on element nodes to xs:untyped and on attribute nodes to
xs:untypedAtomic
An iterator over a sequence of events
This class maps a SequenceIterator to an EventIterator, by simply returning the items in the sequence
as PullEvents.
Class to read pull events from an EventIterator and write them to a Receiver
EventMappingFunction is an interface that must be satisfied by an object passed to an
EventMappingIterator.
MappingIterator merges a sequence of sequences into a single sequence.
An implementation of the JAXP Source class that supplies a document in the form of a stream
of push events sent to a Receiver
An EventStackIterator is an EventIterator that delivers a flat sequence of PullEvents
containing no nested EventIterators
This class bridges EventIterator events to XMLStreamReader (Stax) events.
EveryItemMappingIterator applies a mapping function to each item in a sequence.
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
Interface supported by an XPath expression.
An ExpressionContext represents the context for an XPath expression written
in the stylesheet.
Class to hold details of the location of an expression, of an error in a source file, etc.
Parser for XPath expressions and XSLT patterns.
A Container used on a temporary basis to hold an expression while it is being parsed
This class handles the display of an abstract expression tree in an XML format
with some slight resemblence 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.
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.
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 Java object returned by
an extension function, or supplied as an external variable/parameter.
A simple implementation of a class similar to StringBuffer.
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
ProcessorFilter is an XMLFilter (a SAX2 filter) that performs a transformation
taking a SAX stream as input and producing a SAX stream as output.
A FilterExpression contains a base expression and a filter predicate, which may be an
integer expression (positional filter), or a boolean expression (qualifier)
Factory class to create a ProxyReceiver which filters events on a push pipeline
A CompiledFilterIterator filters an input sequence using a filter expression.
Subclass to handle the common special case where it is statically known
that the filter cannot return a numeric value
This is a marker interface used to identify nodes that contain a namepool fingerprint.
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 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.
This is a utility class that handles formatting of numbers as strings.
A numeric (single precision floating point) value
This class represents a FLWOR expression, evaluated using tuple streams
Iterate over the following axis starting at a given node.
This class implements the upper-case() and lower-case() functions
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.
Handler for xsl:for-each-group elements in stylesheet.
A ForExpression maps an expression over a sequence.
The EventMappingAction represents the action to be taken for each item in the
source sequence.
The MappingAction represents the action to be taken for each item in the
source sequence.
Implement the format-date(), format-time(), and format-dateTime() functions
in XSLT 2.0 and XQuery 1.1.
XSLT 2.0 implementation of format-number() function - removes the dependence on the JDK.
This class implements the function function-arity(), which is a standard function in XQuery 1.1
This class supports the XSLT element-available and function-available functions.
Abstract superclass for calls to system-defined and user-defined functions
XDM 3.0 introduces a third kind of item, beyond nodes and atomic values: the function item.
Higher-order functions in XPath 3.0 introduce a third kind of Item, namely a Function Item.
A FunctionLibrary handles the binding of function calls in XPath (or XQuery) expressions.
A FunctionLibraryList is a list of FunctionLibraries.
This class implements the function function-name(), which is a standard function in XQuery 1.1
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.
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.
This class defines common behaviour across xsl:variable, xsl:param, and xsl:with-param;
also saxon:assign
This class supports the generate-id() function
An AtomicComparer used for comparing atomic values of arbitrary item types.
Generically sorts arbitrary shaped data (for example multiple arrays, 1,2 or 3-d matrices, and so on) using a
quicksort or mergesort.
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.
Class to hold compile-time information about an XQuery global variable
or parameter.
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 returned a SequenceValue containing all the items
in the sequence.
A value that exists in memory and that can be directly addressed
A GroupAdjacentIterator iterates over a sequence of groups defined by
xsl:for-each-group group-adjacent="x".
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
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
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.
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.
This class generates HTML output
HTMLIndenter: This ProxyEmitter indents HTML elements, by adding whitespace
character data where appropriate.
Class to classify HTML names
The NameClassifier classifies element names according to whether the element is (a) an inline element,
and/or (b) a formatted element
Class to classify XHTML names
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
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.
IdentityComparison: a boolean expression that compares two nodes
for equals, not-equals, greater-than or less-than based on identity and
document ordering
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.
IdrefTest is a test that cannot be represented directly in XPath or
XSLT patterns, but which is used internally for matching IDREF nodes: it tests
whether the node has the is-idref property
This filter is inserted into the serializer pipeline when serializing an implicit XSLT result tree, that
is, one that is created without use of xsl:result-document.
This implementation of FunctionLibrary contains all the functions imported into a Query Module.
An IndependentContext provides a context for parsing an XPath expression appearing
in a context other than a stylesheet.
The XPath 2.0 index-of() function
Iterator to return the index positions of selected items in a sequence
This interface can be implemented by users (there are no implementations in Saxon itself).
A NamespaceResolver that resolves namespace prefixes by reference to a node in a document for which
those namespaces are in-scope.
This class supports fuctions get-in-scope-prefixes()
The XPath 2.0 insert-before() function
Insertion iterator.
InstanceOf Expression: implements "Expr instance of data-type"
Abstract superclass for all instructions in the compiled stylesheet.
Details about an instruction, used when reporting errors and when tracing
Information about an instruction in the stylesheet or a construct in a Query, made
available at run-time to a TraceListener
An integer value: note this is a subtype of decimal in XML Schema, not a primitive type.
A Comparable that performs comparison of an Int64Value either with another
Int64Value or with some other representation of an XPath numeric value
Set of int values.
An immutable integer set containing all int values except those in an excluded set
This class represents a sequence of consecutive ascending integers, for example 1 to 50.
An IntegerRangeTest is an expression of the form
E = N to M
where E is numeric, and 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
ExtensionFunctionCallA library of integrated function calls, that is, user-written extension functions implemented
as instances of the class IntegratedFunction.
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
A hash table that maps int keys to Object values.
Set of int values.
An iterator over a sequence of unboxed int values
Set of int values.
A set of integers represented as int values
An immutable integer set containing a single integer
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 immutable integer set containing every integer
Handles grouping separators when formatting a number in cases where the grouping separators are
not at regular intervals
Marker interface: the only instance of this class is the SchemaCompiler object in Saxon-EE
A position() eq last() expression, generated by the optimizer.
This class defines properties of the ISO-8859-1 character set
This class implements the saxon:is-whole-number() extension function,
which is specially-recognized by the system because calls are generated by the optimizer.
An Item is an object that can occur as a member of a sequence.
Implements the saxon:item-at() function.
A ItemChecker implements the item type checking of "treat as": that is,
it returns the supplied sequence, checking that all its items are of the correct type
ItemMappingFunction is an interface that must be satisfied by an object passed to a
ItemMappingIterator.
ItemMappingIterator applies a mapping function to each item in a sequence.
A Comparer used for comparing nodes in document order, or items in merge order
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.
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.
A ItemTypePattern is a pattern that consists simply of an ItemType.
A SequenceIterator that wraps a Java Iterator.
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.
Implementation of the Platform class containing methods specific to the Java platform
(as distinct from .NET).
An object representing an XPath variable for use in the JAXP XPath API.
A JAXPXPathStaticContext provides a context for parsing an XPath expression
in a context other than a stylesheet.
This class translates XML Schema regex syntax into JDK 1.5 regex syntax.
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 JDOM and then proceed with the transformation.
Variant of command line net.sf.saxon.Transform do build the source document
in JDOM and then proceed with the transformation.
JDOMWriter is a Receiver that constructs a JDOM document from the stream of events
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 compiled regular expression implemented using the Java JDK regex package
A JTokenIterator is an iterator over the strings that result from tokenizing a string using a regular expression
Corresponds to a single xsl:key declaration.
A set of xsl:key definitions in a stylesheet that share the same name
Mapping class to filter nodes that have the origin node as an ancestor-or-self
KeyManager manages the set of key definitions in a stylesheet, and the indexes
associated with these key definitions.
This is an implementation of the JDK 1.4 CharSequence interface: it implements
a CharSequence as a list of arrays of characters (the individual arrays are known
as segments).
Implement the XPath 2.0 function last()
A LastItemExpression returns the last item in the sequence returned by a given
base expression.
A LastPositionFinder is an interface implemented by any SequenceIterator that is
able to return the position of the last item in the sequence.
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 is modelled on the XQuery syntax let $x := expr return expr.
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 TinyTree.
The LinkedTreeBuilder class is responsible for taking a stream of Receiver events and constructing
a Document tree using the linked tree implementation.
Class ListIterator, iterates over a sequence of items held in a Java List
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 Value.This class represents a literal result element in the style sheet
(typically an HTML element to be output).
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.
Represents the set of xsl:param elements at the start of an xsl:iterate instruction
The compiled form of an xsl:param element within a template in an XSLT stylesheet.
Handler for local xsl:variable elements in stylesheet.
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.
This class holds constants identifying different kinds of location in a source stylesheet or query.
A Receiver that can be inserted into an event pipeline to copy location information.
A LocationMap allocates integer codes to (systemId, lineNumber) pairs.
A LocationPathPattern represents a path, for example of the form A/B/C...
LocationProvider: this interface represents an object that
provides the location of elements in a source document or instructions in a stylesheet
or query.
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
An LRU cache, based on
LinkedHashMap.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.
This class implements the matches() function for regular expression matching
This class implements extension functions in the
http://exslt.org/math namespace.
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.
An xsl:message element in the stylesheet.
MessageEmitter is the default Receiver for xsl:message output.
A user-written implementation of the MessageListener interface may be registered with the XsltTransformer
to receive notification of xsl:message output.
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.
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
A Mode is a collection of rules; the selection of a rule to apply to a given element
is determined by a Pattern.
A ModuleURIResolver is used when resolving references to
query modules.
An iterator over a single object (typically a sub-expression of an expression)
An iterator that combines the results of a sequence of iterators
Interface representing the document node of a mutable document
An extension of the NodeInfo interface defining a node that can be updated.
The class checks names and characters
against the rules of the XML 1.0 and XML Namespaces 1.0 specification
The class checks names against the rules of the XML 1.1 and XML Namespaces 1.1 specification
A NameChecker performs validation and analysis of XML names.
This class attempts to identify a timezone name, given the date (including the time zone offset)
and the country.
This class supports the name() function
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,
a namespace prefix, and a local name.
Uncaught 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.
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.
A NamespaceException represents an error condition whereby a QName (for example a variable
name or template name) uses a namespace prefix that is not declared
This class supports the function namespace-uri-for-prefix()
This class provides an iterator over the namespace codes representing the in-scope namespaces
of any node.
NamespaceMaintainer is an EventIterator responsible for maintaining namespace context in an
event stream.
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 supports the namespace-uri() function
NodeTest is an interface that enables a test of whether a node has a particular
name and type.
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.
BaseEnumeration is an abstract implementation of an AxisIterator, it
simplifies the implementation of the underlying AxisIterator by requiring
it to provide only two methods: advance(), and getAnother().
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.
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.
This interface represents a node name.
This class supports the name(), local-name(), and namespace-uri() functions
from XPath 1.0, and also the XSLT generate-id() function
This class implements the DOM Node interface as a wrapper around a Saxon NodeInfo object.
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 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 node in the XML parse tree representing an XML element, character content, or attribute.
A node in the XML parse tree representing an XML element, character content, or attribute.
A node in the XML parse tree representing an XML element, character content, or attribute.
A node in the XML parse tree representing an XML element, character content,
or attribute.
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 strips all elements unless xml:space indicates that whitespace
should be preserved.
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
Implements Unicode Normalization Forms C, D, KC, KD.
Accesses the Normalization Data used for Forms C and D.
Implement the XPath normalize-space() function
Implement the XPath normalize-unicode() function
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()
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.
Implements the XPath number() function.
Class NumberFormatter defines a method to format a ArrayList of integers as a character
string according to a supplied format specification.
An xsl:number element in the stylesheet.
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").
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.
This class performs optimizations that vary between different versions of the Saxon product.
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.
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).
This interface defines an OutputURIResolver.
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.
An abstract class to act as a common parent for instructions that create element nodes
and document nodes.
Class ParentNodeExpression represents the XPath expression ".." or "parent::node()"
ParentNodeImpl is an implementation of a non-leaf node (specifically, an Element node
or a Document node)
This class defines options for parsing a source document
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.
A Pattern represents the result of parsing an XSLT pattern string.
This interface enables a client to find all nodes in a document that match a particular pattern.
This is a singleton class used to convert an expression to an equivalent pattern.
Parser for XSLT patterns.
The PatternSponsor class allows a Pattern to be treated like an expression.
A PendingUpdateList is created by updating expressions in XQuery Update.
The PIGrabber class is a Receiver that looks for xml-stylesheet processing
instructions and tests whether they match specified criteria; for those that do, it creates
an InputSource object referring to the relevant stylesheet
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.
A "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)
Represents the defining occurrence of the position variable in a for expression
within an expression, for example the $p in "for $x at $p in ...".
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.
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.
Represents the stylesheet module at the root of the import tree, that is, the module
that includes or imports all the others.
This 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).
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.An internal instruction used by the fn:analyze-string function to process a matching
substring.
ProcInstImpl is an implementation of ProcInstInfo used by the Propagator to construct
its trees.
ProcInstParser is used to parse pseudo-attributes within Processing Instructions
PromotionOffer is an object used transiently during compilation of an expression.
A ProxyReceiver is an Receiver that filters data before passing it to another
underlying Receiver.
A PullConsumer consumes all the events supplied by a PullProvider, doing nothing
with them.
A PullEvent is one of the following:
An item (that is, a node or an atomic value)
A startElement, endElement, startDocument, or endDocument event
An EventIterator, representing a sequence of PullEvents
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.
Diagnostic class to display the sequence of events reported by an EventIterator
PullFilter 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.
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 (previously named fn:expanded-QName())
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.
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 defines extensions to the XPath parser to handle the additional
syntax supported in XQuery
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.
This class implements extension functions in the
http://exslt.org/random namespace.
A RangeExpression is an expression that represents an integer sequence as
a pair of end-points (for example "x to y").
An Iterator that produces numeric values in a monotonic sequence,
ascending or descending.
Receiver: This interface represents a recipient of XML tree-walking (push) events.
ReceiverOptions defines a set of constants, which can be used in
calls to methods on the Receiver interface.
ReceivingContentHandler is a glue class that provides a standard SAX ContentHandler
interface to a Saxon Receiver.
Non-instantiable class containing constant data definitions used by the various Regular Expression translators
This class is an interator that supports the evaluation of xsl:analyze-string.
Interface defining a call-back action for processing captured groups
Thrown when an syntactically incorrect regular expression is detected.
Abstract superclass for the various regex translators, which differ according to the target platform.
A Range represents a range of consecutive Unicode codepoints
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.
The standard JAXP URIResolver is given a relative URI and a base URI and returns the resource
identified by this combination.
The XPath 2.0 remove() function
An implementation of SequenceIterator that returns all items except the one
at a specified position.
This class implements the replace() function for replacing
substrings that match a regular expression
This class supports the resolve-QName function in XPath 2.0
This class supports the resolve-uri() functions in XPath 2.0
The compiled form of an xsl:result-document element in the stylesheet.
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()
ReverseArrayIterator is used to enumerate items held in an array in reverse order.
Iterator that produces numeric values in a monotonic sequence,
ascending or descending.
A ReversibleIterator is an interface implemented by any SequenceIterator that is
able to deliver items in reverse order (or to supply another iterator that can
do so).
A RoleLocator identifies the role in which an expression is used, for example as
the third argument of the concat() function.
Implement the XPath 2.0 root() function
An expression whose value is always a set of nodes containing a single node,
the document root.
This class supports the ceiling(), floor(), round(), and round-to-half-even() functions,
and also the abs() function
Rule: a template rule, or a strip-space rule used to support the implementation
This class wraps a RuleBasedCollator to provide a SubstringMatcher.
RuleManager maintains a set of template rules, one set for each mode
The target of a rule, typically a Template.
An object representing a list of Namespaces.
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.
The class acts as a register of Saxon-specific error codes.
SaxonLocator: this interface exists to unify the SAX Locator and JAXP SourceLocator interfaces,
which are identical.
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.
This is a marker interface that represents any "schema component" as defined in the XML Schema
specification.
Interface for a general purpose visitor object used to process schema components
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.
A SchemaValidator is an object that is used for validating instance documents against a schema.
A whitespace stripping rule that strips elected elements unless xml:space indicates that whitespace
should be preserved.
Sender is a helper class that sends events to a Receiver from any kind of Source object
This class takes a sequence of pull events and composes them into a sequence of items.
Copies a sequence, supplied as a SequenceIterator, to a push pipeline, represented by
a SequenceReceiver
A sequence value implemented extensionally.
A SequenceIterator is used to iterate over any XPath 2 sequence (of values or nodes).
This outputter is used when writing a sequence of atomic values and nodes, that
is, when xsl:variable is used with content and an "as" attribute.
SequenceReceiver: this extension of the Receiver interface is used when processing
a sequence constructor.
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.
This outputter is used when writing a sequence of atomic values and nodes, for
example, when xsl:variable is used with content and an "as" attribute.
A Serializer takes a tree representation of XML and turns it into lexical XML markup.
Enumerator over the defined 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 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.
A sequence value implemented extensionally using an extensible List whose leading part can be shared
with other sequence values.
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.
A simple collation that just wraps a suppled Comparator
A simple container for standalone XPath expressions
An abstract implementation of Expression designed to make it easy to implement new expressions,
in particular, expressions to support extension instructions.
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
An 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.
This interface represents a simple type, which may be a built-in simple type, or
a user-defined simple type.
A SingleItemFilter is an expression that selects zero or one items from a supplied sequence
A node set expression that will always return zero or one nodes
SingletonIterator: an iterator over a sequence of zero or one values
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.
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 class represents an EventIterator over a sequence containing a single pull event.
This expression is equivalent to (A intersect B) in the case where A has cardinality
zero-or-one.
A value that is a sequence containing zero or one items.
SingletonIterator: an iterator over a sequence of zero or one values
The "singularity" tuple stream delivers a single empty tuple.
A Sink is an Receiver that discards all information passed to it
A slash expression is any expression using the binary slash operator "/".
A SlotManager supports functions, templates, etc: specifically, any executable code that
requires a stack frame containing local variables.
A Sortable is an object that can be sorted using the QuickSort method.
A SortedGroupIterator is a modified SortedIterator.
Class to do a sorted iteration
Expression equivalent to the imaginary syntax
expr sortby (sort-key)+
A SortKeyDefinition defines one component of a sort key.
Callback interface used to evaluate sort keys.
A SourceLocationProvider is a
LocationProvider that represents locations
in the source document from which the events
are derived (as distinct from locations in a query or stylesheet of the instructions causing the
events)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 sql:close element in the stylesheet.
An sql:column element in the stylesheet.
An sql:connect element in the stylesheet.
An sql:delete element in the stylesheet.
An sql:execute element in the stylesheet.
An sql:insert element in the stylesheet.
An sql:query element in the stylesheet.
An sql:update element in the stylesheet.
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.
This class implements the default collection URI Resolver.
This class is an EntityResolver used to resolve references to common
DTDs and entity files, using local copies provided with the Saxon product.
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.
This class contains static data tables defining the properties of standard functions.
An entry in the table describing the properties of a function
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.
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 InputSource.
A PullEvent representing the start of a document node
This is a PullEvent representing the start of an element node.
Implements the fn:starts-with() function
StartTagBuffer is a ProxyReceiver that buffers attributes and namespace events within a start tag.
MappingFunction is an interface that must be satisfied by an object passed to a
MappingIterator.
This class supports the static-base-uri() function in XPath 2.0.
A StaticContext contains the information needed while an expression or pattern
is being parsed.
This class contains constants identifying dependencies that an XPath expression
might have on its context.
StaticQueryContext contains information used to build a StaticContext for use when processing XQuery
expressions.
This class implements the Saxon PullProvider API on top of a standard StAX parser
(or any other StAX XMLStreamReader implementation)
This class implements the Saxon EventIterator API on top of a standard StAX parser
(or any other StAX XMLStreamReader implementation)
This class implements the XmlStreamWriter interface, translating the events into Saxon
Receiver events.
This interface represents a "collation" as defined in XPath, that is, a set of rules for comparing strings
A
Converter that accepts a string as input.Converter that does nothing - it returns the input unchanged
Converts string to anyURI
Converts a string to a boolean
Converts a string to a date
Converts a string to a dateTime
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 double.
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
Implement XPath function string()
xf: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
StringTokenIterator: breaks a string up into tokens,
and returns the tokens as a sequence of strings.
An atomic value of type xs:string.
The RuleBasedStripper class performs whitespace stripping according to the rules of
the xsl:strip-space and xsl:preserve-space instructions.
The set of rules used to decide strip-space/preserve-space matching of element names in XSLT.
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 StylesheetFunctionLibrary contains functions defined by the user in a stylesheet.
A stylesheet module represents a module of a stylesheet.
This interface is implemented by all XSL elements that can contain local variable declarations.
A whitespace stripping rule that strips whitespace according to the rules defined for XSLT stylesheets
Implements the XPath 2.0 subsequence() function
A SubsequenceIterator selects a subsequence of a sequence
This class implements the XPath substring() function
Implements the fn:substring-after() function
Implements the fn:substring-before() function
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
Supplied parameter reference: this is an internal expression used to refer to
the value of the n'th parameter supplied on a template call (apply-templates).
Abstract superclass for system-defined and user-defined functions
The SystemFunctionLibrary represents the collection of functions in the fn: namespace.
System IDs are not held in nodes in the tree, because they are usually the same
for a whole document.
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.
This interface represents an expression that is capable of being processed leaving tail calls for the
calling instruction to deal with.
A TailExpression represents a FilterExpression of the form EXPR[position() > n]
Here n is usually 2, but we allow other values
TailIterator iterates over a base sequence starting at an element other than the first.
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.
TemplatesHandlerImpl implements the javax.xml.transform.sax.TemplatesHandler
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
The 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.
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.
An implementation of the AttributeCollection interface based directly on the
TinyTree data structure.
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 an implementation of CommentInfo
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)
TProcInstImpl is an implementation of ProcInstInfo
A node in the XML parse tree representing character content
A data structure to hold the contents of a tree.
This implementation of the Saxon event-pull interface starts from a document, element,
text, comment, or processing-instruction node in a TinyTree,
and returns the events corresponding to that node and its descendants (including
their attributes and namespaces).
This class holds static constants and methods defining the lexical tokens used in
XPath and XQuery, and associated keywords.
This class implements the tokenize() function for regular expression matching.
Tokenizer for expressions and inputs.
This class supports the XPath 2.0 function trace().
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 XPath and XQuery.
This interface defines methods that are called by Saxon during the execution of
a stylesheet, if tracing is switched on.
This class is a filter for a sequence of pull events; it returns the input sequence unchanged,
but traces execution to System.err
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 TransformerFactoryImpl instance can be used to create Transformer and Template
objects.
TransformerHandlerImpl implements the javax.xml.transform.sax.TransformerHandler
interface.
TransformerReceiver is similar in concept to the JAXP TransformerHandler,
except that it implements Saxon's Receiver interface rather than the standard
SAX2 interface.
Implement the XPath translate() function
A Transmitter is a source of events sent to a Receiver.
Treat Expression: implements "treat as data-type ( expression )".
This class supports the XPath 2.0 functions exactly-one(), one-or-more(), zero-or-one().
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.
A tuple, as it appears in an XQuery tuple stream handled by extended FLWOR expressions.
A tuple expression is an expression that returns a 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)
This class contains static information about types and methods for constructing type codes.
This class supports the XSLT element-available and function-available functions.
This class provides Saxon's type checking capability.
An abstraction of ExpressionVisitor that provides the minimal set of services needed by
the TypeChecker; used to allow run-time type-checking of higher order function arguments without
retaining the whole static context
A filter on the push pipeline that performs type checking, both of the item type and the
cardinality.
This 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.
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 tree construction is deferred, innocuous methods such as NodeInfo#getLocalName() may
trigger a dynamic error.
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.
A SequenceIterator is used to iterate over a sequence.
This class provides knowledge of the names and contents of Unicode character blocks,
as referenced using the \p{IsXXXXX} construct in a regular expression.
This class reads the Unicode character database, extracts information needed
to perform unicode normalization, and writes this information out in the form of the
Java "source" module UnicodeData.java.
This class reads the data compiled into class UnicodeData, and builds hash tables
that can be used by the Unicode normalization routines.
UnicodeNormalizer: This ProxyReceiver performs unicode normalization on the contents
of attribute and text nodes.
An enumeration representing a nodeset that is a union of two other NodeSets.
A pattern formed as the union (or) of two other patterns
A QNameTest that is the union of a number of supplied QNameTests
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
Class UnparsedTextIterator, iterates over a file line by line
An UnparsedTextURIResolver accepts an absolute URI and optionally an encoding name as input,
and returns a Reader as its result.
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.
This class has a singleton instance which represents the complex type xdt:untyped,
used for elements that have not been validated.
An Untyped Atomic value.
AtomizingIterator returns the atomization of an underlying sequence supplied
as an iterator.
An UpdateAgent is a callback class that is called to handle a document after it has been updated.
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
This instruction corresponds to a use-attribute-sets attribute on a literal result element, xsl:element,
or xsl:copy.
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
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 expressions in XSLT 2.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.
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
Defines a class that is notified of validation statistics at the end of a validation episode
A value is the result of an expression but it is also an expression in its own right.
ValueComparison: a boolean expression that compares two atomic values
for equals, not-equals, greater-than or less-than.
An xsl:value-of element in the stylesheet.
A ValueRepresentation is a representation of a Value.
ValueTailIterator iterates over a base sequence starting at an element other than the first.
Generic interface representing a variable declaration in the static context of an XPath expression.
Variable reference: a reference to a variable.
The VendorFunctionLibrary represents specially-recognized functions in the Saxon namespace.
An expression representing a nodeset that is a union, difference, or
intersection of two other NodeSets
A pattern formed as the union, intersection, or difference of two other patterns
The Version class holds the SAXON version information.
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.
A virtual copy of a document node
This interface is implemented by NodeInfo implementations that act as wrappers
on some underlying tree.
This class represents a virtual copy of a node with type annotations stripped
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.
This class provides helper methods and constants for handling whitespace
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
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.
The class XdmAtomicValue represents an item in an XPath 2.0 sequence that is an atomic value.
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 XdmFunctionItem represents a function item
The class XdmItem represents an item in a sequence, as defined by 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.
An value in the XDM data model.
XHTMLEmitter is an Emitter that generates XHTML output.
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.
Provides the interface to the Apache catalog resolver.
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.
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 is a URI resolver that loads an XML document found at the relevant
URI and builds a XOM tree from it; the XOM tree is then returned as a source object.
XOMWriter is a Receiver that constructs a XOM document from the stream of events
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.
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 in an XPath expression.
Subclass of XPathException used to report circularities
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.
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
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.
A Simple trace listener for XQuery that writes messages (by default) to System.err
An xsl:analyze-string elements in the stylesheet.
An xsl:apply-imports element in the stylesheet
An xsl:apply-templates element in the stylesheet
xsl:attribute element in stylesheet.
An xsl:attribute-set element in the stylesheet.
An xsl:call-template element in the stylesheet
An xsl:character-map declaration in the stylesheet.
An xsl:choose elements in the stylesheet.
An xsl:comment elements 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.
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:function elements in stylesheet (XSLT 2.0).
Abstract class to represent xsl:include or xsl:import element in the stylesheet.
This class defines common behaviour across xsl:variable, xsl:param, and xsl:with-param
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.
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
Handler for xsl:matching-substring and xsl:non-matching-substring elements in stylesheet.
An xsl:message element in the stylesheet.
An xsl:namespace element in the stylesheet.
An xsl:namespace-alias element in the stylesheet.
An xsl:next-match element in the stylesheet
An xsl:number element in the stylesheet.
Handler for xsl:otherwise elements in stylesheet.
An xsl:output element in the stylesheet.
An xsl:output-character element in the stylesheet.
An xsl:param element in the stylesheet.
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.
An xsl:stylesheet or xsl:transform element in the stylesheet.
An XsltCompiler object allows XSLT 2.0 stylesheets to be compiled.
An xsl:template element in the style sheet.
An XsltExecutable represents the compiled form of a stylesheet.
Handler for xsl:text elements in stylesheet.
Extends the standard XPath static context with information that is available for
XPath expressions invoked from XSLT
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.An xsl:value-of element in the stylesheet.
Handler for xsl:variable elements in stylesheet.
Generic class for xsl:variable and xsl:param elements.
Handler for xsl:when elements in stylesheet.
An xsl:with-param element in the stylesheet.
A value of type xs:yearMonthDuration