All Classes

Class AbstractNumberer is a base implementation of Numberer that provides language-independent default numbering This supports the xsl:number element.

This is the standard trace listener used when the -T option is specified on the command line.

This class implements the sum(), avg(), count() functions,

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

An xsl:analyze-string element in the stylesheet.

Specify how the result tree should be output as specified in the Serialization specification.

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.

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:anyType, also known as the urtype.

Iterator that concatenates the results of two supplied iterators

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, in backwards compatibility mode: see ArithmeticExpression for the non-backwards compatible case.

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.

An atomic mapping expression is a slash expression A/B where B has a static type that is an atomic type.

An AtomicComparer used for comparing atomic values of arbitrary item types.

The AtomicValue class corresponds to the concept of an atomic value in the XPath 2.0 data model.

Implement the mapping function.

AttributeCollectionImpl is an implementation of both the SAX2 interface Attributes and the Saxon equivalent AttributeCollection.

The compiled form of an xsl:attribute-set element in the stylesheet.

This class is an implementation of the DOM Attr class that wraps a Saxon NodeInfo representation of an attribute or namespace node.

This class supports the XSLT element-available and function-available functions.

This is an enumeration class containaing constants representing the thirteen XPath axes

An AxisExpression is always obtained by simplifying a PathExpression.

A SequenceIterator is used to iterate over a sequence.

This class supports the base-uri() functions in XPath 2.0

An integer value: note this is a subtype of decimal in XML Schema, not a primitive type.

Binary Expression: a numeric or boolean expression consisting of the two operands and an operator

Binding is a interface used to represent the run-time properties and methods associated with a variable: specifically, a method to get the value of the variable.

Implements an imaginary xsl:block instruction which simply evaluates its contents.

Iterate over the instructions in the Block, concatenating the result of each instruction into a single combined sequence.

This class supports the XPath functions boolean(), not(), true(), and false()

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.

A compiled saxon:break instruction.

The abstract Builder class is responsible for taking a stream of SAX events and constructing a Document tree.

This class is used to implement the built-in list types NMTOKENS, ENTITIES, IDREFS.

This class evaluates arithmetic expressions; it acts as a helper class to the ArithmeticExpression class.

A comparer specifically for comparing two date, time, or dateTime values

A CallTemplatePackage is an object that encapsulates the name of a template to be called, the parameters to be supplied, and the execution context.

A CardinalityChecker implements the cardinality checking of "treat as": that is, it returns the supplied sequence, checking that its cardinality is correct

This class holds data about the case-variants of Unicode characters.

Cast Expression: implements "cast as data-type ( expression )".

CharacterMapExpander: This ProxyReceiver expands characters occurring in a character map, as specified by the XSLT 2.0 xsl:character-map declaration

This class creates a CharacterSet object for a given named encoding.

Compiled representation of an xsl:choose or xsl:if element in the stylesheet.

A collating sequence that uses Unicode codepoint ordering

This class supports the function codepoints-to-string

Abstract superclass for all functions that take an optional collation argument

A CollationURIResolver accepts a collation name as input, and returns a collation (represented by a StringCollator) as output.

This interface defines a CollectionURIResolver.

An instruction representing an xsl:comment element in the stylesheet.

This class implements extension functions in the http://exslt.org/common namespace.

XSLT 2.0 compare() function

Interface implemented by expressions that perform a comparison

This Compile class provides a command-line interface allowing a stylesheet to be compiled.

Abtract class representing a function call that is always rewritten at compile-time: it can never be executed

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.

This class supports the get_X_from_Y functions defined in XPath 2.0

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

This class holds details of user-selected configuration options for a set of transformations and/or queries.

A Container is something other than an expression that can act as the container of an expression.

A ContentHandlerProxy is a Receiver that converts events into the form expected by an underlying SAX2 ContentHandler.

NodeTest is an interface that enables a test of whether a node matches particular conditions.

