# Package net.sf.saxon.om

This package defines the interface to the Saxon tree structure.

See: Description

- Interface Summary
  Interface | Description
  --- | ---
  AtomicSequence | Interface representing a sequence of atomic values.
  AttributeCollection | AttributeCollection represents the collection of attributes available on a particular element node.
  DocumentInfo | This interface represents a document node as defined in the XPath 2.0 data model.
  FingerprintedNode | This is a marker interface used to identify nodes that contain a namepool fingerprint.
  FunctionItem | XDM 3.0 introduces a third kind of item, beyond nodes and atomic values: the function item.
  GroundedValue | A value that exists in memory and that can be directly addressed
  IdentityComparable | The IdentityComparable class provides a way to compare class objects for equality
  Item | An Item is an object that can occur as a member of 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.
  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 | 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

- Class Summary
  Class | Description
  --- | ---
  AbsolutePath | Represents the path from the root of a tree to the node, as a sequence of (name, position) pairs
  AbsolutePath.PathElement | Inner class representing one step in the path
  AbstractItem | Abstract superclass for items
  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 array.
  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 namecode and a reference to the NamePool from which it was allocated.
  CopyOptions | Non-instantiable class to define options for the `NodeInfo.copy(net.sf.saxon.event.Receiver, int, int)` method
  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.
  EmptyAtomicSequence | An implementation of AtomicSequence that contains no items.
  FingerprintedQName | A QName triple (prefix, URI, local) with the additional ability to hold an integer fingerprint.
  InscopeNamespaceResolver | A NamespaceResolver that resolves namespace prefixes by reference to a node in a document for which those namespaces are in-scope.
  LazySequence | A sequence that wraps an iterator, without being materialized.
  MemoSequence | A Sequence implementation that represents a lazy evaluation of a supplied iterator
  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.
  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, a namespace prefix, and a local name.
  NamespaceBinding | Represents the binding of a prefix to a URI.
  NoElementsSpaceStrippingRule | A whitespace stripping rule that strips all elements unless xml:space indicates that whitespace should be preserved.
  NoNamespaceName | An implementation of NodeName for the common case of a name in no namespace
  SelectedElementsSpaceStrippingRule | A whitespace stripping rule that strips elected elements unless xml:space indicates that whitespace should be preserved.
  SequenceTool | Utility class for manipulating sequences.
  SingletonSet<T> | A set with exactly one (non-null) member
  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).

- Exception Summary
  Exception | Description
  --- | ---
  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

Copyright (c) 2004-2013 Saxonica Limited. All rights reserved.