net.sf.saxon.tree.tiny

## Class TinyTree

- java.lang.Object
- - net.sf.saxon.tree.tiny.TinyTree

-     public final class TinyTree
      extends Object

  A data structure to hold the contents of a tree. As the name implies, this implementation of the data model is optimized for size, and for speed of creation: it minimizes the number of Java objects used.

  It can be used to represent a tree that is rooted at a document node, or one that is rooted at an element node.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected int[]` | `alpha`
    `protected int[]` | `attCode`
    `protected int[]` | `attParent`
    `protected int[]` | `attTypeCode`
    `protected AtomicSequence[]` | `attTypedValue`
    `protected CharSequence[]` | `attValue`
    `protected int[]` | `beta`
    `protected AppendableCharSequence` | `charBuffer`
    `protected FastStringBuffer` | `commentBuffer`
    `protected short[]` | `depth`
    `protected long` | `documentNumber`
    `protected int[]` | `nameCode`
    `protected NamespaceBinding[]` | `namespaceBinding`
    `protected int[]` | `namespaceParent`
    `protected int[]` | `next`
    `byte[]` | `nodeKind`
    `protected int` | `numberOfAttributes`
    `protected int` | `numberOfNamespaces`
    `protected int` | `numberOfNodes`
    `protected int[]` | `prior`
    `protected int` | `rootIndexUsed`
    `static int` | `TYPECODE_IDREF`
    `protected int[]` | `typeCodeArray`
    `protected AtomicSequence[]` | `typedValueArray`
    `protected boolean` | `usesNamespaces`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `TinyTree(Configuration config)` Create a TinyTree.
    `TinyTree(Configuration config, int nodes, int attributes, int namespaces, int characters)` Create a tree with a specified initial size

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `addTextNodeCopy(int depth, int existingNodeNr)` Create a new text node that is a copy of an existing text node
    `void` | `diagnosticDump()` Produce diagnostic print of main tree arrays
    `static void` | `diagnosticDump(NodeInfo node)` Create diagnostic dump of the tree containing a particular node.
    `int[]` | `getAlphaArray()` Get the array holding alpha information
    `int[]` | `getAttributeNameCodeArray()` Get the array used to hold the name codes of all attributes
    `int[]` | `getAttributeParentArray()` Get the array used to hold the parent pointers of all attributes
    `int[]` | `getAttributeTypeCodeArray()` Get the array used to hold the type codes of all attributes
    `CharSequence[]` | `getAttributeValueArray()` Get the array used to hold the name codes of all attributes
    `int[]` | `getBetaArray()` Get the array holding beta information
    `AppendableCharSequence` | `getCharacterBuffer()` Get the character buffer used to hold all the text data of the document
    `CharSequence` | `getCommentBuffer()` Get the character buffer used to hold all the comment data of the document
    `Configuration` | `getConfiguration()` Get the configuration previously set using setConfiguration
    `long` | `getDocumentNumber()` Get the document number (actually, the tree number)
    `int` | `getLineNumber(int sequence)` Get the line number for a node.
    `int` | `getNameCode(int nodeNr)` Get the nameCode for a given node, which must be a document, element, text, comment, or processing instruction node
    `int[]` | `getNameCodeArray()` Get the array holding node name information
    `NamePool` | `getNamePool()` Get the name pool used for the names in this document
    `NamespaceBinding[]` | `getNamespaceCodeArray()` Get the array used to hold the namespace codes of namespace declarations
    `int[]` | `getNamespaceParentArray()` Get the array used to hold the parent pointers of all namespace declarations
    `int[]` | `getNextPointerArray()` Get the array holding next-sibling pointers
    `TinyNodeImpl` | `getNode(int nr)` Get the node at a given position in the tree
    `short[]` | `getNodeDepthArray()` Get the array holding node depth information
    `int` | `getNodeKind(int nodeNr)` Get the node kind of a given node, which must be a document, element, text, comment, or processing instruction node
    `byte[]` | `getNodeKindArray()` Get the array holding node kind information
    `int` | `getNumberOfAttributes()` Get the number of attributes in the tree
    `int` | `getNumberOfNamespaces()` Get the number of namespace declarations in the tree
    `int` | `getNumberOfNodes()` Get the number of nodes in the tree, excluding attributes and namespace nodes
    `String` | `getSystemId(int seq)` Get the system id of an element in the document
    `int` | `getTypeAnnotation(int nodeNr)` Get the type annotation of a node.
    `int[]` | `getTypeCodeArray()` Get the array holding node type information
    `AtomicSequence` | `getTypedValueOfAttribute(net.sf.saxon.tree.tiny.TinyAttributeImpl att, int nodeNr)` Get the typed value of an attribute node.
    `AtomicSequence` | `getTypedValueOfElement(int nodeNr)` Get the type value of an element node, given only the node number
    `AtomicSequence` | `getTypedValueOfElement(TinyElementImpl element)` Get the typed value of an element node.
    `void` | `indexIDElement(NodeInfo root, int nodeNr, NameChecker checker)` Index an element of type xs:ID
    `boolean` | `isIdAttribute(int nr)` Determine whether an attribute is an IDREF/IDREFS attribute.
    `boolean` | `isIdElement(int nr)` Ask whether an element is an ID element.
    `boolean` | `isIdrefAttribute(int nr)` Determine whether an attribute is an IDREF/IDREFS attribute.
    `boolean` | `isIdrefElement(int nr)` Ask whether an element is an IDREF/IDREFS element.
    `boolean` | `isNilled(int nodeNr)` Ask whether a given node is nilled
    `void` | `setConfiguration(Configuration config)` Set the Configuration that contains this document
    `void` | `setLineNumbering()` Set line numbering on
    `void` | `showSize()` Output a statistical summary to System.err

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### documentNumber

          protected long documentNumber

    - #### charBuffer

          protected AppendableCharSequence charBuffer

    - #### commentBuffer

          protected FastStringBuffer commentBuffer

    - #### numberOfNodes

          protected int numberOfNodes

    - #### nodeKind

          public byte[] nodeKind

    - #### depth

          protected short[] depth

    - #### next

          protected int[] next

    - #### alpha

          protected int[] alpha

    - #### beta

          protected int[] beta

    - #### nameCode

          protected int[] nameCode

    - #### prior

          protected int[] prior

    - #### typeCodeArray

          protected int[] typeCodeArray

    - #### typedValueArray

          protected AtomicSequence[] typedValueArray

    - #### TYPECODE_IDREF

          public static final int TYPECODE_IDREF

      See Also:
        Constant Field Values

    - #### numberOfAttributes

          protected int numberOfAttributes

    - #### attParent

          protected int[] attParent

    - #### attCode

          protected int[] attCode

    - #### attValue

          protected CharSequence[] attValue

    - #### attTypedValue

          protected AtomicSequence[] attTypedValue

    - #### attTypeCode

          protected int[] attTypeCode

    - #### numberOfNamespaces

          protected int numberOfNamespaces

    - #### namespaceParent

          protected int[] namespaceParent

    - #### namespaceBinding

          protected NamespaceBinding[] namespaceBinding

    - #### rootIndexUsed

          protected int rootIndexUsed

    - #### usesNamespaces

          protected boolean usesNamespaces

  - ### Constructor Detail

    - #### TinyTree

          public TinyTree(Configuration config)

      Create a TinyTree. The initial size is based on the average size of trees previously built in this session
      Parameters:
        `config` - the Saxon Configuration

    - #### TinyTree

          public TinyTree(Configuration config,
                  int nodes,
                  int attributes,
                  int namespaces,
                  int characters)

      Create a tree with a specified initial size
      Parameters:
        `config` - the Saxon configuration
        `nodes` - the expected number of (non attribute or namespace) nodes
        `attributes` - the expected number of attributes
        `namespaces` - the expected number of namespace declarations
        `characters` - the expected number of characters in the document (in text nodes)

  - ### Method Detail

    - #### setConfiguration

          public void setConfiguration(Configuration config)

      Set the Configuration that contains this document
      Parameters:
        `config` - the Saxon configuration

    - #### getConfiguration

          public Configuration getConfiguration()

      Get the configuration previously set using setConfiguration
      Returns:
        the Saxon configuration

    - #### getNamePool

          public NamePool getNamePool()

      Get the name pool used for the names in this document
      Returns:
        the name pool

    - #### addTextNodeCopy

          public int addTextNodeCopy(int depth,
                            int existingNodeNr)

      Create a new text node that is a copy of an existing text node
      Parameters:
        `depth` - the depth of the new node
        `existingNodeNr` - the node to be copied
      Returns:
        the node number of the new node

    - #### getTypeAnnotation

          public int getTypeAnnotation(int nodeNr)

      Get the type annotation of a node. Applies only to document, element, text, processing instruction, and comment nodes.
      Parameters:
        `nodeNr` - the node whose type annotation is required
      Returns:
        the fingerprint of the type annotation for elements and attributes, otherwise undefined.

    - #### getTypedValueOfElement

          public AtomicSequence getTypedValueOfElement(TinyElementImpl element)
                                                throws XPathException

      Get the typed value of an element node.
      Parameters:
        `element` - the element node
      Returns:
        the typed value of the node (a Value whose items are AtomicValue instances)
      Throws:
        `XPathException` - if a dynamic error occurs, for example if the node is an element annotated with a type that has element-only content

    - #### getTypedValueOfElement

          public AtomicSequence getTypedValueOfElement(int nodeNr)
                                                throws XPathException

      Get the type value of an element node, given only the node number
      Parameters:
        `nodeNr` - the node number of the element node
      Returns:
        the typed value of the node
      Throws:
        `XPathException` - if the eement has no typed value

    - #### getTypedValueOfAttribute

          public AtomicSequence getTypedValueOfAttribute(net.sf.saxon.tree.tiny.TinyAttributeImpl att,
                                                int nodeNr)
                                                  throws XPathException

      Get the typed value of an attribute node. This method avoids materializing the attribute node if possible, but uses the attribute node supplied if it already exists.
      Parameters:
        `att` - the attribute node if available. If null is supplied, the attribute node will be materialized only if it is needed.
        `nodeNr` - the node number of the attribute node
      Returns:
        the typed value of the node
      Throws:
        `XPathException` - if an error is found

    - #### getNodeKind

          public int getNodeKind(int nodeNr)

      Get the node kind of a given node, which must be a document, element, text, comment, or processing instruction node
      Parameters:
        `nodeNr` - the node number
      Returns:
        the node kind

    - #### getNameCode

          public int getNameCode(int nodeNr)

      Get the nameCode for a given node, which must be a document, element, text, comment, or processing instruction node
      Parameters:
        `nodeNr` - the node number
      Returns:
        the name code

    - #### indexIDElement

          public void indexIDElement(NodeInfo root,
                            int nodeNr,
                            NameChecker checker)

      Index an element of type xs:ID
      Parameters:
        `root` - the root node of the document
        `nodeNr` - the element of type xs:ID
        `checker` - checks names against XML 1.0 or XML 1.1 rules

    - #### getNode

          public final TinyNodeImpl getNode(int nr)

      Get the node at a given position in the tree
      Parameters:
        `nr` - the node number
      Returns:
        the node at the given position

    - #### isIdAttribute

          public boolean isIdAttribute(int nr)

      Determine whether an attribute is an IDREF/IDREFS attribute. (The represents the is-idref property in the data model)
      Parameters:
        `nr` - the node number of the attribute
      Returns:
        true if this is an IDREF/IDREFS attribute

    - #### isIdrefAttribute

          public boolean isIdrefAttribute(int nr)

      Determine whether an attribute is an IDREF/IDREFS attribute. (The represents the is-idref property in the data model)
      Parameters:
        `nr` - the node number of the attribute
      Returns:
        true if this is an IDREF/IDREFS attribute

    - #### isIdElement

          public boolean isIdElement(int nr)

      Ask whether an element is an ID element. (The represents the is-id property in the data model)
      Parameters:
        `nr` - the element node whose is-idref property is required
      Returns:
        true if the node has the is-idref property

    - #### isIdrefElement

          public boolean isIdrefElement(int nr)

      Ask whether an element is an IDREF/IDREFS element. (The represents the is-idref property in the data model)
      Parameters:
        `nr` - the element node whose is-idref property is required
      Returns:
        true if the node has the is-idref property

    - #### getSystemId

          public String getSystemId(int seq)

      Get the system id of an element in the document
      Parameters:
        `seq` - the node number of the element node
      Returns:
        the system id (base URI) of the element

    - #### setLineNumbering

          public void setLineNumbering()

      Set line numbering on

    - #### getLineNumber

          public int getLineNumber(int sequence)

      Get the line number for a node.
      Parameters:
        `sequence` - the node number
      Returns:
        the line number of the node. Return -1 if line numbering is off.

    - #### getDocumentNumber

          public long getDocumentNumber()

      Get the document number (actually, the tree number)
      Returns:
        the unique number of this TinyTree structure

    - #### isNilled

          public boolean isNilled(int nodeNr)

      Ask whether a given node is nilled
      Parameters:
        `nodeNr` - the node in question (which must be an element node)
      Returns:
        true if the node has the nilled property

    - #### diagnosticDump

          public void diagnosticDump()

      Produce diagnostic print of main tree arrays

    - #### diagnosticDump

          public static void diagnosticDump(NodeInfo node)

      Create diagnostic dump of the tree containing a particular node. Designed to be called as an extension function for diagnostics.
      Parameters:
        `node` - the node in question

    - #### showSize

          public void showSize()

      Output a statistical summary to System.err

    - #### getNumberOfNodes

          public int getNumberOfNodes()

      Get the number of nodes in the tree, excluding attributes and namespace nodes
      Returns:
        the number of nodes.

    - #### getNumberOfAttributes

          public int getNumberOfAttributes()

      Get the number of attributes in the tree
      Returns:
        the number of attributes

    - #### getNumberOfNamespaces

          public int getNumberOfNamespaces()

      Get the number of namespace declarations in the tree
      Returns:
        the number of namespace declarations

    - #### getNodeKindArray

          public byte[] getNodeKindArray()

      Get the array holding node kind information
      Returns:
        an array of bytes, byte N is the node kind of node number N

    - #### getNodeDepthArray

          public short[] getNodeDepthArray()

      Get the array holding node depth information
      Returns:
        an array of shorts, byte N is the node depth of node number N

    - #### getNameCodeArray

          public int[] getNameCodeArray()

      Get the array holding node name information
      Returns:
        an array of integers, integer N is the name code of node number N

    - #### getTypeCodeArray

          public int[] getTypeCodeArray()

      Get the array holding node type information
      Returns:
        an array of integers, integer N is the type code of node number N

    - #### getNextPointerArray

          public int[] getNextPointerArray()

      Get the array holding next-sibling pointers
      Returns:
        an array of integers, integer N is the next-sibling pointer for node number N

    - #### getAlphaArray

          public int[] getAlphaArray()

      Get the array holding alpha information
      Returns:
        an array of integers, whose meaning depends on the node kind. For elements it is a pointer to the first attribute, for text, comment, and processing instruction nodes it is a pointer to the content

    - #### getBetaArray

          public int[] getBetaArray()

      Get the array holding beta information
      Returns:
        an array of integers, whose meaning depends on the node kind. For elements it is a pointer to the first namespace declaration

    - #### getCharacterBuffer

          public AppendableCharSequence getCharacterBuffer()

      Get the character buffer used to hold all the text data of the document
      Returns:
        the character buffer

    - #### getCommentBuffer

          public CharSequence getCommentBuffer()

      Get the character buffer used to hold all the comment data of the document
      Returns:
        the character buffer used for comments

    - #### getAttributeNameCodeArray

          public int[] getAttributeNameCodeArray()

      Get the array used to hold the name codes of all attributes
      Returns:
        an integer array; the Nth integer holds the attribute name code of attribute N

    - #### getAttributeTypeCodeArray

          public int[] getAttributeTypeCodeArray()

      Get the array used to hold the type codes of all attributes
      Returns:
        an integer array; the Nth integer holds the attribute type code of attribute N

    - #### getAttributeParentArray

          public int[] getAttributeParentArray()

      Get the array used to hold the parent pointers of all attributes
      Returns:
        an integer array; the Nth integer holds the pointer to the parent element of attribute N

    - #### getAttributeValueArray

          public CharSequence[] getAttributeValueArray()

      Get the array used to hold the name codes of all attributes
      Returns:
        an array of strings; the Nth string holds the string value of attribute N

    - #### getNamespaceCodeArray

          public NamespaceBinding[] getNamespaceCodeArray()

      Get the array used to hold the namespace codes of namespace declarations
      Returns:
        an array of integer namespace codes

    - #### getNamespaceParentArray

          public int[] getNamespaceParentArray()

      Get the array used to hold the parent pointers of all namespace declarations
      Returns:
        an integer array; the Nth integer holds the pointer to the parent element of namespace N

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