ContextMappingFunction is an interface that must be satisfied by an object passed to a ContextMappingIterator.

An entry on the context stack.

Subclass of ContextStackFrame representing a built-in template rule in XSLT

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

This class provides a representation of the current runtime call stack, as represented by the stack of XPathContext objects.

The Controller is Saxon's implementation of the JAXP Transformer class, and represents an executing instance of a transformation or query.

Handler for xsl:copy elements in stylesheet.

Exception indicating that an attempt was made to copy namespace-sensitive content without copying its associated namespaces

This class defines properties of the cp1250 Central Europe character set, as defined at http://www.microsoft.com/globaldev/reference/sbcs/1250.htm.

This class defines properties of the CP1252 (Latin 1) character set, as defined at http://www.microsoft.com/globaldev/reference/sbcs/1252.htm.

Implement the XSLT current() function

Implements the XSLT functions current-group() and current-grouping-key()

Implement XPath function fn:data()

This class implements extension functions in the http://exslt.org/dates-and-times namespace.

A value of type DateTime

A value of type xs:dayTimeDuration

DecimalFormatManager manages the collection of named and unnamed decimal formats

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

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.

Implement the XPath 2.0 default-collation() function

A Destination represents a place where XML can be sent.

The XPath 2.0 distinct-values() function

Implement the fn:doc() function - a simplified form of the Document 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.

This class implements the JAXP DocumentBuilder interface, allowing a Saxon TinyTree to be constructed using standard JAXP parsing interfaces.

A node in the XML parse tree representing the Document itself (or equivalently, the root node of the Document).

An instruction to create a document node.

This class (which has one instance per Configuration) is used to allocate unique document numbers.

This class is an implementation of the DOM Document class that wraps a Saxon DocumentInfo representation of a document node.

Sends an entire document to a Receiver.

The document node of a tree implemented as a wrapper around a DOM Document.

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.

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.

This class wraps a list of nodes as a DOM NodeList

DOMSender.java: pseudo-SAX driver for a DOM source document.

DOMWriter is a Receiver that attaches the result tree to a specified Node in a DOM Document

A numeric (double precision floating point) value

A value of type xs:duration

An EagerLetExpression is the same as a LetExpression except that the variable is evaluated using eager evaluation rather than lazy evaluation.

An instruction that creates an element node.

This is a filter that can be added to a pull pipeline to remember element names so that they are available immediately after the END_ELEMENT event is notified

Emitter: This abstract class defines methods that must be implemented by components that format SAXON output.

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.

EmptyIterator: an iterator over an empty sequence.

An EmptySequence object represents a sequence containing no members.

Pull event representing the end of a document

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.

Implement XPath function fn:error()

A SequenceIterator that throws an exception as soon as its next() method is called.

This interface is a simple subset of the Expression interface, that provides a single method to evaluate the result of an expression as a single item

Inner class PreparedExpression represents a compiled XPath expression together with the standard variables $p1 ..

An iterator over a sequence of events

Class to read pull events from an EventIterator and write them to a Receiver

MappingIterator merges a sequence of sequences into a single sequence.

An EventStackIterator is an EventIterator that delivers a flat sequence of PullEvents containing no nested EventIterators

A compiled stylesheet or a query in executable form.

Implement the exists() and empty() functions

An ExpressionContext represents the context for an XPath expression written in the stylesheet.

Parser for XPath expressions and XSLT patterns.

This class, ExpressionTool, contains a number of useful static methods for manipulating expressions.

Interface ExtensionElementFactory.

This is a marker interface representing an abstract superclass of JavaExtensionFunctionFactory and DotNetExtensionFunctionFactory.

This class implements functions that are supplied as standard with SAXON, but which are not defined in the XSLT or XPath specifications.

This class represents the type of an external Java object returned by an extension function, or supplied as an external variable/parameter.

FeatureKeys defines a set of constants, names of Saxon configuration options which can be supplied to the Saxon implementations of the JAXP interfaces TransformerFactory, SchemaFactory, Validator, and ValidationHandler.

