TreeList

java.lang.Object
- gnu.lists.AbstractSequence<java.lang.Object>
- - gnu.lists.TreeList

All Implemented Interfaces:

Consumable, PositionConsumer, XConsumer, java.lang.Appendable, java.util.function.Consumer<java.lang.Object>, java.util.function.DoubleConsumer, java.util.function.IntConsumer, java.util.function.LongConsumer

Direct Known Subclasses:

NodeTree
```
public class TreeList
extends AbstractSequence<java.lang.Object>
implements java.lang.Appendable, XConsumer, PositionConsumer, Consumable
```
A compact representation of a tree, that is a nested list structure. The data structure can store anything that can be emitted to a Consumer. This data structure is optimized for efficient forwards traversal through the data structure, not random access. It does have an "insertion point"; insertions and deletions are efficient through the use of a buffer gap. It is a reasonable choice for a "DOM" for XML data.

Field Summary

Fields
Modifier and Type	Field and Description
`int`	`attrStart` If non-zero, gap is in an attribute starting (1 less than) here.
`protected static int`	`BEGIN_ATTRIBUTE_LONG` The beginning of an attribute.
`static int`	`BEGIN_ATTRIBUTE_LONG_SIZE`
`protected static int`	`BEGIN_DOCUMENT` Beginning of a document (or top-level value).
`protected static int`	`BEGIN_ELEMENT_LONG` Begin of an element, non-compact form.
`protected static int`	`BEGIN_ELEMENT_SHORT` Beginning of an element, compact form.
`protected static int`	`BEGIN_ELEMENT_SHORT_INDEX_MAX`
`static int`	`BEGIN_ENTITY` Start of an entity (typically a file, possibly included).
`static int`	`BEGIN_ENTITY_SIZE`
`char[]`	`data`
`int`	`docStart` If non-zero, gap is in an document starting (1 less than) here.
`protected static int`	`DOCUMENT_URI` The document-uri property of a node.
`static int`	`END_ATTRIBUTE_SIZE`
`protected static int`	`END_DOCUMENT` End of a document.
`protected static int`	`END_ELEMENT_LONG` End of n element, non-compact form.
`protected static int`	`END_ELEMENT_SHORT` End of an element, compact form.
`protected static int`	`END_ENTITY`
`int`	`gapEnd`
`int`	`gapStart`
`static int`	`INT_FOLLOWS` A 32-bit integer, non-compact form.
`static int`	`MAX_CHAR_SHORT` The largest Unicode character that can be encoded in one char.
`java.lang.Object[]`	`objects`
`int`	`oindex`
`protected static char`	`POSITION_PAIR_FOLLOWS` A position triple referencing some other "nodes".
`protected static int`	`PROCESSING_INSTRUCTION` A processing-instruction node follows.

Fields inherited from class gnu.lists.AbstractSequence
noInts

Constructor Summary

