TreeList.TreeItr (MMBase API)

Overview

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.mmbase.bridge.util
Class TreeList.TreeItr

java.lang.Object
  org.mmbase.bridge.util.TreeList.TreeItr

All Implemented Interfaces:: Iterator, ListIterator, NodeIterator, TreeIterator

Enclosing class:: TreeList

protected class TreeList.TreeItr
extends Object
implements TreeIterator

The TreeIterator contains the core-functionality of TreeList.

Method Summary
`void`	`add(Object o)`
`int`	`currentDepth()` Depth of the last node fetched with next() or nextNode()
`protected Node`	`getNextLeafNode()` Simply returns the 'smallest' of all available nodes (compared to the 'previous node') This is actually an alternavite implementation for getNextNode, but it also works when 'leaf' constraints are applied.
`protected Node`	`getNextNode()` Implementation idea graphicly.
`protected Node`	`getRealNode(int index)` Returns the 'real' node, us the just used 'next' node of index.
`boolean`	`hasNext()`
`boolean`	`hasPrevious()`
`Object`	`next()`
`int`	`nextIndex()`
`Node`	`nextNode()` Returns the next element in the iterator as a Node
`protected boolean`	`prepare(int index)` Makes sure that query with given index has an iterator, a 'next' node and a 'previous' node.
`Object`	`previous()`
`int`	`previousIndex()`
`Node`	`previousNode()` Returns the previous element in the iterator as a Node
`void`	`remove()`
`void`	`set(Object o)`
`protected void`	`useNext(int index)` Uses the new 'next' node of the iterator with the given index.

Methods inherited from class java.lang.Object

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

Method Detail

hasNext

public boolean hasNext()

Specified by:: hasNext in interface ListIterator

prepare

protected final boolean prepare(int index)

Makes sure that query with given index has an iterator, a 'next' node and a 'previous' node.

Returns:: true it such query existed, false, otherwise

useNext

protected final void useNext(int index)

Uses the new 'next' node of the iterator with the given index. This means that it becomes the previous node and that a new 'next' node will be determined

getRealNode

protected final Node getRealNode(int index)

Returns the 'real' node, us the just used 'next' node of index.

nextNode

public Node nextNode()

Description copied from interface: NodeIterator

Returns the next element in the iterator as a Node

Specified by:: nextNode in interface NodeIterator

Returns:: next Node

currentDepth

public int currentDepth()

Depth of the last node fetched with next() or nextNode()

Specified by:: currentDepth in interface TreeIterator

Returns:: Depth of the last node fetched

public Object next()

Specified by:: next in interface ListIterator

getNextNode

protected final Node getNextNode()

Implementation idea graphicly.

                        iterators


              current-2  current-1  current       current+1                         [///]: used node
               [///]       [///]     [///]         [///]                            [|||]: last used node (lastNode)
                                                                                    [   ]: unused node
         ...   [///]       [///]     [|||] _       [///]    previousNodes           [ * ]: considered next node (nextListNextNode)
                                            \
               [   ]       [   ]     [   ]   `---> [ * ]    nextNodes

               if (! [|||] contained by [ * ]) current--

Every time next is called, the last used node is compared with the next node of the next iterator (the arrow in the above scheme). If the last used node is 'contained' by this next node, then this next node of the next iterator will be 'next()' otherwise current is decreased by one and next is called recursively. This means that the next node is always one longer than the current one, equally long, or shorter. If 'leaf constraints' are in use, then the implementation jumps to getNextLeafNode, which simply returns the 'smallest node' of all iterators.

getNextLeafNode

protected final Node getNextLeafNode()

Simply returns the 'smallest' of all available nodes (compared to the 'previous node') This is actually an alternavite implementation for getNextNode, but it also works when 'leaf' constraints are applied.

Since:: MMBase-1.8

hasPrevious

public boolean hasPrevious()

Specified by:: hasPrevious in interface ListIterator

previousNode

public Node previousNode()