A FilterExpression contains a base expression and a filter predicate, which may be an integer expression (positional filter), or a boolean expression (qualifier)

Subclass to support the extension function saxon:leading, which terminates the iteration at the first item whose predicate is false

This is a marker interface used to identify nodes that contain a namepool fingerprint.

An instruction derived from an xsl:attribute element in stylesheet, or from an attribute constructor in XQuery.

This is a utility class that handles formatting of numbers as strings.

This class implements the upper-case() and lower-case() functions

Handler for xsl:for-each-group elements in stylesheet.

Implement the format-date() function in XSLT 2.0

Abstract superclass for calls to system-defined and user-defined functions

A FunctionLibraryList is a list of FunctionLibraries.

Abstract superclass for the primitive types containing date components: xs:date, xs:gYear, xs:gYearMonth, xs:gMonth, xs:gMonthDay, xs:gDay

GeneralComparison: a boolean expression that compares two expressions for equals, not-equals, greater-than or less-than.

This class defines common behaviour across xsl:variable, xsl:param, and xsl:with-param; also saxon:assign

Generically sorts arbitrary shaped data (for example multiple arrays, 1,2 or 3-d matrices, and so on) using a quicksort or mergesort.

The compiled form of a global xsl:param element in the stylesheet or an external variable declared in the prolog of a Query.

A compiled global variable in a stylesheet or query.

Implementation of the xs:gYear 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 GroupAdjacentIterator iterates over a sequence of groups defined by xsl:for-each-group group-adjacent="x".

A GroupEndingIterator iterates over a sequence of groups defined by xsl:for-each-group group-ending-with="x".

A GroupStartingIterator iterates over a sequence of groups defined by xsl:for-each-group group-starting-with="x".

Implementation of the xs:gYear data type

This class generates HTML output

A simple class for testing membership of a fixed set of case-insensitive ASCII strings.

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

IdentityTransformerHandler implements the javax.xml.transform.sax.TransformerHandler interface.

An IDPattern is a pattern of the form id("literal") or id($variable)

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 implementation of FunctionLibrary contains all the functions imported into a Query Module.

The XPath 2.0 index-of() function

A NamespaceResolver that resolves namespace prefixes by reference to a node in a document for which those namespaces are in-scope.

The XPath 2.0 insert-before() function

InstanceOf Expression: implements "Expr instance of data-type"

Details about an instruction, used when reporting errors and when tracing

An integer value: note this is a subtype of decimal in XML Schema, not a primitive type.

Set of int values.

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.

An enumeration representing a nodeset that is an intersection of two other NodeSets.

Set of int values.

Set of int values.

An implementation of IntToIntMap that relies on serial searching, and is therefore optimized for very small map sizes

Interface defining a map from integers to integers

A position() eq last() expression, generated by the optimizer.

This class defines properties of the ISO-8859-2 character set

An Item is an object that can occur as a member of a sequence.

A ItemChecker implements the item type checking of "treat as": that is, it returns the supplied sequence, checking that all its items are of the correct type

ItemMappingIterator applies a mapping function to each item in a sequence.

ItemType is an interface that allows testing of whether an Item conforms to an expected type.

A TailCallLoop wraps the body of a function that contains tail-recursive function calls.

This class acts as a factory for creating expressions that call Java extension functions.

Implementation of the Platform class containing methods specific to the Java platform (as distinct from .NET).

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

Variant of command line net.sf.saxon.Transform do build the source document in JDOM and then proceed with the transformation.

This class together with its embedded subclasses handles conversion from Java values to XPath values.

A compiled regular expression implemented using the Java JDK regex package

Corresponds to a single xsl:key declaration.

A KeyPattern is a pattern of the form key(keyname, keyvalue)

Implement the XPath 2.0 function last()

A LastPositionFinder is an interface implemented by any SequenceIterator that is able to return the position of the last item in the sequence.