Constructors
Constructor and Description
`TreeList()`
`TreeList(TreeList list)`
`TreeList(TreeList list, int startPosition, int endPosition)` Make a copy of a sub-range of a TreeList.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Consumer`	`append(char c)`
`Consumer`	`append(java.lang.CharSequence csq)`
`Consumer`	`append(java.lang.CharSequence csq, int start, int end)`
`void`	`beginEntity(java.lang.Object base)`
`void`	`clear()`
`int`	`compare(int ipos1, int ipos2)` Compare two positions, and indicate their relative order.
`void`	`consume(Consumer out)`
`int`	`consumeIRange(int startPosition, int endPosition, Consumer out)`
`boolean`	`consumeNext(int ipos, Consumer out)` Copy an element specified by a position pair to a Consumer.
`void`	`consumePosRange(int startPos, int endPos, Consumer out)`
`int`	`createPos(int index, boolean isAfter)` Generate a position at a given index.
`int`	`createRelativePos(int istart, int offset, boolean isAfter)`
`java.lang.Object`	`documentUriOfPos(int pos)`
`void`	`dump()`
`void`	`dump(java.io.PrintWriter out)`
`void`	`dump(java.io.PrintWriter out, int start, int limit)`
`void`	`endAttribute()` End of an attribute or end of an actual parameter.
`void`	`endDocument()`
`void`	`endElement()`
`void`	`endEntity()`
`void`	`ensureSpace(int needed)`
`int`	`find(java.lang.Object arg1)`
`int`	`firstAttributePos(int ipos)` Like firstChildPos.
`int`	`firstChildPos(int ipos)` Get position before first child (of the element following position).
`java.lang.Object`	`get(int index)`
`int`	`getAttributeCount(int parent)`
`protected int`	`getIndexDifference(int ipos1, int ipos0)` Get offset of (ipos1) relative to (ipos0).
`protected int`	`getIntN(int index)` Get a 32-bit int from the data array.
`protected long`	`getLongN(int index)` Get a 64-bit long from the data array.
`int`	`getNextKind(int ipos)`
`int`	`getNextKindI(int index)`
`java.lang.Object`	`getNextTypeObject(int ipos)`
`java.lang.Object`	`getPosNext(int ipos)` Get the element following the specified position.
`int`	`getPosNextInt(int ipos)` Return following value (like getPosNext), as an integer.
`java.lang.Object`	`getPosPrevious(int ipos)` Get the element before the specified position.
`int`	`gotoAttributesStart(int index)`
`boolean`	`gotoAttributesStart(TreePosition pos)`
`int`	`gotoChildrenStart(int index)`
`int`	`hashCode()`
`boolean`	`hasNext(int ipos)`
`boolean`	`ignoring()` True if consumer is ignoring rest of element.
`boolean`	`isEmpty()`
`int`	`nextDataIndex(int pos)`
`int`	`nextIndex(int ipos)` Get the offset from the beginning corresponding to a position cookie.
`int`	`nextMatching(int startPos, ItemPredicate predicate, int endPos, boolean descend)` Get next matching child or descendent (ignoring attributes).
`int`	`nextNodeIndex(int pos, int limit)` Skip all primitive content nodes.
`int`	`nextPos(int position)` Return the next position following the argument.
`int`	`parentOrEntityI(int index)`
`int`	`parentOrEntityPos(int ipos)`
`int`	`parentPos(int ipos)` Get position of parent.
`int`	`posToDataIndex(int ipos)`
`void`	`reserveObjects(int needed)`
`void`	`setAttributeName(int attrIndex, int nameIndex)`
`void`	`setElementName(int elementIndex, int nameIndex)`
`void`	`setIntN(int index, int i)`
`int`	`size()`
`void`	`startAttribute(int index)`
`void`	`startAttribute(java.lang.Object attrType)` Write a attribute for the current element.
`void`	`startDocument()`
`void`	`startElement(int index)`
`void`	`startElement(java.lang.Object type)`
`void`	`statistics()`
`void`	`statistics(java.io.PrintWriter out)`
`int`	`stringValue(boolean inElement, int index, java.lang.StringBuffer sbuf)`
`void`	`stringValue(int startIndex, int endIndex, java.lang.StringBuffer sbuf)`
`int`	`stringValue(int index, java.lang.StringBuffer sbuf)`
`void`	`toString(java.lang.String sep, java.lang.StringBuffer sbuf)`
`void`	`write(char[] buf, int off, int len)`
`void`	`write(java.lang.CharSequence str, int start, int length)`
`void`	`write(int c)`
`void`	`write(java.lang.String str)`
`void`	`writeBoolean(boolean v)`
`void`	`writeByte(int v)`
`void`	`writeCDATA(char[] chars, int offset, int length)`
`void`	`writeComment(char[] chars, int offset, int length)`
`void`	`writeComment(java.lang.String comment, int offset, int length)`
`void`	`writeDocumentUri(java.lang.Object uri)` Write/set the document-uri property of the current document.
`void`	`writeDouble(double v)`
`void`	`writeFloat(float v)`
`void`	`writeInt(int v)`
`void`	`writeIntForce32(int v)`
`void`	`writeJoiner()`
`void`	`writeLong(long v)`
`void`	`writeObject(java.lang.Object v)`
`void`	`writePosition(AbstractSequence seq, int ipos)` Consume a single position pair.
`void`	`writePosition(SeqPosition position)` Consume node at current position.
`void`	`writeProcessingInstruction(java.lang.String target, char[] content, int offset, int length)`
`void`	`writeProcessingInstruction(java.lang.String target, java.lang.String content, int offset, int length)`

Methods inherited from class gnu.lists.AbstractSequence
add, add, addAll, addAll, addPos, asImmutable, badRank, boundedHash, checkCanWrite, checkRank, compare, compare, consume, contains, containsAll, copyPos, effectiveIndex, effectiveIndex, effectiveIndex, effectiveIndex, effectiveIndex, elements, endPos, equals, equals, fill, fill, fillPosRange, firstChildPos, fromEndIndex, get, get, get, get, getAttribute, getAttributeLength, getBooleanRaw, getByteRaw, getCharRaw, getContainingSequenceSize, getDoubleRaw, getElementKind, getFloatRaw, getInt, getInt, getInt, getInt, getInt, getIntRaw, getIterator, getIterator, getIteratorAtPos, getLongRaw, getLowBound, getNextTypeName, getRaw, getRowMajor, getShortRaw, getSize, getSize, gotoChildrenStart, gotoParent, hasPrevious, indexOf, isAfterPos, iterator, lastIndexOf, listIterator, listIterator, nextIndex, previousPos, rank, releasePos, remove, remove, removeAll, removePos, removePosRange, retainAll, set, set, setAt, setBuffer, setPosNext, setPosPrevious, setRaw, stableCompare, startPos, subList, subSequence, subSequencePos, toArray, toArray, toString, unsupported, unsupportedException

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface gnu.lists.Consumer
accept, accept, accept, accept

Methods inherited from interface java.util.function.Consumer
andThen

Methods inherited from interface java.util.function.IntConsumer
andThen

Methods inherited from interface java.util.function.LongConsumer
andThen

Methods inherited from interface java.util.function.DoubleConsumer
andThen

- Field Detail
  - objects
```
public java.lang.Object[] objects
```
  - oindex
```
public int oindex
```
  - data
```
public char[] data
```
  - gapStart
```
public int gapStart
```
  - gapEnd
```
public int gapEnd
```
  - attrStart
```
public int attrStart
```
    If non-zero, gap is in an attribute starting (1 less than) here.
  - docStart
```
public int docStart
```
    If non-zero, gap is in an document starting (1 less than) here.
  - MAX_CHAR_SHORT
```
public static final int MAX_CHAR_SHORT
```
    The largest Unicode character that can be encoded in one char.
    
    See Also:
    
    Constant Field Values
  - POSITION_PAIR_FOLLOWS
```
protected static final char POSITION_PAIR_FOLLOWS
```
    A position triple referencing some other "nodes". Followed by index of sequence (2 chars), and ipos (2 chars).
    
    See Also:
    
    Constant Field Values
  - INT_FOLLOWS
```
public static final int INT_FOLLOWS
```
    A 32-bit integer, non-compact form. [INT_FOLLOWS] [word1], [word2]: The big-endian bits of the integer.
    
    See Also:
    
    Constant Field Values
  - PROCESSING_INSTRUCTION
```
protected static final int PROCESSING_INSTRUCTION
```
    A processing-instruction node follows. [PROCESSING_INSTRUCTION] [target] 2 shorts, where objects[target] is the target as a String. [length] 2 shorts. [comment text], (length) number of characters.
    
    See Also:
    
    Constant Field Values
  - BEGIN_ATTRIBUTE_LONG
```
protected static final int BEGIN_ATTRIBUTE_LONG
```
    The beginning of an attribute. [BEGIN_ATTRIBUTE_LONG] [index], 2 shorts, where objects[index] is the attribute type name and objects[index+1] is the attribute type object. [end_offset], 2 shorts, giving the location of the following END_ATTRIBUTE. If the attribute straddles the gap, then end_offset is a negative offset relative to data.length. (Therefore allocating more space for the gap does not require adjusting end_offset.) Otherwise, the end_offset is relative to the BEGIN_ATTRIBUTE_LONG word.
    
    See Also:
    
    Constant Field Values
  - BEGIN_ATTRIBUTE_LONG_SIZE
```
public static final int BEGIN_ATTRIBUTE_LONG_SIZE
```
    See Also:
    
    Constant Field Values
  - END_ATTRIBUTE_SIZE
```
public static final int END_ATTRIBUTE_SIZE
```
    See Also:
    
    Constant Field Values
  - BEGIN_DOCUMENT
```
protected static final int BEGIN_DOCUMENT
```
    Beginning of a document (or top-level value). Used to distinguish a document from its element node. [end_offset], 2 shorts, giving the location of the following END_DOCUMENT. If the attribute straddles the gap, then end_offset is a negative offset relative to data.length. (Therefore allocating more space for the gap does not require adjusting end_offset.) Otherwise, the end_offset is relative to the BEGIN_DOCUMENT word. [parent_offset], in 2 shorts. The parent node, or -1 if no parent. Otherwise, a negative value is a relative offset, while a non-negative value is absolute. (Use the latter when gap is between this node and its parent. The parent would normally be a BEGIN_ENTITY.
    
    See Also:
    
    Constant Field Values
  - END_DOCUMENT
```
protected static final int END_DOCUMENT
```
    End of a document.
    
    See Also:
    
    Constant Field Values
  - BEGIN_ENTITY
```
public static final int BEGIN_ENTITY
```
    Start of an entity (typically a file, possibly included). [base_uri], 2 shorts, given an index of a base-uri object [parent_offset], in 2 shorts, encoded as for BEGIN_DOCUMENT.
    
    See Also:
    
    Constant Field Values
  - BEGIN_ENTITY_SIZE
```
public static final int BEGIN_ENTITY_SIZE
```
    See Also:
    
    Constant Field Values
  - END_ENTITY
```
protected static final int END_ENTITY
```
    See Also:
    
    Constant Field Values
  - DOCUMENT_URI
```
protected static final int DOCUMENT_URI
```
    The document-uri property of a node. This is not an actual value, but it is a property of the previous document node, or the surrounding node just after a BEGIN_XXX entry. [DOCUMENT_URI] [index]. 2 shorts, where objects[index] is the document-uri value.
    
    See Also:
    
    Constant Field Values
  - BEGIN_ELEMENT_SHORT
```
protected static final int BEGIN_ELEMENT_SHORT
```
    Beginning of an element, compact form. [BEGIN_ELEMENT_SHORT + index], where objects[index] is the element's type name and objects[index+1] is the type object. [end_offset], the unsigned offset (from the initial word) to the corresponding END_ELEMENT_SHORT. [parent_offset], the (unsigned absolute value of the) offset to the outer BEGIN_ELEMENT_SHORT/BEGIN_ELEMENT_LONG/BEGIN_DOCUMENT. . (If these is no parent, then parent_offset==0.) This should is used when index < BEGIN_ELEMENT_SHORT_INDEX_MAX, both end_offset and parent_offset fit in 16 bits, and the element does not straddle the gap.
    
    See Also:
    
    Constant Field Values
  - BEGIN_ELEMENT_SHORT_INDEX_MAX
```
protected static final int BEGIN_ELEMENT_SHORT_INDEX_MAX
```
    See Also:
    
    Constant Field Values
  - END_ELEMENT_SHORT
```
protected static final int END_ELEMENT_SHORT
```
    End of an element, compact form. [END_ELEMENT_SHORT] [begin_offset], the unsigned absolute value of the offset to the matching BEGIN. (This is the same as the matching end_offset.)
    
    See Also:
    
    Constant Field Values
  - BEGIN_ELEMENT_LONG
```
protected static final int BEGIN_ELEMENT_LONG
```
    Begin of an element, non-compact form. [BEGIN_ELEMENT_LONG] [end_offset], in 2 shorts. The position of the matching END_ELEMENT_LONG. If the element straddles the gap, then end_offset is a negative offset relative to data.length. (Therefore allocating more space for the gap does not require adjusting any end_offset.) If the element and and its children are all on the same side of the gap, then end_offset is a positive offset relative to the BEGIN_ELEMENT_LONG word. (Hence shifting an entire element when the gap is moved does not require changing its end_offset.) Note that the space taken by a BEGIN_ELEMENT_LONG is the same that needed for a BEGIN_ELEMENT_SHORT (but a END_ELEMENT_LONG takes much more space than a END_ELEMENT_SHORT). This is to make it easier to convert a BEGIN_ELEMENT_LONG to a BEGIN_ELEMENT_SHORT or vice versa, as needed.
    
    See Also:
    
    Constant Field Values
  - END_ELEMENT_LONG
```
protected static final int END_ELEMENT_LONG
```
    End of n element, non-compact form. [END_ELEMENT_LONG] [index], 2 shorts where objects[index] is the element's type name and objects[index+1] is the type object. [begin_offset], in 2 shorts. The position of the matching BEGIN_ELEMENT_LONG. If the element straddles the gap, then begin_offset is the actual index (i.e. relative to the start of data) of the matching BEGIN_ELEMENT_LONG. (Therefore allocating more space for the gap does not require adjusting begin_offset.) If the element does not straddle the gap, then begin_offset is a negative offset relative to the END_ELEMENT_LONG word. (Hence shifting an entire element when the gap is moved does not require changing its begin_offset.) relative to data.length. [parent_offset], in 2 shorts. The position of the outer BEGIN_ELEMENT_LONG, BEGIN_ELEMENT_SHORT or BEGIN_DOCUMENT. If the difference straddles the gap (i.e. either this element straddles the gap or the parent element does and the gap precedes this element), then parent_offset is the actual index of the parent element. Otherwise, then parent_offset is a negative offset relative to the END_ELEMENT_LONG word.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - TreeList
```
public TreeList()
```
  - TreeList
```
public TreeList(TreeList list,
                int startPosition,
                int endPosition)
