gnu.lists

Class TreeList

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

Implemented Interfaces:: Consumable, Consumer, PositionConsumer, XConsumer

Known Direct Subclasses:: NodeTree, Values

public class TreeList

extends AbstractSequence

implements 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
`protected static int`	`BEGIN_ATTRIBUTE_LONG` The beginning of an attribute.
`protected static int`	`BEGIN_DOCUMENT` Beginning of a document (or top-level value).
`protected static int`	`END_DOCUMENT` End of a document.
`protected static int`	`END_GROUP_LONG` End of a group, non-compact form.
`protected static int`	`END_GROUP_SHORT` End of a group, compact form.
`static int`	`INT_FOLLOWS` A 32-bit integer, non-compact form.
`protected static char`	`POSITION_PAIR_FOLLOWS` A position triple referenceing some other "nodes".
`protected static int`	`PROCESSING_INSTRUCTION` A processing-instruction node follows.
`int`	`attrStart` If non-zero, gap is in an attribute starting (1 less than) here.
`char[]`	`data`
`int`	`docStart` If non-zero, gap is in an document starting (1 less than) here.
`int`	`gapEnd`
`int`	`gapStart`
`Object[]`	`objects`
`int`	`oindex`

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

Method Summary
`Object`	`baseUriOfPos(int pos)` Return of the base-uri property, if known, of the node at pos.
`void`	`beginAttribute(String attrName, Object attrType)` Write a attribute for the current group.
`void`	`beginAttribute(int index)`
`void`	`beginDocument()`
`void`	`beginGroup(String typeName, Object type)`
`void`	`beginGroup(int index)`
`void`	`clear()`
`int`	`compare(int ipos1, int ipos2)` Compare two positions, and indicate their relative order.
`void`	`consume(Consumer out)`
`void`	`consume(SeqPosition position)` Consume node at current position.
`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)`
`void`	`dump()`
`void`	`dump(java.io.PrintWriter out)`
`void`	`endAttribute()`
`void`	`endDocument()`
`void`	`endGroup(String typeName)`
`void`	`ensureSpace(int needed)`
`int`	`find(Object arg1)`
`int`	`find(Object arg1, Object arg2)`
`int`	`firstAttributePos(int ipos)` Like firstChildPos.
`int`	`firstChildPos(int ipos)` Get position before first child (of the element following position).
`Object`	`get(int index)` See java.util.List.
`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)`
`protected int`	`getNextTypeIndex(int ipos)`
`String`	`getNextTypeName(int ipos)`
`Object`	`getNextTypeObject(int ipos)`
`Object`	`getPosNext(int ipos)` Get the element following the specified position.
`int`	`getPosNextInt(int ipos)` Return following value (like getPosNext), as an integer.
`Object`	`getPosPrevious(int ipos)` Get the element before the specified position.
`boolean`	`gotoAttributesStart(TreePosition pos)`
`int`	`gotoAttributesStart(int index)`
`int`	`gotoChildrenStart(int index)`
`boolean`	`hasNext(int ipos)`
`int`	`hashCode()`
`boolean`	`ignoring()` True if consumer is ignoring rest of group.
`boolean`	`isEmpty()`
`int`	`nextDataIndex(int pos)`
`int`	`nextMatching(int startPos, ElementPredicate 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`	`parentPos(int ipos)` Get position of parent.
`int`	`posToDataIndex(int ipos)`
`void`	`resizeObjects()`
`void`	`setIntN(int index, int i)`
`int`	`size()` See java.util.List.
`void`	`statistics()`
`void`	`statistics(java.io.PrintWriter out)`
`int`	`stringValue(boolean inGroup, int index, StringBuffer sbuf)`
`int`	`stringValue(int index, StringBuffer sbuf)`
`void`	`toString(String sep, StringBuffer sbuf)`
`void`	`write(char[] buf, int off, int len)`
`void`	`writeBaseUri(Object uri)` Write/set the base-uri property of the current element or document.
`void`	`writeBoolean(boolean v)`
`void`	`writeByte(int v)`
`void`	`writeCDATA(char[] chars, int offset, int length)`
`void`	`writeChar(int i)`
`void`	`writeChars(String str)`
`void`	`writeComment(char[] chars, int offset, int length)`
`void`	`writeDouble(double v)`
`void`	`writeFloat(float v)`
`void`	`writeInt(int v)`
`void`	`writeLong(long v)`
`void`	`writeObject(Object v)`
`void`	`writePosition(AbstractSequence seq, int ipos)` Consume a single position pair.
`void`	`writeProcessingInstruction(String target, char[] content, int offset, int length)`

