Package net.sf.saxon.om

This package defines the interface to the Saxon tree structure.

See:
Description

Interface Summary

AttributeCollection	AttributeCollection represents the collection of attributes available on a particular element node.
AxisIterator	A SequenceIterator is used to iterate over a sequence.
DocumentInfo	This interface represents a document node as defined in the XPath 2.0 data model.
ExternalObjectModel	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).
FingerprintedNode	This is a marker interface used to identify nodes that contain a namepool fingerprint.
FunctionItem	XQuery 1.1 introduces a third kind of item, beyond nodes and atomic values: the function item.
GroundedIterator	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.
GroundedValue	A value that exists in memory and that can be directly addressed
Item	An Item is an object that can occur as a member of a sequence.
LookaheadIterator	A SequenceIterator is used to iterate over a sequence.
MutableDocumentInfo	Interface representing the document node of a mutable document
MutableNodeInfo	An extension of the NodeInfo interface defining a node that can be updated.
NamespaceDeclarations	This interface represents a collection of namespace declarations or undeclarations, typically those appearing together in an element start tag.
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.
SequenceIterator	A SequenceIterator is used to iterate over any XPath 2 sequence (of values or nodes).
SiblingCountingNode	Interface that extends NodeInfo by providing a method to get the position of a node relative to its siblings.
UnfailingIterator	A SequenceIterator is used to iterate over a sequence.
ValueRepresentation	A ValueRepresentation is a representation of a Value.
VirtualNode	This interface is implemented by NodeInfo implementations that act as wrappers on some underlying tree.

Class Summary

AllElementStripper	The AllElementStripper refines the Stripper class to do stripping of all whitespace nodes in a document
ArrayIterator	ArrayIterator is used to enumerate items held in an array.
AttributeCollectionImpl	AttributeCollectionImpl is an implementation of both the SAX2 interface Attributes and the Saxon equivalent AttributeCollection.
Axis	An axis, that is a direction of navigation in the document structure.
AxisIteratorImpl	A SequenceIterator is used to iterate over a sequence.
DiagnosticNamePool	This class provides a diagnostic wrapper for the real NamePool.
DocumentNumberAllocator	This class (which has one instance per Configuration) is used to allocate unique document numbers.
DocumentPool	An object representing the collection of documents handled during a single transformation.
EmptyIterator	EmptyIterator: an iterator over an empty sequence.
EmptyNamespaceDeclarationList	A class representing an empty set of namespace declarations
FastStringBuffer	A simple implementation of a class similar to StringBuffer.
InscopeNamespaceResolver	A NamespaceResolver that resolves namespace prefixes by reference to a node in a document for which those namespaces are in-scope.
ListIterator	Class ListIterator, iterates over a sequence of items held in a Java ArrayList, or indeed in any other kind of List
LookaheadIteratorImpl	This class wraps any sequence iterator, turning it into a lookahead iterator, by looking ahead one item
Name10Checker	The class checks names and characters against the rules of the XML 1.0 and XML Namespaces 1.0 specification
Name11Checker	The class checks names against the rules of the XML 1.1 and XML Namespaces 1.1 specification
NameChecker	A NameChecker performs validation and analysis of XML names.
NamePool	A NamePool holds a collection of expanded 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.
NamespaceCodeIterator	This class provides an iterator over the namespace codes representing the in-scope namespaces of any node.
NamespaceConstant	This class is not instantiated, it exists to hold a set of constants representing known namespaces.
NamespaceDeclarationsImpl	An implementation of the NamespaceDeclarations interface, based on encapsulating an array of namespace codes.
NamespaceIterator	This class provides an implementation of the namespace axis over any implementation of the data model.
NamespaceIterator.NamespaceNodeImpl	Inner class: a model-independent representation of a namespace node
NamespaceResolverAsDeclarations	An implementation of NamespaceDeclarations that contains all the inscope namespaces made available by a NamespaceResolver.
NamespaceResolverWithDefault	This class is a NamespaceResolver that modifies an underyling NamespaceResolver by changing the mapping of the null prefix to be a specified namespace, rather than the one used by the underlying namespace resolver.
Navigator	The Navigator class provides helper classes for navigating a tree, irrespective of its implementation
Navigator.AncestorEnumeration	General-purpose implementation of the ancestor and ancestor-or-self axes
Navigator.AxisFilter	AxisFilter is an iterator that applies a NodeTest filter to the nodes returned by an underlying AxisIterator.
Navigator.BaseEnumeration	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().
Navigator.DescendantEnumeration	General-purpose implementation of the descendant and descendant-or-self axes, in terms of the child axis.
Navigator.EmptyTextFilter	EmptyTextFilter is an iterator that applies removes any zero-length text nodes returned by an underlying AxisIterator.
Navigator.FollowingEnumeration	General purpose implementation of the following axis, in terms of the ancestor, child, and following-sibling axes
Navigator.PrecedingEnumeration	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.
NodeArrayIterator	An iterator over an array of nodes.
NodeListIterator	Specialization of ListIterator for use when the items in the list are all nodes
Orphan	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).
PrefixNormalizer
PrependIterator	An iterator over nodes, that prepends a given node to the nodes returned by another iterator.
ProcInstParser	ProcInstParser is used to parse pseudo-attributes within Processing Instructions
ReverseArrayIterator	ReverseArrayIterator is used to enumerate items held in an array in reverse order.
ReverseNodeArrayIterator	Iterator over an array of nodes in reverse order
SingleNodeIterator	SingletonIterator: an iterator over a sequence of zero or one values
SingletonIterator	SingletonIterator: an iterator over a sequence of zero or one values
SpaceStrippedDocument	A SpaceStrippedDocument represents a view of a real Document in which selected whitespace text nodes are treated as having been stripped.
SpaceStrippedNode	A StrippedNode is a view of a node, in a virtual tree that has whitespace text nodes stripped from it.
StandardNames	Well-known names used in XSLT processing.
StructuredQName	This class provides an economical representation of a QName triple (prefix, URI, and localname).
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).
TypeStrippedDocument	A TypeStrippedDocument represents a view of a real Document in which all nodes are untyped
TypeStrippedNode	A TypeStrippedNode is a view of a node, in a virtual tree that has type annotations stripped from it.
Validation	This class contains constants and static methods to manipulate the validation property of a type.
VirtualCopy	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.
VirtualDocumentCopy	A virtual copy of a document node
VirtualUntypedCopy	This class represents a virtual copy of a node with type annotations stripped

Exception Summary

NamePool.NamePoolLimitException	Uncaught Exception raised when some limit in the design of the name pool is exceeded
NamespaceException	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
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.

Michael H. Kay
Saxonica Limited
9 February 2005