```
    Make a copy of a sub-range of a TreeList.
    
    Parameters:
    
    list - the TreeList to copy
    
    startPosition - start of range, as a raw index in data
    
    endPosition - end of range, as a raw index in data
  - TreeList
```
public TreeList(TreeList list)
```
- Method Detail
  - clear
```
public void clear()
```
    Overrides:
    
    clear in class AbstractSequence<java.lang.Object>
  - ensureSpace
```
public void ensureSpace(int needed)
```
  - reserveObjects
```
public final void reserveObjects(int needed)
```
  - find
```
public int find(java.lang.Object arg1)
```
  - getIntN
```
protected final int getIntN(int index)
```
    Get a 32-bit int from the data array.
  - getLongN
```
protected final long getLongN(int index)
```
    Get a 64-bit long from the data array.
  - setIntN
```
public final void setIntN(int index,
                          int i)
```
  - writePosition
```
public void writePosition(SeqPosition position)
```
    Description copied from interface: PositionConsumer
    
    Consume node at current position. The caller may invalidate or change the position after consume returns, so if the consumer wants to save it, it needs to copy it.
    
    Specified by:
    
    writePosition in interface PositionConsumer
  - writePosition
```
public void writePosition(AbstractSequence seq,
                          int ipos)
```
    Description copied from interface: PositionConsumer
    
    Consume a single position pair. This PositionConsumer may assume the sequence does no reference management; i.e. that copyPos is trivial and releasePos is a no-op. If that is not the case, use consume(TreePosition) instead.
    
    Specified by:
    
    writePosition in interface PositionConsumer
  - writeObject
```
public void writeObject(java.lang.Object v)
```
  - writeDocumentUri
```
public void writeDocumentUri(java.lang.Object uri)
```
    Write/set the document-uri property of the current document. Only allowed immediately following startDocument.
  - writeComment
```
public void writeComment(char[] chars,
                         int offset,
                         int length)