A LetExpression is modelled on the XQuery syntax let $x := expr return expr.

Class ListIterator, iterates over a sequence of items held in a Java ArrayList, or indeed in any other kind of 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.

NodeTest is an interface that enables a test of whether a node has a particular name and type.

The compiled form of an xsl:param element within a template in an XSLT stylesheet.

Variable reference: a reference to a local variable.

A Receiver that can be inserted into an event pipeline to copy location information.

A LocationPathPattern represents a path, for example of the form A/B/C...

A SequenceIterator is used to iterate over a sequence.

An LRU cache, based on LinkedHashMap.

MappingIterator merges a sequence of sequences into a single flat sequence.

This class implements extension functions in the http://exslt.org/math namespace.

An xsl:message element in the stylesheet.

A user-written implementation of the MessageListener interface may be registered with the XsltTransformer to receive notification of xsl:message output.

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

A Mode is a collection of rules; the selection of a rule to apply to a given element is determined by a Pattern.

An iterator over a single object (typically a sub-expression of an expression)

An extension of the NodeInfo interface defining a node that can be updated.

The class checks names against the rules of the XML 1.1 and XML Namespaces 1.1 specification

A StringCollator is used for comparing strings (Java String objects).

This class supports the name(), local-name(), and namespace-uri() functions from XPath 1.0, and also the XSLT generate-id() function

Uncaught Exception raised when some limit in the design of the name pool is exceeded

An xsl:namespace element in the stylesheet.

This class is not instantiated, it exists to hold a set of constants representing known namespaces.

This interface represents a collection of namespace declarations or undeclarations, typically those appearing together in an element start tag.

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 provides an implementation of the namespace axis over any implementation of the data model.

NamespaceMaintainer is an EventIterator responsible for maintaining namespace context in an event stream.

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.

General-purpose implementation of the ancestor and ancestor-or-self axes

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 following axis, in terms of the ancestor, child, and following-sibling axes

This interface is implemented by expressions that returns a boolean value, and returns an expression whose result is the negated boolean value

An xsl:next-match element in the stylesheet

An iterator over an array of nodes.

A node in the "linked" tree representing any kind of node except a namespace node.

NodeTest is an interface that enables a test of whether a node has a particular name and kind.

A Comparer used for comparing nodes in document order

A NodeTest is a simple kind of pattern that enables a context-free test of whether a node has a particular 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.

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.

Exception indicating that an attribute or namespace node has been written when there is no open element to write it to

Accesses the Normalization Data used for Forms C and D.

Implement the XPath normalize-unicode() function

Interface Numberer supports number formatting.

Class Numberer_de is designed simply to demonstrate how to write a number formatter for a different language.

Class Numberer_fr is a number formatter for french.

Implements the XPath number() function.

An xsl:number element in the stylesheet.

A NumericPromoter performs numeric promotion on each item in a supplied sequence

An XPath value that encapsulates a Java object.

This class performs optimizations that vary between different versions of the Saxon product.

This interface defines an OutputURIResolver.

A ParameterSet is a set of parameters supplied when calling a template.

Class ParentNodeExpression represents the XPath expression ".." or "parent::node()"

This class defines options for parsing a source document

A PathMap is a description of all the paths followed by an expression.

A node in the path map.

A root node in the path map.

This interface enables a client to find all nodes in a document that match a particular pattern.

The PatternSponsor class allows a Pattern to be treated like an expression.

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

A PipelineConfiguration sets options that apply to all the operations in a pipeline.

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

This interface provides access to methods whose implementation depends on the chosen platform (typically Java or .NET)

An iterator over nodes, that prepends a given node to the nodes returned by another iterator.

An xsl:processing-instruction element in the stylesheet, or a processing-instruction constructor in a query

ProcInstParser is used to parse pseudo-attributes within Processing Instructions

A ProxyReceiver is an Receiver that filters data before passing it to another underlying Receiver.

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

Diagnostic class to display the sequence of events reported by an EventIterator

