net.sf.saxon.om

Interface Summary
Interface	Description
Action	A functional interface that simply encapsulates a callback action of any kind, allowing the action to fail with an XPathException.
AtomicSequence	Interface representing a sequence of atomic values.
AtomizedValueIterator<T extends Item<?>>	Interface implemented by an iterator that can deliver atomized results.
AttributeCollection	AttributeCollection represents the collection of attributes available on a particular element node.
FocusIterator<T extends Item<?>>	An iterator that maintains the values of position() and current(), typically implemented as a wrapper over an iterator which does not maintain these values itself.
Function	XDM 3.0 introduces a third kind of item, beyond nodes and atomic values: the function.
GroundedValue<T extends Item<?>>	A value that exists in memory and that can be directly addressed
IdentityComparable	The IdentityComparable class provides a way to compare class objects for strong equality.
Item<T extends Item<?>>	An Item is an object that can occur as a member of a sequence.
ItemConsumer<T extends Item>	A FunctionalInterface for any method that processes individual items, and which may generate exceptions.
MutableDocumentInfo	Interface representing the document node of a mutable document
MutableNodeInfo	An extension of the NodeInfo interface defining a node that can be updated.
NamespaceBindingSet	Represents a set of namespace bindings
NamespaceResolver	Abstract class that supports lookup of a lexical QName to get the expanded QName.
NodeInfo	The NodeInfo interface represents a node in Saxon's implementation of the XPath 2.0 data model.
NodeName	This interface represents a node name.
NotationSet	A set of declared notations (in the sense of XSD xs:notation)
Sequence<T extends Item<?>>	This interface represents an XDM Value, that is, a sequence of items.
SequenceIterator<T extends Item<?>>	A SequenceIterator is used to iterate over any XPath 2 sequence (of values or nodes).
SpaceStrippingRule	Interface for deciding whether a particular element is to have whitespace text nodes stripped
TreeInfo	This interface represents information about a tree as a whole.
UnfailingItemConsumer<T extends Item>	A FunctionalInterface for any method that processes individual items.