```
    Specified by:
    
    writeComment in interface XConsumer
  - writeComment
```
public void writeComment(java.lang.String comment,
                         int offset,
                         int length)
```
  - writeProcessingInstruction
```
public void writeProcessingInstruction(java.lang.String target,
                                       char[] content,
                                       int offset,
                                       int length)
```
    Specified by:
    
    writeProcessingInstruction in interface XConsumer
  - writeProcessingInstruction
```
public void writeProcessingInstruction(java.lang.String target,
                                       java.lang.String content,
                                       int offset,
                                       int length)
```
  - startElement
```
public void startElement(java.lang.Object type)
```
  - startDocument
```
public void startDocument()
```
  - endDocument
```
public void endDocument()
```
  - beginEntity
```
public void beginEntity(java.lang.Object base)
```
    Specified by:
    
    beginEntity in interface XConsumer
  - endEntity
```
public void endEntity()
```
    Specified by:
    
    endEntity in interface XConsumer
  - startElement
```
public void startElement(int index)
```
  - setElementName
```
public void setElementName(int elementIndex,
                           int nameIndex)
```
  - endElement
```
public void endElement()
```
  - startAttribute
```
public void startAttribute(java.lang.Object attrType)
```
    Description copied from interface: Consumer
    
    Write a attribute for the current element. This is only allowed immediately after a startElement.
  - startAttribute
```
public void startAttribute(int index)
```
  - setAttributeName
```
public void setAttributeName(int attrIndex,
                             int nameIndex)