This class delivers any XPath sequence through the pull interface.

PullProvider is Saxon's pull-based interface for reading XML documents and XDM sequences.

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.

This class bridges PullProvider events to XMLStreamReader (Stax) events.

Implements the fn:put() function in XQuery Update 1.0.

A QNameException represents an error condition whereby a QName (for example a variable name or template name) is malformed

A QName value.

A QuantifiedExpression tests whether some/all items in a sequence satisfy some condition.

This class represents a query module, and includes information about the static context of the query module.

This class contains static methods used to read a query as a byte stream, infer the encoding if necessary, and return the text of the query as a string; also methods to import functions and variables from one module into another, and check their consistency.

This class implements the rules for an XQuery simple content constructor, which are used in constructing the string value of an attribute node, text node, comment node, etc, from the value of the select expression or the contained sequence constructor.

A RangeExpression is an expression that represents an integer sequence as a pair of end-points (for example "x to y").

Receiver: This interface represents a recipient of XML tree-walking (push) events.

ReceivingContentHandler is a glue class that provides a standard SAX ContentHandler interface to a Saxon Receiver.

Thrown when an syntactically incorrect regular expression is detected.

A Range represents a range of consecutive Unicode codepoints

The standard JAXP URIResolver is given a relative URI and a base URI and returns the resource identified by this combination.

An implementation of SequenceIterator that returns all items except the one at a specified position.

This class supports the resolve-QName function in XPath 2.0

The compiled form of an xsl:result-document element in the stylesheet.

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 RoleLocator identifies the role in which an expression is used, for example as the third argument of the concat() function.

An expression whose value is always a set of nodes containing a single node, the document root.

Rule: a template rule, or a strip-space rule used to support the implementation

RuleManager maintains a set of template rules, one set for each mode

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 unchecked exception thrown by the Saxon API.

A saxon:break element in the stylesheet, or (by subclassing) a saxon:continue element

A saxon:collation element in the style sheet: this is a top-level element that defines details of a named collation.

A saxon:doctype element in the stylesheet.

The class acts as a register of Saxon-specific error codes.

The class implements a saxon:import-query declaration in a stylesheet.

SaxonLocator: this interface exists to unify the SAX Locator and JAXP SourceLocator interfaces, which are identical.

A saxon:script element in the stylesheet.

This is a marker interface that represents any "schema component" as defined in the XML Schema specification.

An exception that identifies an error in reading, parsing, or validating a schema.

SchemaType is an interface implemented by all schema types: simple and complex types, built-in and user-defined types.

A SchemaValidator is an object that is used for validating instance documents against a schema.

This class takes a sequence of pull events and composes them into a sequence of items.

A sequence value implemented extensionally.

A SequenceIterator is used to iterate over any XPath 2 sequence (of values or nodes).

SequenceReceiver: this extension of the Receiver interface is used when processing a sequence constructor.

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 class implements the saxon:serialize() extension function, which is specially-recognized by the system because it needs access to parts of the static context

This class implements extension functions in the http://exslt.org/sets namespace.

This class implements the rules for an XSLT (or XQuery) simple content constructor, which are used in constructing the string value of an attribute node, text node, comment node, etc, from the value of the select expression or the contained sequence constructor.

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

A node set expression that will always return zero or one nodes

A SingletonAtomizer combines the functions of an Atomizer and a CardinalityChecker: it is used to atomize a sequence of nodes, checking that the result of the atomization contains zero or one atomic values.

Class to handle comparisons of singletons.

SingletonIterator: an iterator over a sequence of zero or one values

A Sink is an Receiver that discards all information passed to it

A SlotManager supports functions, templates, etc: specifically, any executable code that requires a stack frame containing local variables.

A SortedGroupIterator is a modified SortedIterator.

A SortedTupleIterator is a modified SortedIterator.

A SortKeyDefinition defines one component of a sort key.

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)

An sql:close element in the stylesheet.

