Package net.sf.saxon.s9api

package net.sf.saxon.s9api

This package provides Saxon's preferred Java API for XSLT, XQuery, XPath, and XML Schema processing. Unlike standard Java APIs such as JAXP and XQJ, this API provides a consistent and integrated approach to the entire functionality of the Saxon product.

An application starts by loading a Processor, which allows configuration options to be set. Whenever possible, an application should instantiate a single Processor and use it for the duration of the application, across all threads.

The interfaces for XSLT, XQuery, and XPath processing all follow the same pattern. There is a three-stage execution model: first a compiler is created using a factory method in the Processor object. The compiler holds compile-time options and the static context information. Then the compiler's compile() method is called to create an executable, a representation of the compiled stylesheet, query, or expression. This is thread-safe and immutable once created. To run the query or transformation, first call the load() method to create a run-time object called variously an XsltTransformer, XQueryEvaluator, or XPathSelector. This holds run-time context information such as parameter settings and the initial context node; the object is therefore not shareable and should only be run in a single thread; indeed it should normally only be used once. This object also provides methods allowing the transformation or query to be executed.

The interfaces for schema processing in Saxon-EE have changed a little in Saxon 13 to accommodate the fact that a Processor can now hold multiple schemas, each of which can be used independently (previously multiple schema documents could be loaded, but they were all aggregated into a single schema). A schema is represented by the class XsdSchema, and is built using an XsdCompiler obtained from the Processor. The XsdSchema can be used to create a SchemaValidator for validating instance documents, and it can be supplied to an XSLT, XQuery, or XPath compiler for executing schema-aware transformations and queries.

Source documents can be constructed using a DocumentBuilder, which holds all the options and parameters to control document building.

The output of a transformation, or of any other process that generates an XML tree, can be sent to a Destination. There are a number of implementations of this interface, including a Serializer which translates the XML document tree into lexical XML form.

There are classes to represent the objects of the XDM data model, including XdmValue, XdmItem, XdmNode, and XdmAtomicValue. These can be manipulated using methods based on the Java 8 streams processing model: for details see package net.sf.saxon.s9api.streams.

Related Packages

Package	Description
net.sf.saxon	This is the top-level package containing the code used to build Saxon-HE.
net.sf.saxon.s9api.push	This package contains an API for lightweight document construction.
net.sf.saxon.s9api.streams	This package (introduced in Saxon 9.9) provides methods to manipulate XDM values using Java 8 streams.