```
  - endAttribute
```
public void endAttribute()
```
    Description copied from interface: Consumer
    
    End of an attribute or end of an actual parameter. The former use matches a startAttribute; the latter may not, and can be used to separate parameters in a parameter list. This double duty suggsts the method should at least be re-named.
  - append
```
public Consumer append(char c)
```
    Specified by:
    
    append in interface java.lang.Appendable
  - write
```
public void write(int c)
```
  - writeBoolean
```
public void writeBoolean(boolean v)
```
  - writeByte
```
public void writeByte(int v)
```
  - writeInt
```
public void writeInt(int v)
```
  - writeIntForce32
```
public void writeIntForce32(int v)
```
  - writeLong
```
public void writeLong(long v)
```
  - writeFloat
```
public void writeFloat(float v)
```
  - writeDouble
```
public void writeDouble(double v)
```
  - ignoring
```
public boolean ignoring()
```
    Description copied from interface: Consumer
    
    True if consumer is ignoring rest of element. The producer can use this information to skip ahead.
  - writeJoiner
```
public void writeJoiner()
```
  - write
```
public void write(char[] buf,
                  int off,
                  int len)
```
  - write
```
public void write(java.lang.String str)
```
  - write
```
public void write(java.lang.CharSequence str,
                  int start,
                  int length)