Class Summary
Class	Description
AbsolutePath	Represents the path from the root of an XDM tree to a specific node, as a sequence of (name, position) pairs
AbsolutePath.PathElement	Inner class representing one step in the path
AllElementsSpaceStrippingRule	A whitespace stripping rule that strips all elements unless xml:space indicates that whitespace should be preserved.
AtomicArray	A sequence of atomic values, implemented using an underlying arrayList.
AxisInfo	An axis, that is a direction of navigation in the document structure.
Chain	A chain is an implementation of Sequence that represents the concatenation of a number of subsequences.
CodedName	An implementation of NodeName that encapsulates an integer fingerprint, a string prefix, and a reference to the NamePool from which the fingerprint was allocated.
CopyOptions	Non-instantiable class to define options for the `NodeInfo.copy(net.sf.saxon.event.Receiver, int, net.sf.saxon.expr.parser.Location)` method
DocumentInfo	The class DocumentInfo is retained in Saxon 9.7 to preserve a level of backwards compatibility for applications that use the method `Configuration.buildDocument(Source)` method to construct a tree.
DocumentPool	An object representing the collection of documents handled during a single transformation.
DocumentURI	This class encapsulates a string used as the value of the document-uri() property of a document, together with a normalized representation of the string used for equality comparisons.
FingerprintedQName	A QName triple (prefix, URI, local) with the additional ability to hold an integer fingerprint.
FocusTrackingIterator<T extends Item<?>>	An iterator that maintains the values of position() and current(), as a wrapper over an iterator which does not maintain these values itself.
GenericTreeInfo	A generic (model-independent) implementation of the TreeInfo interface, suitable for use with all tree models where the object representing the document node does not itself act as the TreeInfo implementation
IgnorableSpaceStrippingRule	A whitespace stripping rule that strips whitespace text node children from all elements having an element-only content model, regardless of the value of the xml:space attribute
InscopeNamespaceResolver	A NamespaceResolver that resolves namespace prefixes by reference to a node in a document for which those namespaces are in-scope.
InScopeNamespaces	Represents the set of all namespace bindings that are in scope for a particular element node
LazySequence<T extends Item<?>>	A sequence that wraps an iterator, without being materialized.
MemoSequence<T extends Item<?>>	A Sequence implementation that represents a lazy evaluation of a supplied iterator.
NameChecker	The NameChecker performs validation and analysis of XML names.
NameOfNode	An implementation of NodeName that gets the name of an existing NodeInfo object.
NamePool	A NamePool holds a collection of expanded names, each containing a namespace URI, and a local name.
NamespaceBinding	Represents the binding of a prefix to a URI.
NoElementsSpaceStrippingRule	A whitespace stripping rule that retains all whitespace text nodes
NoNamespaceName	An implementation of NodeName for the common case of a name in no namespace
One<T extends Item<?>>	A sequence containing exactly one item.
OneOrMore<T extends Item<?>>	A value that is a sequence containing one or more items.
PrefixPool	A prefix pool maintains a two-way mapping from namespace prefixes (as strings) to integer prefix codes.
QNameParser	Parser to handle QNames in either lexical QName or EQName syntax, including resolving any prefix against a URIResolver.
SelectedElementsSpaceStrippingRule	A whitespace stripping rule that strips elected elements unless xml:space indicates that whitespace should be preserved.
SequenceTool	Utility class for manipulating sequences.
StandardNames	Well-known names used in XSLT processing.
StructuredQName	This class provides an economical representation of a QName triple (prefix, URI, and localname).
StylesheetSpaceStrippingRule	A whitespace stripping rule that strips whitespace according to the rules defined for XSLT stylesheets
TreeModel	A TreeModel represents an implementation of the Saxon NodeInfo interface, which itself is essentially an implementation of the XDM model defined in W3C specifications (except that Saxon's NodeInfo understands the 13 XPath axes, rather than merely supporting parent and child properties).
ZeroOrMore<T extends Item<?>>	A value that is a sequence containing one or more items.
ZeroOrOne<T extends Item<?>>	A value that is a sequence containing zero or one items.

Enum Summary
Enum	Description
EmptyAtomicSequence	An implementation of AtomicSequence that contains no items.
Genre	The Genre of an item is the top-level classification of its item type: one of Atomic, Node, Function, Map, Array, or External

Exception Summary
Exception	Description
NamePool.NamePoolLimitException	Unchecked Exception raised when some limit in the design of the name pool is exceeded
QNameException	A QNameException represents an error condition whereby a QName (for example a variable name or template name) is malformed

Package net.sf.saxon.om Description

This package defines the interface to the Saxon tree structure. This structure is used to represent both the source document and the stylesheet. Essentially, this class represents Saxon's realization of the XPath data model.

The classes in the package are rather a miscellany. What they have in common is that they describe the way the Saxon tree structure is accessed, in a way that it independent of the two tree implementations (in packages net.sf.saxon.tree and net.sf.saxon.tinytree).

Broadly speaking, the classes fall into four categories:

Interface classes: DocumentInfo, NodeInfo, Item, ValueRepresentation. These describe the interface offered by the object model to the rest of the system, including the application.
Iterator classes: SequenceIterator, AxisIterator, ArrayIterator, EmptyIterator, SingletonIterator, and others. These classes provide mechanisms for iterating over sequences. The most general, and the one which applications are most likely to use, is the SequenceIterator interface itself. AxisIterator is a specialization of this interface whose main difference is that it cannot throw exceptions. The other classes are implementations of SequenceIterator for use in particular circumstances.

Shared implementation classes: DocumentPool, NamePool, Navigator, XMLChar. These contain functionality that is shared between the various tree implementations. (However, there is also some shared functionality in the net.sf.saxon.tree package). These classes are not generally needed by applications, with the exception of NamePool, which complex applications may need to manipulate.

Information classes: Axis, NamespaceConstant. These contain constants.