Java Doc for NodeInfo.java in  » XML » saxonb » net » sf » saxon » om » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Note that several NodeInfo objects may represent the same node. To test node identity, the method NodeInfo.isSameNodeInfo(NodeInfo) should be used. An exception to this rule applies for document nodes, where the correspondence between document nodes and DocumentInfo objects is one to one. NodeInfo objects are never reused: a given NodeInfo object represents the same node for its entire lifetime.

This is the primary interface for accessing trees in Saxon, and it forms part of the public Saxon API. The only subclass of NodeInfo that applications should normally use is DocumentInfo , which represents a document node. Methods that form part of the public API are (since Saxon 8.4) labelled with a JavaDoc "since" tag: classes and methods that have no such label should not be regarded as stable interfaces.

The interface represented by this class is at a slightly higher level than the abstraction described in the W3C data model specification, in that it includes support for the XPath axes, rather than exposing the lower-level properties (such as "parent" and "children") directly. All navigation within trees, except for a few convenience methods, is done by following the axes using the NodeInfo.iterateAxis method. This allows different implementations of the XPath tree model to implement axis navigation in different ways. Some implementations may choose to use the helper methods provided in class Navigator .

Note that the stability of this interface applies to classes that use the interface, not to classes that implement it. The interface may be extended in future to add new methods.
author:
   Michael H. Kay
since:
   8.4

The other node must always be in the same tree; the effect of calling this method when the two nodes are in different trees is undefined.

This method is primarily for internal use.

This method is intended primarily for internal use.

Note that two different NodeInfo instances can represent the same conceptual node. Therefore the "==" operator should not be used to test node identity.

The other node must always be in the same tree; the effect of calling this method when the two nodes are in different trees is undefined. To obtain a global ordering of nodes, the application should first compare the result of getDocumentNumber(), and only if the document number is the same should compareOrder() be called.
Parameters:
  other - The other node, whose position is to be compared with thisnode -1 if this node precedes the other node, +1 if it follows theother node, or 0 if they are the same node. (In this case,isSameNode() will always return true, and the two nodes willproduce the same result for generateId())
since:
   8.4

This method is primarily for internal use. It should not be considered a stable part of the Saxon API.
exception:
  XPathException -
Parameters:
  out - the Receiver to which the node should be copied
Parameters:
  whichNamespaces - in the case of an element, controlswhich namespace nodes should be copied. Values are NodeInfo.NO_NAMESPACES,NodeInfo.LOCAL_NAMESPACES, NodeInfo.ALL_NAMESPACES
Parameters:
  copyAnnotations - indicates whether the type annotationsof element and attribute nodes should be copied
Parameters:
  locationId - If non-zero, identifies the location of the instructionthat requested this copy. If zero, indicates that the location informationfor the original node is to be copied; in this case the Receiver must bea LocationCopier

This method is intended primarily for internal use. User applications needing information about the namespace context of a node should use iterateAxis(Axis.NAMESPACE).
Parameters:
  buffer - If this is non-null, and the result array fits in this buffer, then the resultmay overwrite the contents of this array, to avoid the cost of allocating a new array on the heap. An array of integers representing the namespace declarations and undeclarations present onthis element. For a node other than an element, return null. Otherwise, the returned array is asequence of namespace codes, whose meaning may be interpreted by reference to the name pool. Thetop half word of each namespace code represents the prefix, the bottom half represents the URI.If the bottom half is zero, then this is a namespace undeclaration rather than a declaration.The XML namespace is never included in the list. If the supplied array is larger than required,then the first unused entry will be set to -1.

For a node other than an element, the method returns null.

The granularity of line numbering is normally the element level: for other nodes such as text nodes and attributes, the line number of the parent element will normally be returned.

In the case of a tree constructed by taking input from a SAX parser, the line number will reflect the SAX rules: that is, the line number of an element is the line number where the start tag ends. This may be a little confusing where elements have many attributes spread over multiple lines, or where single attributes (as can easily happen with XSLT 2.0 stylesheets) occupy several lines.

In the case of a tree constructed by a stylesheet or query, the line number may reflect the line in the stylesheet or query that caused the node to be constructed.

The line number can be read from within an XPath expression using the Saxon extension function saxon:line-number() the line number of the node in its original source document; or-1 if not available
since:
   8.4

The interpretation of this depends on the type of node. For an element it is the accumulated character content of the element, including descendant elements.

This method returns the string value as if the node were untyped. Unlike the string value accessor in the XPath 2.0 data model, it does not report an error if the element has a complex type, instead it returns the concatenation of the descendant text nodes as it would if the element were untyped. the string value of the node
since:
   8.4

The bit IS_DTD_TYPE (1<<30) will be set in the case of an attribute node if the type annotation is one of ID, IDREF, or IDREFS and this is derived from DTD rather than schema validation. the type annotation of the node, under the mask NamePool.FP_MASK, and optionally thebit setting IS_DTD_TYPE in the case of a DTD-derived ID or IDREF/S type (which is treatedas untypedAtomic for the purposes of obtaining the typed value).Returns -1 for kinds of nodes that have no annotation, and for elements annotated asuntyped, and attributes annotated as untypedAtomic.
since:
   8.4

Note: the result is equivalent to
iterateAxis(Axis.CHILD).next() != null True if the node has one or more children
since:
   8.4

Note that two different NodeInfo instances can represent the same conceptual node. Therefore the "==" operator should not be used to test node identity. The equals() method is not overridden for nodes, so it has the same effect as using "==".

Note: a.isSameNodeInfo(b) if and only if generateId(a)==generateId(b).

This method has the same semantics as isSameNode() in DOM Level 3, but works on Saxon NodeInfo objects rather than DOM Node objects.
Parameters:
  other - the node to be compared with this node true if this NodeInfo object and the supplied NodeInfo object representthe same node in the tree.

This method is primarily for internal use. It should not be considered a stable part of the Saxon API.
Parameters:
  out - The relevant Receiver
Parameters:
  includeAncestors - True if namespaces declared on ancestorelements must be output; false if it is known that these are