```
  - writeCDATA
```
public void writeCDATA(char[] chars,
                       int offset,
                       int length)
```
    Specified by:
    
    writeCDATA in interface XConsumer
  - append
```
public Consumer append(java.lang.CharSequence csq)
```
    Specified by:
    
    append in interface java.lang.Appendable
  - append
```
public Consumer append(java.lang.CharSequence csq,
                       int start,
                       int end)
```
    Specified by:
    
    append in interface java.lang.Appendable
  - isEmpty
```
public boolean isEmpty()
```
    Overrides:
    
    isEmpty in class AbstractSequence<java.lang.Object>
  - size
```
public int size()
```
    Overrides:
    
    size in class AbstractSequence<java.lang.Object>
  - createPos
```
public int createPos(int index,
                     boolean isAfter)
```
    Description copied from class: AbstractSequence
    
    Generate a position at a given index. The result is a position cookie that must be free'd with releasePos.
    
    Overrides:
    
    createPos in class AbstractSequence<java.lang.Object>
    
    Parameters:
    
    index - offset from beginning of desired position
    
    isAfter - should the position have the isAfter property
  - posToDataIndex
```
public final int posToDataIndex(int ipos)
```
  - firstChildPos
```
public int firstChildPos(int ipos)
```
    Description copied from class: AbstractSequence
    
    Get position before first child (of the element following position).
    
    Overrides:
    
    firstChildPos in class AbstractSequence<java.lang.Object>
    
    Parameters:
    
    ipos - parent position. It is not released by this method.
    
    Returns:
    
    non-zero position cookie if there is a child sequence (which might be empty); zero if current position is end of sequence or following element is atomic (cannot have children).
  - gotoChildrenStart
```
public final int gotoChildrenStart(int index)
```
  - parentPos
```
public int parentPos(int ipos)
```
    Description copied from class: AbstractSequence
    
    Get position of parent.
    
    Overrides:
    
    parentPos in class AbstractSequence<java.lang.Object>
    
    Parameters:
    
    ipos - child position. It is not released by this method.
    
    Returns:
    
    the p os of the parent, or endPos() is there is no known parent.
  - parentOrEntityPos
```
public int parentOrEntityPos(int ipos)
```
  - parentOrEntityI
```
public int parentOrEntityI(int index)
```
  - getAttributeCount
```
public int getAttributeCount(int parent)
```
  - gotoAttributesStart
```
public boolean gotoAttributesStart(TreePosition pos)
```
    Overrides:
    
    gotoAttributesStart in class AbstractSequence<java.lang.Object>
  - firstAttributePos
```
public int firstAttributePos(int ipos)
```
    Description copied from class: AbstractSequence
    
    Like firstChildPos. Problem: Should this stop before we get to children? I think so, but that requires changes to TreeList.
    
    Overrides:
    
    firstAttributePos in class AbstractSequence<java.lang.Object>
  - gotoAttributesStart
```
public int gotoAttributesStart(int index)
```
  - get
```
public java.lang.Object get(int index)
```
    Overrides:
    
    get in class AbstractSequence<java.lang.Object>
  - consumeNext
```
public boolean consumeNext(int ipos,
                           Consumer out)