add, add, addAll, addAll, addPos, append, baseUriOfPos, clear, compare, compare, compare, consume, consumeNext, consumePosRange, contains, containsAll, copyPos, createPos, createRelativePos, elements, endPos, equals, equals, fill, fill, fillPosRange, firstAttributePos, firstChildPos, fromEndIndex, get, get, getAttribute, getAttributeLength, getContainingSequenceSize, getEffectiveIndex, getIndexDifference, getIterator, getIterator, getIteratorAtPos, getLowBound, getNextKind, getNextTypeName, getNextTypeObject, getPosNext, getPosPrevious, getSize, gotoAttributesStart, gotoChildrenStart, gotoParent, hasNext, hasPrevious, hashCode, indexOf, isAfterPos, isEmpty, iterator, lastIndexOf, listIterator, listIterator, nextIndex, nextIndex, nextMatching, nextPos, parentPos, previousPos, rank, releasePos, remove, remove, removeAll, removePos, removePosRange, retainAll, set, set, setPosNext, setPosPrevious, size, stableCompare, startPos, subList, subSequence, subSequencePos, toArray, toArray, toString, toString, unsupported

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. Kludge warning: ParsedXMLToConsumer.endAttributes has hard-wired in the size of BEGIN_ATTRIBUTE_LONG and END_ATTRIBUTE.
Field Value:
61705

BEGIN_DOCUMENT

protected static final int BEGIN_DOCUMENT

Beginning of a document (or top-level value). [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. Used to distinguish a document from its element node.
Field Value:
61712

END_DOCUMENT

protected static final int END_DOCUMENT

End of a document.
Field Value:
61713

END_GROUP_LONG

protected static final int END_GROUP_LONG

End of a group, non-compact form. [END_GROUP_LONG] [index], 2 shorts where objects[index] is the group's type name and objects[index+1] is the type object. [begin_offset], in 2 shorts. The position of the matching BEGIN_GROUP_LONG. If the group straddles the gap, then begin_offset is the actual index (i.e. relative to the start of data) of the matching BEGIN_GROUP_LONG. (Therefore allocating more space for the gap does not require adjusting begin_offset.) If the group does not straddle the gap, then begin_offset is a negative offset relative to the END_GROUP_LONG word. (Hence shifting an entire group 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_GROUP_LONG, BEGIN_GROUP_SHORT or BEGIN_DOCUMENT. If the difference straddles the gap (i.e. either this group straddles the gap or the parent group does and the gap precedes this group), then parent_offset is the actual index of the parent group. Otherwise, then parent_offset is a negative offset relative to the END_GROUP_LONG word.
Field Value:
61708

END_GROUP_SHORT

protected static final int END_GROUP_SHORT

End of a group, compact form. [END_GROUP_SHORT] [begin_offset], the unsigned absolute value of the offset to the matching BEGIN. (This is the same as the matching end_offset.)
Field Value:
61707

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.
Field Value:
61698

POSITION_PAIR_FOLLOWS

protected static final char POSITION_PAIR_FOLLOWS

A position triple referenceing some other "nodes". Followed by index of sequence (2 chars), and ipos (2 chars).
Field Value:
'\uf10f'

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.
Field Value:
61716

attrStart

public int attrStart

If non-zero, gap is in an attribute starting (1 less than) here.

data

public char[] data

docStart

public int docStart

If non-zero, gap is in an document starting (1 less than) here.

gapEnd

public int gapEnd

gapStart

public int gapStart

objects

public Object[] objects

oindex

public int oindex

TreeList

public TreeList()

TreeList

public TreeList(TreeList list)

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

baseUriOfPos

public Object baseUriOfPos(int pos)

Return of the base-uri property, if known, of the node at pos.
Overrides:
baseUriOfPos in interface AbstractSequence

beginAttribute

public void beginAttribute(String attrName,
                           Object attrType)

Write a attribute for the current group. This is only allowed immediately after a beginGroup.
Specified by:
beginAttribute in interface Consumer

beginAttribute

public void beginAttribute(int index)

beginDocument

public void beginDocument()

Specified by:
beginDocument in interface Consumer

beginGroup

public void beginGroup(String typeName,
                       Object type)

Specified by:
beginGroup in interface Consumer

beginGroup

public void beginGroup(int index)

clear

public void clear()

Overrides:
clear in interface AbstractSequence

compare

public int compare(int ipos1,
                   int ipos2)

Compare two positions, and indicate their relative order.
Overrides:
compare in interface AbstractSequence

consume

public void consume(Consumer out)

Specified by:
consume in interface Consumable
Overrides:
consume in interface AbstractSequence

consume

public void consume(SeqPosition position)

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:
consume in interface PositionConsumer

consumeIRange

public int consumeIRange(int startPosition,
                         int endPosition,
                         Consumer out)

consumeNext

public boolean consumeNext(int ipos,
                           Consumer out)

Copy an element specified by a position pair to a Consumer.
Overrides:
consumeNext in interface AbstractSequence
Returns:
if hasNext(ipos).

consumePosRange

public void consumePosRange(int startPos,
                            int endPos,
                            Consumer out)

Overrides:
consumePosRange in interface AbstractSequence

createPos

public int createPos(int index,
                     boolean isAfter)

Generate a position at a given index. The result is a position cookie that must be free'd with releasePos.
Overrides:
createPos in interface AbstractSequence
Parameters:
index - offset from beginning of desired position
isAfter - should the position have the isAfter property

createRelativePos

public int createRelativePos(int istart,
                             int offset,
                             boolean isAfter)

Overrides:
createRelativePos in interface AbstractSequence

dump

public void dump()

dump

public void dump(java.io.PrintWriter out)

endAttribute

public void endAttribute()

Specified by:
endAttribute in interface Consumer

endDocument

public void endDocument()

Specified by:
endDocument in interface Consumer

endGroup

public void endGroup(String typeName)

Specified by:
endGroup in interface Consumer

ensureSpace

public void ensureSpace(int needed)

find

public int find(Object arg1)

find

public int find(Object arg1,
                Object arg2)

firstAttributePos

public int firstAttributePos(int ipos)

Like firstChildPos. Problem: Should this stop before we get to children? I think so, but that requires changes to TreeList.
Overrides:
firstAttributePos in interface AbstractSequence

firstChildPos

public int firstChildPos(int ipos)

Get position before first child (of the element following position).
Overrides:
firstChildPos in interface AbstractSequence
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).