An sql:connect element in the stylesheet.

Class SQLElementFactory.

An sql:query element in the stylesheet.

This class represents a stack frame holding details of the variables used in a function or in an XSLT template.

This class implements the default collection URI Resolver.

StandardErrorListener is the standard error handler for XSLT processing errors, used if no other ErrorListener is nominated.

An entry in the table describing the properties of a function

Well-known names used in XSLT processing.

Default implementation of the UnparsedTextURIResolver, used if no other implementation is nominated to the Configuration.

A PullEvent representing the start of a document node

StartTagBuffer is a ProxyReceiver that buffers attributes and namespace events within a start tag.

This class supports the static-base-uri() function in XPath 2.0.

StaticQueryContext contains information used to build a StaticContext for use when processing XQuery expressions.

This class implements the Saxon EventIterator API on top of a standard StAX parser (or any other StAX XMLStreamReader implementation)

Implement XPath function string()

Implement the XPath string-length() function

This class supports the function string-to-codepoints()

An atomic value of type xs:string

A StrippedNode is a view of a node, in a virtual tree that has whitespace text nodes stripped from it.

This class provides an economical representation of a QName triple (prefix, URI, and localname).

Class StyleNodeFactory.

This interface is implemented by all XSL elements that can contain local variable declarations.

Implements the XPath 2.0 subsequence() function

NodeTest is an interface that enables a test of whether a node has a particular name and type.

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.

Abstract superclass for the JDK 1.4 and .NET regex translators, or in principle for any other target regex dialect in which "." matches a UTF-16 16-bit code rather than a Unicode character

Object representing a character class

Character class representing the complement of another character class, that is, all characters that the other class doesn't match.

Character class that matches nothing

Simple Character Class - essentially, anything other than a Union or Subtraction between two character classes.

Character class that matches a single specific character outside the BMP

The SystemFunctionLibrary represents the collection of functions in the fn: namespace.

Implementation of the XSLT system-property() function

A TailCallLoop wraps the body of a function that contains tail-recursive function calls.

A TailExpression represents a FilterExpression of the form EXPR[position() > n] Here n is usually 2, but we allow other values

A TeeDestination allows writing to two destinations at once.

An xsl:template element in the style sheet.

An iterator over a sequence of integers held in an array.

A Comparer used for comparing sort keys when data-type="text".

This class represents a temporary tree whose root document node owns a single text 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.

A value of type xs:time

The TinyBuilder class is responsible for taking a stream of SAX events and constructing a Document tree, using the "TinyTree" implementation.

A node in a TinyTree representing an XML element, character content, or attribute.

A data structure to hold the contents of a tree.

This implementation of the Saxon 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 implements the tokenize() function for regular expression matching.

This class supports the XPath 2.0 function trace().

A subclass of TraceWrapper 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

This Transform class is the entry point to the Saxon XSLT Processor.

TransformerHandlerImpl implements the javax.xml.transform.sax.TransformerHandler interface.

Implement the XPath translate() function

This class supports the XPath 2.0 functions exactly-one(), one-or-more(), zero-or-one().

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 expression is an expression that returns a tuple.

Mapping function to map the wrapped objects returned by the SortedTupleIterator into real items.

This class provides Saxon's type checking capability.

This class exists to provide answers to questions about the type hierarchy.

Unary Expression: an expression taking a single operand expression

When tree construction is deferred, innocuous methods such as NodeInfo#getLocalName() may trigger a dynamic error.

A document node whose construction is deferred.

This class represents a virtual element node, the result of an element constructor that (in general) hasn't been fully evaluated.

A SequenceIterator is used to iterate over a sequence.

An enumeration representing a nodeset that is a union of two other NodeSets.

This class establishes properties of a character set that is known to the Java VM but not specifically known to Saxon

Implements the unparsed-entity-uri() function defined in XSLT 1.0 and the unparsed-entity-public-id() function defined in XSLT 2.0

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.