```
    Description copied from class: AbstractSequence
    
    Copy an element specified by a position pair to a Consumer.
    
    Overrides:
    
    consumeNext in class AbstractSequence<java.lang.Object>
    
    Returns:
    
    if hasNext(ipos).
  - consumePosRange
```
public void consumePosRange(int startPos,
                            int endPos,
                            Consumer out)
```
    Overrides:
    
    consumePosRange in class AbstractSequence<java.lang.Object>
  - consumeIRange
```
public int consumeIRange(int startPosition,
                         int endPosition,
                         Consumer out)
```
  - toString
```
public void toString(java.lang.String sep,
                     java.lang.StringBuffer sbuf)
```
    Overrides:
    
    toString in class AbstractSequence<java.lang.Object>
  - hasNext
```
public boolean hasNext(int ipos)
```
    Overrides:
    
    hasNext in class AbstractSequence<java.lang.Object>
  - getNextKind
```
public int getNextKind(int ipos)
```
    Overrides:
    
    getNextKind in class AbstractSequence<java.lang.Object>
  - getNextKindI
```
public int getNextKindI(int index)
```
  - getNextTypeObject
```
public java.lang.Object getNextTypeObject(int ipos)
```
    Overrides:
    
    getNextTypeObject in class AbstractSequence<java.lang.Object>
  - getPosPrevious
```
public java.lang.Object getPosPrevious(int ipos)
```
    Description copied from class: AbstractSequence
    
    Get the element before the specified position.
    
    Overrides:
    
    getPosPrevious in class AbstractSequence<java.lang.Object>
    
    Parameters:
    
    ipos - the specified position.
    
    Returns:
    
    the following element, or eofValue if there is none. FIXME Should change eof handling so return type can be E.
  - getPosNextInt
```
public int getPosNextInt(int ipos)
```
    Return following value (like getPosNext), as an integer.
  - getPosNext
```
public java.lang.Object getPosNext(int ipos)
```
    Description copied from class: AbstractSequence
    
    Get the element following the specified position.
    
    Overrides:
    
    getPosNext in class AbstractSequence<java.lang.Object>
    
    Parameters:
    
    ipos - the specified position.
    
    Returns:
    
    the following element, or eofValue if there is none. Called by SeqPosition.getNext. FIXME Should change eof handling so return type can be E.
  - stringValue
```
public void stringValue(int startIndex,
                        int endIndex,
                        java.lang.StringBuffer sbuf)
```
  - stringValue
```
public int stringValue(int index,
                       java.lang.StringBuffer sbuf)
```
  - stringValue
```
public int stringValue(boolean inElement,
                       int index,
                       java.lang.StringBuffer sbuf)
```
  - createRelativePos
```
public int createRelativePos(int istart,
                             int offset,
                             boolean isAfter)
```
    Overrides:
    
    createRelativePos in class AbstractSequence<java.lang.Object>
  - nextNodeIndex
```
public final int nextNodeIndex(int pos,
                               int limit)
```
    Skip all primitive content nodes.
  - nextMatching
```
public int nextMatching(int startPos,
                        ItemPredicate predicate,
                        int endPos,
                        boolean descend)