get

public Object get(int index)

See java.util.List.
Overrides:
get in interface AbstractSequence

getIndexDifference

protected int getIndexDifference(int ipos1,
                                 int ipos0)

Get offset of (ipos1) relative to (ipos0).
Overrides:
getIndexDifference in interface AbstractSequence

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.

getNextKind

public int getNextKind(int ipos)

Overrides:
getNextKind in interface AbstractSequence

getNextTypeIndex

protected int getNextTypeIndex(int ipos)

getNextTypeName

public String getNextTypeName(int ipos)

Overrides:
getNextTypeName in interface AbstractSequence

getNextTypeObject

public Object getNextTypeObject(int ipos)

Overrides:
getNextTypeObject in interface AbstractSequence

getPosNext

public Object getPosNext(int ipos)

Get the element following the specified position.
Overrides:
getPosNext in interface AbstractSequence
Parameters:
ipos - the specified position.
Returns:
the following element, or eofValue if there is none. Called by SeqPosition.getNext.

getPosNextInt

public int getPosNextInt(int ipos)

Return following value (like getPosNext), as an integer.

getPosPrevious

public Object getPosPrevious(int ipos)

Get the element before the specified position.
Overrides:
getPosPrevious in interface AbstractSequence
Parameters:
ipos - the specified position.
Returns:
the following element, or eofValue if there is none.

gotoAttributesStart

public boolean gotoAttributesStart(TreePosition pos)

Overrides:
gotoAttributesStart in interface AbstractSequence

gotoAttributesStart

public int gotoAttributesStart(int index)

gotoChildrenStart

public final int gotoChildrenStart(int index)

hasNext

public boolean hasNext(int ipos)

Overrides:
hasNext in interface AbstractSequence

hashCode

public int hashCode()

Overrides:
hashCode in interface AbstractSequence

ignoring

public boolean ignoring()

True if consumer is ignoring rest of group. The producer can use this information to skip ahead.
Specified by:
ignoring in interface Consumer

isEmpty

public boolean isEmpty()

Overrides:
isEmpty in interface AbstractSequence

nextDataIndex

public final int nextDataIndex(int pos)

nextMatching

public int nextMatching(int startPos,
                        ElementPredicate predicate,
                        int endPos,
                        boolean descend)