An UntypedAtomicConverter is an expression that converts any untypedAtomic items in a sequence to a specified type

An UpdateAgent is a callback class that is called to handle a document after it has been updated.

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 class represents a call to a user-defined function in the stylesheet or query.

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.

A class to hold some static constants and methods associated with processing UTF16 and surrogate pairs

This exception indicates a failure when validating an instance against a type defined in a schema.

A value is the result of an expression but it is also an expression in its own right.

An xsl:value-of element in the stylesheet.

ValueTailIterator iterates over a base sequence starting at an element other than the first.

Variable reference: a reference to a variable.

An expression representing a nodeset that is a union, difference, or intersection of two other NodeSets

This class represents a 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.

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

This class provides helper methods and constants for handling whitespace

A node in the XML parse tree representing a text node with compressed whitespace content

The class XdmAtomicValue represents an item in an XPath 2.0 sequence that is an atomic value.

The class XdmEmptySequence represents an empty sequence in the XDM Data Model.

This class represents a node in the XDM data model.

An iterator over an XPath sequence.

XHTMLEmitter is an Emitter that generates XHTML output.

This class performs URI escaping for the XHTML output method.

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.

XMLIndenter: This ProxyReceiver indents elements, by adding character data where appropriate.

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.

An XPathCompiler object allows XPath queries to be compiled.

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 object represents the dynamic XPath execution context for use in the free-standing Saxon XPath API.

XPathEvaluator provides a simple API for standalone XPath processing (that is, executing XPath expressions in the absence of an XSLT stylesheet).

Subclass of XPathException used to report circularities

This class is a representation of an XPath Expression for use with the XPathEvaluator class.

Saxon implementation of the JAXP 1.3 XPathFactory

The XPathFunctionLibrary is a FunctionLibrary that supports binding of XPath function calls to instances of the JAXP XPathFunction interface returned by an XPathFunctionResolver.

This interface defines methods that must be provided when Saxon's free-standing XPath API is used.

An XQueryCompiler object allows XQuery 1.0 queries to be compiled.

An XQueryEvaluator represents a compiled and loaded stylesheet ready for execution.

XQueryExpression represents a compiled query.

XQueryFunctionBinder is an extension of the FunctionLibrary interface used for function libraries that contain user-written XQuery functions.

A Simple trace listener for XQuery that writes messages (by default) to System.err

An xsl:apply-imports element in the stylesheet

xsl:attribute element in stylesheet.

An xsl:call-template element in the stylesheet

An xsl:choose elements in the stylesheet.

Handler for xsl:copy elements in stylesheet.

Handler for xsl:decimal-format elements in stylesheet.

An xsl:element element in the stylesheet.

Handler for xsl:for-each elements in stylesheet.

Handler for xsl:function elements in stylesheet (XSLT 2.0).

This class defines common behaviour across xsl:variable, xsl:param, and xsl:with-param

xsl:import element in the stylesheet.

xsl:include element in the stylesheet.

Handler for xsl:matching-substring and xsl:non-matching-substring elements in stylesheet.

An xsl:namespace element in the stylesheet.

An xsl:next-match element in the stylesheet

Handler for xsl:otherwise elements in stylesheet.

An xsl:output-character element in the stylesheet.

Handler for xsl:perform-sort elements in stylesheet (XSLT 2.0).

An xsl:processing-instruction element in the stylesheet.

An xsl:sequence element in the stylesheet.

Common superclass for XSLT elements whose content template produces a text value: xsl:attribute, xsl:comment, and xsl:processing-instruction

An XsltCompiler object allows XSLT 2.0 stylesheets to be compiled.

An XsltExecutable represents the compiled form of a stylesheet.

This is a marker interface used to identify functions that are defined in XSLT rather than in XPath

A Simple trace listener for XSLT that writes messages (by default) to System.err

An xsl:value-of element in the stylesheet.

Generic class for xsl:variable and xsl:param elements.

An xsl:with-param element in the stylesheet.