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.
This is the standard trace listener used when the -T option is specified on the command line.
This class implements the XPath 2.0 functions
adjust-date-to-timezone(), adjust-time-timezone(), and adjust-dateTime-timezone().
This class implements the sum(), avg(), count() functions,
The AllElementStripper refines the Stripper class to do stripping of
all whitespace nodes in a document
A Comparer that treats strings as an alternating sequence of alpha parts and numeric parts.
An xsl:analyze-string elements in the stylesheet.
This class enumerates the ancestor:: or ancestor-or-self:: axes,
starting at a given node.
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 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.
Iterator that concatenates the results of two supplied iterators
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.
Inner class to handle addition or subtraction of a Date (or Time, or DateTime) and a Duration
Inner class to handle subtraction of a Date (or Time, or DateTime) from another, to return a Duration
Inner class to handle addition and subtraction of two durations
Inner class to handle division of two durations to give a number
Inner class to handle multiplication (or division) of a duration by a number
Inner class to handle numeric arithmetic expressions
ArrayIterator is used to enumerate items held in an array.
This class defines properties of the US-ASCII character set
saxon:assign element in stylesheet.
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
A Comparator used for comparing atomic values of arbitrary item types.
Marker 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.
A SequenceIterator is used to iterate over a sequence.
An Atomizer is an expression corresponding essentially to the fn:data() function: it
maps a sequence by replacing nodes with their typed values
Implement the mapping function.
An instruction derived from an xsl:attribute element in stylesheet, or from
an attribute constructor in XQuery
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.
AttributeEnumeration is an iterator over all the attribute nodes of an Element.
AttributeEnumeration is an enumeration of all the attribute nodes of an Element.
A node in the XML parse 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 wraps a JAXP Source object to provide an extended Source object that
contains options indicating how the Source should be processed: for example,
whether or not it should be validated against a schema.
This class supports the XSLT element-available and function-available functions.
An axis, that is a direction of navigation in the document structure.
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.
A value of type xs:base64Binary
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
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.
Implements an imaginary xsl:block instruction which simply evaluates
its contents.
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
This class establishes properties of a character set that is
known to the Java VM but not specifically known to Saxon.
The abstract Builder class is responsible for taking a stream of SAX events
and constructing a Document tree.
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 xdt:dayTimeDuration).
This class is used to implement the built-in
list types NMTOKENS, ENTITIES, IDREFS.
This class is used to construct Schema objects containing all the built-in types:
that is, the types defined in the "xs" and "xdt" namespaces.
Abstract superclass for Date, Time, and DateTime.
A comparer specifically for comparing two date, time, or dateTime values
Instruction representing an xsl:call-template element in the stylesheet.
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
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 )".
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.
CharacterMapExpander: This ProxyReceiver expands characters occurring in a character map,
as specified by the XSLT 2.0 xsl:character-map declaration
This interface defines properties of a character set, built in to the Saxon product.
This class creates 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 ClosingAction is an action that can be performed by a
ClosingIterator when the end of a
sequence is reachedA closing iterator returns the items delivered by an underlying iterator unchanged, and
calls a user-supplied function when the underlying iterator hits the end of the sequence.
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 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.
An AtomicComparer used for comparing strings, untypedAtomic values, and URIs using a collation.
Abstract superclass for all functions that take an optional collation argument
This object maps collation URIs to collations.
A CollationURIResolver accepts a collation name as input, and returns
a collation (represented by a Comparator) 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").
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 Compile class provides a command-line interface allowing a
stylesheet to be compiled.
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.
A complex type as defined in XML Schema: either a user-defined complex type, or xs:anyType.
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 representing an xsl:element element in an XSLT stylesheet,
or a computed element constructor in XQuery.
This class is an abstract superclass for different kinds of expression.
This class holds details of user-selected configuration options for a transformation
or query.
The ConstructorFunctionLibrary represents the collection of constructor functions for atomic types.
A Container is something that can act as the parent of an expression.
This class implements the contains(), starts-with(), ends-with(),
substring-before(), and substring-after() functions
A ContentHandlerProxy is a Receiver that converts events into the form expected by an
underlying SAX2 ContentHandler.
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.
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
An xsl:copy-of element in the stylesheet.
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 CP1251 Cyrillic character set,
as defined at http://www.microsoft.com/globaldev/reference/sbcs/1251.htm.
This class defines properties of the CP1252 (Latin 1) character set,
as defined at http://www.microsoft.com/globaldev/reference/sbcs/1252.htm.
This package defines character set CP852
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 functions current-group() and 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.
This interface may be implemented by an external debugging tool
DecimalFormatManager manages the collection of named and unnamed decimal formats
A Comparator 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
This interface represents the union of global variable declarations and function declarations in XQuery
modules
An iterator supplying the prefixes of the declared namespaces for an element node in a TinyTree
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.
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
Implement the fn:doc() function - a simplified form of the Document function
A saxon:doctype element in the stylesheet.
Implements the XSLT document() function
Implementation of JAXP 1.1 DocumentBuilderFactory.
This class implements the JAXP DocumentBuilder interface, allowing a Saxon TinyTree to be
constructed using standard JAXP parsing interfaces.
This is a filter that can be added to a pull pipeline to remove START_DOCUMENT and END_DOCUMENT
events.
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.
Sends an entire document to a Receiver.
A DocumentSorter is an expression that sorts a sequence of nodes into
document order.
DocumentValidator checks that a document is well-formed: specifically, that it contains a single element
node child and no text node children.
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 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).
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.
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 a DOM Document
A Comparator 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
Subclass of XPathException used for dynamic errors
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.
An instruction that creates an element node.
ElementImpl implements an element with no attributes or namespace declarations.
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
This class is an implementation of the DOM Element class that wraps a Saxon NodeInfo
representation of an element node.
A node in the XML parse tree representing an XML element.
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.
A class representing an empty set of namespace declarations
An EmptySequence object represents a sequence containing no members.
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.
This class supports the functions encode-for-uri() and iri-to-uri()
This class implements the saxon:evaluate(), saxon:expression(), and saxon:eval() extension functions,
which are specially-recognized by the system because they need access to parts of the static context
Inner class PreparedExpression represents a compiled XPath expression together
with the standard variables $p1 ..
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.
Implement the exists() and empty() functions
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.
This class, ExpressionTool, contains a number of useful static methods
for manipulating expressions.
This interface contains methods that extend NodeInfo: the extra methods will be added to the NodeInfo
interface at some time in the future.
Interface ExtensionElementFactory.
This class acts as a container for an extension function defined to call a method
in a user-defined class.
This class acts as a factory for creating expressions that call Java extension functions.
Abstract class representing an extension instruction
This class implements functions that are supplied as standard with SAXON,
but which are not defined in the XSLT or XPath specifications.
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, names of Saxon configuration
options which can be supplied to the Saxon implementations of the JAXP
interfaces TransformerFactory, SchemaFactory, Validator, and ValidationHandler.
Filter 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)
A FilterIterator filters an input sequence using a filter expression.
Subclass to support the extension function saxon:leading, which terminates
the iteration at the first item whose predicate is false
Subclass to handle the common special case where it is statically known
that the filter cannot return a numeric value
This is a marker interface used to identify nodes that contain a namepool 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
Iterate over the following axis starting at a given node.
This class implements the upper-case() and lower-case() functions
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.
Implement the format-date() function in XPath 2.0
XSLT 2.0 implementation of format-number() function - removes the dependence on the JDK.
Abstract superclass for calls to system-defined and user-defined functions
A FunctionLibrary handles the binding of function calls in XPath (or XQuery) expressions.
A FunctionLibraryList is a list of FunctionLibraries.
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.
This class defines common behaviour across xsl:variable, xsl:param, and xsl:with-param;
also saxon:assign
A Comparator 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 the 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 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 GroupStartingIterator iterates over a sequence of groups defined by
xsl:for-each-group group-starting-with="x".
Implementation of the xs:gYearMonth data type
Implementation of the xs:gYear data type
A value of type xs:hexBinary
This class generates HTML output
HTMLIndenter: This ProxyEmitter indents HTML elements, by adding whitespace
character data where appropriate.
A simple class for testing membership of a fixed set of case-insensitive ASCII strings.
This class is used as a filter on the serialization pipeline; it performs the function
of escaping URI-valued attributes in HTML
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.
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.
An IDPattern is a pattern of the form id("literal") or id($variable)
NodeTest is an interface that enables a test of whether a node matches particular
conditions.
An IfExpression returns the value of either the "then" part or the "else" part,
depending on the value of the condition
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 expression or pattern appearing
in a context other than a stylesheet.
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.
This class supports fuctions get-in-scope-prefixes()
The XPath 2.0 insert-before() function
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, made
available at run-time to a TraceListener
An InstructionInfoProvider is an object that is capable of providing an InstructionInfo
object which provides diagnostic information about an instruction or other construct such
as a function, template, expression, or pattern.
Set of int values.
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, N, and M are all expressions of type integer.
An integer value: note this is a subtype of decimal in XML Schema, not a primitive type.
An enumeration representing a nodeset that is an intersection of two other NodeSets.
A hash table that maps int keys to Object values.
Set of int values.
An iterator over a sequence of unboxed int values
A hash table that maps int keys to int values.
A position() eq last() expression, generated by the optimizer.
This class defines properties of the ISO-8859-1 character set
This class defines properties of the ISO-8859-2 character set
Description: This class implements the CharacterSet to support ISO-8859-5 (Latin/Cyrillic)
encoding.
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
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.
ItemType is an interface that allows testing of whether an Item conforms to an
expected type.
A JavaCollationFactory allows a Collation to be created given
a set of properties that the collation should have.
The JavaExtensionLibrary is a FunctionLibrary that binds XPath function calls to
calls on Java methods (or constructors, or fields).
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.
This class translates XML Schema regex syntax into JDK 1.4 regex syntax.
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.
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.
KeyManager manages the set of key definitions in a stylesheet, and the indexes
associated with these key definitions.
A KeyPattern is a pattern of the form key(keyname, keyvalue)
This class defines properties of the KO18R Cyrillic character set
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 1.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 LazyExpression is an expression that forces lazy evaluation: it must not be evaluated eagerly,
because a failure must not be reported unless the value is actually referenced.
A LetExpression is modelled on the XQuery syntax let $x := expr return expr.
Line numbers are not held in nodes in the tree, because they are not usually needed.
Class ListIterator, iterates over a sequence of items held in a Java ArrayList,
or indeed in any other kind of List
Interface representing a simple type of variety List
This class represents a literal result element in the style sheet
(typically an HTML element to be output).
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 in the stylesheet or an
external variable in a Query.
Handler for local xsl:variable elements in stylesheet.
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.
A Comparer used for comparing keys
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 Emitter for 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)
A value of type xsd:yearMonthDuration
An iterator that combines the results of a sequence of iterators
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 supports the name(), local-name(), and namespace-uri() functions
from XPath 1.0, and also the XSLT generate-id() function
An object representing a collection of XML names, each containing a Namespace URI,
a Namespace prefix, and a local name; plus a collection of namespaces, each
consisting of a prefix/URI pair.
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.
An xsl:namespace element in the stylesheet.
This class is not instantiated, it exists to hold a set of constants representing known
namespaces.
This class bridges between the JAXP 1.3 NamespaceContext interface and Saxon's
equivalent NamespaceResolver interface.
This interface represents a collection of namespace declarations or
undeclarations, typically those appearing together in an element start tag.
An implementation of the NamespaceDeclarations interface,
based on encapsulating an array of namespace codes.
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 implementation of the namespace axis over any implementation
of the data model.
Inner class: a model-independent representation of a namespace node
NamespaceReducer is a ProxyReceiver responsible for removing duplicate namespace
declarations.
Abstract class that supports lookup of a lexical QName to get the expanded QName.
An implentation of NamespaceDeclarations that contains all the inscope namespaces
made available by a NamespaceResolver.
NodeTest is an interface that enables a test of whether a node has a particular
name and type.
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.
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.
An xsl:next-match element in the stylesheet
This class supports the nilled() function
Interface NodeFactory.
A node in the XML parse tree representing an XML element, character content, or attribute.
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.
A Comparer used for comparing nodes in document order
This class implements the DOM Node interface as a wrapper around a Saxon NodeInfo object.
A NodeTest is a simple kind of pattern that enables a context-free test of whether
a node has a particular
name.
A NodeTestPattern is a pattern that consists simply of a NodeTest.
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.
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.
NodeTest is an interface that enables a test of whether a node has a particular
name and type.
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
An xs:NOTATION value.
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_en does number formatting for language="en".
Class Numberer_fr is a number formatter for french.
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 NumericPromoter performs numeric promotion on each item in a supplied sequence
NumericValue is an abstract superclass for IntegerValue, DecimalValue,
FloatValue, and DoubleValue
An XPath value that encapsulates a Java object.
This class doesn't actually do any optimization itself, despite the name.
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 implements the saxon:parse() extension function,
which is specially-recognized by the system because it needs access
to parts of the static context
An expression that establishes a set of nodes by following relationships between nodes
in the document.
A Pattern represents the result of parsing an XSLT pattern string.
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
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 interface provides access to methods whose implementation depends on the chosen platform
(typically Java or .NET)
This interface defines properties of a pluggable character set, that is, a user-supplied
character set.
A PositionIterator selects a subsequence of a sequence
PositionRange: a boolean expression that tests whether the position() is
within a certain range.
Enumerate all the nodes on the preceding axis from a given start node.
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.
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.
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.
PullFilter is a pass-through filter class that links one PullProvider to another PullProvider
in a pipeline.
This class delivers any XPath sequence through the pull interface.
PullNamespaceReducer is a PullFilter responsible for removing duplicate namespace
declarations.
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.
This class bridges PullProvider events to XMLStreamReader (Stax) events.
PullTracer is a PullFilter that can be inserted into a pull pipeline for diagnostic purposes.
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())
A QName value.
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.
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 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.
This is a generic version of C.A.R Hoare's Quick Sort
algorithm.
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").
Iterator that produces numeric values in a monotonic sequence,
ascending or descending.
Represents the defining occurrence of a variable declared for local use
within an expression, for example the $x in "for $x in ...".
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.
This class is an interator that supports the evaluation of xsl:analyze-string.
Thrown when an syntactically incorrect regular expression is detected.
This interface represents a compiled regular expression
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
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
A value conforming to one of the built-in subtypes of String, specifically
normalizedString, token, language, Name, NCName, ID, IDREF, ENTITY, NMTOKEN.
The compiled form of an xsl:result-document element in the stylesheet.
Implement XPath function fn:reverse()
ReverseArrayIterator is used to enumerate items held in an array in reverse order.
A Reverser is an expression that reverses the order of a sequence of items.
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
An object representing a list of Namespaces.
saxon:assign element in stylesheet.
A saxon:call-template element in the stylesheet.
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.
Saxon implementation of the JAXP class javax.xml.datatype.Duration.
A saxon:entity-ref 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.
Provides string constants that can be used to set
output properties for a Transformer, or to retrieve
output properties from a Transformer or Templates object.
A saxon:script element in the stylesheet.
Handler for saxon:while elements in stylesheet.
Saxon implementation of the JAXP class javax.xml.datatype.XMLGregorianCalendar.
Saxon implementation of the XQL interface XQConnection.
Saxon implementation of the XQJ interface XQDataFactory.
Saxon implementation of the XQJ XQDataSource interface.
Created by IntelliJ IDEA.
The class is a Saxon implementation of the XQJ interface XQResultSequence.
Saxon implementation of the XQJ interface XQPreparedExpression.
Saxon implementation of the XQSequence interface in XQJ, which represents an XDM sequence together
with a current position.
Created by IntelliJ IDEA.
This is a marker interface that represents any "schema component" as defined in the XML Schema
specification.
This is a marker interface that acts as a surrogate for an object representing
a global element or attribute declaration.
An exception that identifies an error in reading, parsing, or
validating a schema.
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 value of type xsd:dayTimeDuration
Sender is a helper class that sends events to a Receiver from any kind of Source object
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.
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.
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
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.
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.
This class implements the rules for an XSLT 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.
An abstract implementation of Expression designed to make it easy to implement new expressions,
in particular, expressions to support extension instructions.
A simple mapping expression is an expression A/B where B has a static type that is an atomic type.
Common superclass for XSLT instructions whose content template produces a text
value: xsl:attribute, xsl:comment, xsl:processing-instruction, xsl:namespace,
and xsl:text
This interface represents a simple type, which may be a built-in simple type, or
a user-defined simple type.
A node set expression that will always return zero or one nodes
A SingletonAtomizer combines the functions of an Atomizer and a CardinalityChecker: it is used to
atomize a sequence of nodes, checking that the result of the atomization contains zero or one atomic
values.
Class to handle comparisons of singletons.
SingletonIterator: an iterator over a sequence of zero or one values
A value that is a sequence containing zero or one nodes
A Sink is an Receiver that discards all information passed to it
A SliceExpression represents a FilterExpression of the form EXPR[position() > n and position() invalid input: '<' m],
where n and m are not necessarily constants
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
A SortedTupleIterator is a modified SortedIterator.
Expression equivalent to the imaginary syntax
expr sortby (sort-key)+
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)This interface defines a SourceResolver.
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.
Class SQLElementFactory.
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.
A StandaloneContext provides a context for parsing an XPath expression
in a context other than a stylesheet.
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.
Implementation of XQCommonHandler that performs the mappings between Java and XPath
as defined in the XQJ specification.
StandardErrorListener is the standard error handler for XSLT 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.
This class defines the default OutputURIResolver.
This class provides the service of converting a URI into an InputSource.
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
(added by the working groups on 24 August 2004)
A StaticContext contains the information needed while an expression or pattern
is being parsed.
Exception used for static errors in XPath, XSLT, or XQuery
This class contains constants identifying dependencies that an XPath expression
might have on its context.
StaticQueryContext is the implementation of StaticContext used when processing XQuery
expressions.
This class implements the Saxon PullProvider API on top of a standard StAX parser
(or any other StAX XMLStreamReader implementation)
Implement XPath function string()
xf:string-join(string* $sequence, string $separator)
Implement the XPath string-length() function
StringTokenIterator: breaks a string up into tokens,
and returns the tokens as a sequence of strings.
An atomic value of type xs:string
A StrippedDocument 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.
The Stripper class maintains details of which elements need to be stripped.
Abstract superclass for all element nodes in the stylesheet.
Class StyleNodeFactory.
A StylesheetFunctionLibrary contains functions defined by the user in a stylesheet.
This interface is implemented by all XSL elements that can contain local variable declarations.
The StylesheetStripper refines the Stripper class to do stripping of
whitespace nodes on a stylesheet.
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 class implements the XPath substring() 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.
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.
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
TeeOutputter: a SequenceReceiver that duplicates received events to two different destinations
An xsl:template element in the style sheet.
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
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 Simple trace listener that writes messages to System.err
A value of type xs:time
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.
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 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 class which implements efficient and thread-safe multi-cast event
dispatching for the TraceListener evants.
A subclass of TraceWrapper used to trace expressions in XPath and XQuery.
A run-time instruction which wraps a real instruction and traces its entry and exit to the
TraceListener
This interface defines methods that are called by Saxon during the execution of
a stylesheet, if tracing is switched on.
This class is a tracing wrapper around any expression: it delivers the same result as the
wrapped expression, but traces its evaluation to a TraceListener
A filter that can be inserted into a Receiver pipeline to trace the events that pass through
This Transform class is the 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.
Treat Expression: implements "treat as data-type ( expression )".
This class supports the XPath 2.0 functions exactly-one(), one-or-more(), zero-or-one().
The Builder class is responsible for taking a stream of SAX events and constructing
a Document tree.
A TreeReceiver acts as a bridge between a SequenceReceiver, which can receive
events for constructing any kind of sequence, and an ordinary Receiver, which
only handles events relating to the building of trees.
This implementation of the Saxon pull interface starts from any NodeInfo,
and returns the events corresponding to that node and its descendants (including
their attributes and namespaces).
A tuple expression is an expression that returns a tuple.
A TupleSorter is an expression that sorts a stream of tuples.
This class contains static information about types and methods for constructing type codes.
This class provides Saxon's type checking capability.
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.
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.
A document node whose construction is deferred.
An element 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.
An UndeclaredVariable object is created when a reference is encountered to a variable
that has not yet been declared.
This class supports the two functions string-to-codepoints() and codepoints-to-string()
This class defines properties of the Unicode character set
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
This class establishes properties of a character set that is
known to the Java VM but not specifically known to Saxon
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
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 UntypedAtomicConverter is an expression that converts any untypedAtomic items in
a sequence to a specified type
An Untyped Atomic value.
A Comparer used for comparing strings, with upper case collated before lower case
if the strings are otherwise equal.
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 function defined 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
This class contains constants and static methods to manipulate the validation
property of a type.
A ValidationErrorValue is a pseudo-value representing the result of a validation failure.
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.
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.
An object representing an XPath variable for use in the standalone XPath API.
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
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.
A virtual tree walker provides a sequence of pull events describing the structure and content of a tree
that is conceptually being constructed by expressions in a query or stylesheet; in fact the tree is
not necessarily constructed in memory, and exists only as this stream of pull events.
Handler for saxon:while elements in stylesheet.
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
An instruction derived from a xsl:with-param element in the stylesheet.
XHTMLEmitter is an Emitter that generates XHTML output.
XHTMLIndenter: This class indents XHTML elements, by adding whitespace
character data where appropriate.
This class performs URI escaping for the XHTML output method.
This class is used on the serialization pipeline to check that the document conforms
to XML 1.0 rules.
This class defines the basic properties of characters in XML 1.1.
This class defines the basic XML character properties.
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 represents a context in which an XPath expression is evaluated.
This class represents a "major context" in which an XPath expression is evaluated:
a "major context" object allows all aspects of the dynamic context to change, whereas
a "minor context" only allows changes to the focus and the destination for push output.
An XSLTContext object holds all the additional dynamic context items used in XSLT.
This class represents a minor change in the dynamic context in which an XPath expression is evaluated:
a "major context" object allows all aspects of the dynamic context to change, whereas
a "minor context" only allows changes to the focus and the destination for push output.
This is a cut-down version of the XPathEvaluator in the net.sf.saxon.xpath package.
XPathEvaluator provides a simple 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 used to report circularities
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.
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interface reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQJ interfaces reconstructed from version 0.5 documentation
XQueryExpression represents a compiled query.
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
XQJ interfaces reconstructed from version 0.5 documentation
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.
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.
Common superclass for XSLT elements whose content template produces a text
value: xsl:attribute, xsl:comment, and xsl:processing-instruction
An xsl:stylesheet or xsl:transform element in the stylesheet.
An xsl:template element in the style sheet.
Handler for xsl:text elements in stylesheet.
This is a marker interface used to identify functions that are defined in XSLT rather
than in XPath
Extends the standard XPath static context with information that is available for
XPath expressions invoked from XSLT
A Simple trace listener for XSLT that writes messages (by default) to System.err
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.