Get next matching child or descendent (ignoring attributes).
Overrides:
nextMatching in interface AbstractSequence
Parameters:
startPos - starting position
endPos - stop before endPos
descend - if true do depth-first traversal.
Returns:
poistion of next match or 0 if none found

nextNodeIndex

public final int nextNodeIndex(int pos,
                               int limit)

Skip all primitive content nodes.

nextPos

public int nextPos(int position)

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 interface AbstractSequence

parentPos

public int parentPos(int ipos)

Get position of parent.
Overrides:
parentPos in interface AbstractSequence
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.

posToDataIndex

public final int posToDataIndex(int ipos)

resizeObjects

public final void resizeObjects()

setIntN

public final void setIntN(int index,
                          int i)

size

public int size()

See java.util.List.
Overrides:
size in interface AbstractSequence

statistics

public void statistics()

statistics

public void statistics(java.io.PrintWriter out)

stringValue

public int stringValue(boolean inGroup,
                       int index,
                       StringBuffer sbuf)

stringValue

public int stringValue(int index,
                       StringBuffer sbuf)

toString

public void toString(String sep,
                     StringBuffer sbuf)

Overrides:
toString in interface AbstractSequence

write

public void write(char[] buf,
                  int off,
                  int len)

Specified by:
write in interface Consumer

writeBaseUri

public void writeBaseUri(Object uri)

Write/set the base-uri property of the current element or document. Only allowed immediately following beginDocument, beginGroup, or writeProcessingInstruction.
Specified by:
writeBaseUri in interface XConsumer

writeBoolean

public void writeBoolean(boolean v)

Specified by:
writeBoolean in interface Consumer

writeByte

public void writeByte(int v)

writeCDATA

public void writeCDATA(char[] chars,
                       int offset,
                       int length)

Specified by:
writeCDATA in interface XConsumer

writeChar

public void writeChar(int i)

Specified by:
writeChar in interface Consumer

writeChars

public void writeChars(String str)

Specified by:
writeChars in interface Consumer

writeComment

public void writeComment(char[] chars,
                         int offset,
                         int length)

Specified by:
writeComment in interface XConsumer

writeDouble

public void writeDouble(double v)

Specified by:
writeDouble in interface Consumer

writeFloat

public void writeFloat(float v)

Specified by:
writeFloat in interface Consumer

writeInt

public void writeInt(int v)

Specified by:
writeInt in interface Consumer

writeLong

public void writeLong(long v)

Specified by:
writeLong in interface Consumer

writeObject

public void writeObject(Object v)

Specified by:
writeObject in interface Consumer

writePosition

public void writePosition(AbstractSequence seq,
                          int ipos)

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

writeProcessingInstruction

public void writeProcessingInstruction(String target,
                                       char[] content,
                                       int offset,
                                       int length)

Specified by:
writeProcessingInstruction in interface XConsumer

Overview Package Tree Index Deprecated About
Prev Class \| Next Class	Frames \| No Frames
Summary: Nested \| Field \| Method \| Constr	Detail: Nested \| Field \| Method \| Constr

gnu.lists

Class TreeList

Field Summary

Constructor Summary

Method Summary

Methods inherited from class gnu.lists.AbstractSequence

Field Details

BEGIN_ATTRIBUTE_LONG

BEGIN_DOCUMENT

END_DOCUMENT

END_GROUP_LONG

END_GROUP_SHORT

INT_FOLLOWS

POSITION_PAIR_FOLLOWS

PROCESSING_INSTRUCTION

attrStart

data

docStart

gapEnd

gapStart

objects

oindex

Constructor Details

TreeList

TreeList

TreeList

Method Details

baseUriOfPos

beginAttribute

beginAttribute

beginDocument

beginGroup

beginGroup

clear

compare

consume

consume

consumeIRange

consumeNext

consumePosRange

createPos

createRelativePos

dump

dump

endAttribute

endDocument

endGroup

ensureSpace

find

find

firstAttributePos

firstChildPos

get

getIndexDifference

getIntN

getLongN

getNextKind

getNextTypeIndex

getNextTypeName

getNextTypeObject

getPosNext

getPosNextInt

getPosPrevious

gotoAttributesStart

gotoAttributesStart

gotoChildrenStart

hasNext

hashCode

ignoring

isEmpty

nextDataIndex

nextMatching

nextNodeIndex

nextPos

parentPos

posToDataIndex

resizeObjects

setIntN

size

statistics