Class	Description
AbstractDestination	An abstract class providing reusable code for implementing the Destination interface
AbstractXsltTransformer	A class that exists to contain common code shared between XsltTransformer and Xslt30Transformer.
Action	A completely general functional interface for functions that take no arguments, return void, and potentially throw a SaxonApiException.
Axis	This is an enumeration class containing constants representing the thirteen axes available in XPath versions from 1.0 to 3.1, together with four new axes defined experimentally in XPath 4.0.
BuildingContentHandler	A SAX ContentHandler that builds a Saxon tree, and allows the node at the root of the tree to be retrieved on completion.
BuildingStreamWriter	A BuildingStreamWriter allows a document to be constructed by calling the methods defined in the XMLStreamWriter interface; after the document has been constructed, its root node may be retrieved by calling the BuildingStreamWriter.getDocumentNode() method.
Destination	A Destination represents a place where XDM values can be sent.
DestinationHelper	A helper class for implementing the Destination interface.
DocumentBuilder	A document builder holds properties controlling how a Saxon document tree should be built, and provides methods to invoke the tree construction.
DOMDestination	This class represents a Destination (for example, the destination of the output of a transformation) in which the results are written to a newly constructed DOM tree in memory.
ExtensionFunction	This is an interface for simple external/extension functions.
HostLanguage	Identifies a host language in which XPath expressions appear.
ItemType	An item type, as defined in the XPath/XQuery specifications.
ItemType.BuiltInAtomicItemType	ItemType representing a built-in atomic type
ItemTypeFactory	This class is used for creating ItemType objects.
JsonBuilder	A JsonBuilder is used to parse JSON documents.
Location	Saxon interface to represent a location, typically the location of an expression within a query or stylesheet.
Message	A Message represents the output of an xsl:message or xsl:assert instruction.
MessageListener	A user-written implementation of the MessageListener interface may be registered with the XsltTransformer to receive notification of xsl:message output.
MessageListener2	Deprecated.
NullDestination	A NullDestination is a Destination that discards all output sent to it.
OccurrenceIndicator	Represents one of the possible occurrence indicators in a SequenceType.
Processor	The Processor class serves three purposes: it allows global Saxon configuration options to be set; it acts as a factory for generating XQuery, XPath, and XSLT compilers; and it owns certain shared resources such as the Saxon NamePool and compiled schemas.
QName	The QName class represents an instance of xs:QName, as defined in the XPath data model.
RawDestination	An RawDestination is a Destination that accepts a sequence output by a stylesheet or query and returns it directly as an XdmValue, without constructing an XML tree, and without serialization.
SAXDestination	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.
SaxonApiException	An exception thrown by the Saxon s9api API.
SaxonApiUncheckedException	An unchecked exception thrown by the Saxon API.
SchemaManager	Deprecated. since Saxon 13.0 - use XsdCompiler
SchemaValidator	A SchemaValidator is an object that is used for validating instance documents against a schema.
SequenceType	A SequenceType is the combination of an ItemType and an OccurrenceIndicator.
Serializer	A Serializer takes an XDM value and outputs a textual representation of the content.
Serializer.Property	Enumeration class defining the permitted serialization properties.
TeeDestination	A TeeDestination allows writing to two destinations at once.
UnprefixedElementMatchingPolicy	An enumeration defining possible strategies for resolving unprefixed element names appearing as name tests in the steps of a path expression or XSLT match pattern
ValidationMode	Enumeration class defining different schema validation (or construction) modes
WhitespaceStrippingPolicy	WhitespaceStrippingPolicy is class defining the possible policies for handling whitespace text nodes in a source document.
XdmArray	An array in the XDM data model.
XdmAtomicValue	The class XdmAtomicValue represents an item in an XPath sequence that is an atomic value.
XdmDestination	An XdmDestination is a Destination in which an XdmNode is constructed to hold the output of a query or transformation: that is, a tree using Saxon's implementation of the XDM data model
XdmEmptySequence	The class XdmEmptySequence represents an empty sequence in the XDM Data Model.
XdmExternalObject	The class XdmExternalObject represents an XDM item that wraps an external (Java or .NET) object.
XdmFunctionItem	The class XdmFunctionItem represents a function item.
XdmItem	The class XdmItem represents an item in a sequence, as defined by the XDM data model.
XdmJNode	This class represents a JNode in the XDM data model.
XdmMap	A map in the XDM data model.
XdmNode	This class represents a node in the XDM data model.
XdmNodeKind	Enumeration class defining the seven kinds of node defined in the XDM model
XdmSequenceIterator<T extends XdmItem>	An iterator over an XPath sequence.
XdmValue	A value in the XDM data model.
XmlProcessingError	The XmlProcessingError class contains information about an error detected during compilation or execution of a stylesheet, query, XPath expression, or schema
XPathCompiler	An XPathCompiler object allows XPath queries to be compiled.
XPathExecutable	An XPathExecutable represents the compiled form of an XPath expression.
XPathSelector	An XPathSelector represents a compiled and loaded XPath expression ready for execution.
XQueryCompiler	An XQueryCompiler object allows XQuery queries to be compiled.
XQueryEvaluator	An XQueryEvaluator represents a compiled and loaded query ready for execution.
XQueryExecutable	An XQueryExecutable represents the compiled form of a query.
XsdCompiler	The XsdCompiler is used to load schema documents, and to set options for the way in which they are loaded.
XsdSchema	This class represents an XSD Schema - that is, a set of schema components, typically resulting from compiling a collection of one or more source schema documents.
Xslt30Transformer	An Xslt30Transformer represents a compiled and loaded stylesheet ready for execution.
XsltCompiler	An XsltCompiler object allows XSLT stylesheets to be compiled.
XsltExecutable	An XsltExecutable represents the compiled form of a stylesheet.
XsltExecutable.ParameterDetails	Inner class containing information about a global parameter to a compiled stylesheet
XsltPackage	An XsltPackage object represents the result of compiling an XSLT 3.0 package, as represented by an XML document containing an xsl:package element.
XsltTransformer	An XsltTransformer represents a compiled and loaded stylesheet ready for execution.