```
    Description copied from class: AbstractSequence
    
    Get next matching child or descendent (ignoring attributes).
    
    Overrides:
    
    nextMatching in class AbstractSequence<java.lang.Object>
    
    Parameters:
    
    startPos - starting position
    
    predicate - a test (predicate) to apply to selected elements
    
    endPos - stop before endPos
    
    descend - if true do depth-first traversal.
    
    Returns:
    
    poistion of next match or 0 if none found
  - nextPos
```
public int nextPos(int position)
```
    Description copied from class: AbstractSequence
    
    Return the next position following the argument. The new position has the isAfter property. The argument is implicitly released (as in releasePos). Returns 0 if we are already at end of file.
    
    Overrides:
    
    nextPos in class AbstractSequence<java.lang.Object>
  - nextDataIndex
```
public final int nextDataIndex(int pos)
```
  - documentUriOfPos
```
public java.lang.Object documentUriOfPos(int pos)
```
  - compare
```
public int compare(int ipos1,
                   int ipos2)
```
    Compare two positions, and indicate their relative order.
    
    Overrides:
    
    compare in class AbstractSequence<java.lang.Object>
  - getIndexDifference
```
protected int getIndexDifference(int ipos1,
                                 int ipos0)
```
    Description copied from class: AbstractSequence
    
    Get offset of (ipos1) relative to (ipos0).
    
    Overrides:
    
    getIndexDifference in class AbstractSequence<java.lang.Object>
  - nextIndex
```
public int nextIndex(int ipos)
```
    Description copied from class: AbstractSequence
    
    Get the offset from the beginning corresponding to a position cookie.
    
    Overrides:
    
    nextIndex in class AbstractSequence<java.lang.Object>
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class AbstractSequence<java.lang.Object>
  - consume
```
public void consume(Consumer out)
```
    Specified by:
    
    consume in interface Consumable
    
    Overrides:
    
    consume in class AbstractSequence<java.lang.Object>
  - statistics
```
public void statistics()
```
  - statistics
```
public void statistics(java.io.PrintWriter out)
```
  - dump
```
public void dump()
```
  - dump
```
public void dump(java.io.PrintWriter out)
```
  - dump
```
public void dump(java.io.PrintWriter out,
                 int start,
                 int limit)
```

Class TreeList

Field Summary

Fields inherited from class gnu.lists.AbstractSequence

Constructor Summary

Method Summary

Methods inherited from class gnu.lists.AbstractSequence

Methods inherited from class java.lang.Object

Methods inherited from interface gnu.lists.Consumer

Methods inherited from interface java.util.function.Consumer

Methods inherited from interface java.util.function.IntConsumer

Methods inherited from interface java.util.function.LongConsumer

Methods inherited from interface java.util.function.DoubleConsumer

Field Detail

objects

oindex

data

gapStart

gapEnd

attrStart

docStart

MAX_CHAR_SHORT

POSITION_PAIR_FOLLOWS

INT_FOLLOWS

PROCESSING_INSTRUCTION

BEGIN_ATTRIBUTE_LONG

BEGIN_ATTRIBUTE_LONG_SIZE

END_ATTRIBUTE_SIZE

BEGIN_DOCUMENT

END_DOCUMENT

BEGIN_ENTITY

BEGIN_ENTITY_SIZE

END_ENTITY

DOCUMENT_URI

BEGIN_ELEMENT_SHORT

BEGIN_ELEMENT_SHORT_INDEX_MAX

END_ELEMENT_SHORT

BEGIN_ELEMENT_LONG

END_ELEMENT_LONG

Constructor Detail

TreeList

TreeList

TreeList

Method Detail

clear

ensureSpace

reserveObjects

find

getIntN

getLongN

setIntN

writePosition

writePosition

writeObject

writeDocumentUri

writeComment

writeComment

writeProcessingInstruction

writeProcessingInstruction

startElement

startDocument

endDocument

beginEntity

endEntity

startElement

setElementName

endElement

startAttribute

startAttribute

setAttributeName

endAttribute

append

write

writeBoolean

writeByte

writeInt

writeIntForce32

writeLong

writeFloat

writeDouble

ignoring