TreeList.TreeItr (MMBase API)

Overview

Package

Class

Tree

Deprecated

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:: java.util.Iterator, java.util.ListIterator, NodeIterator, TreeIterator

Enclosing class:: TreeList

protected class TreeList.TreeItr
extends java.lang.Object
implements TreeIterator

The TreeIterator!

Method Summary
`void`	`add(java.lang.Object o)`
`int`	`currentDepth()` Depth of the last node fetched with next() or nextNode()
`protected Node`	`getNextNode()` Implementation idea graphicly.
`protected Node`	`getRealNode(int index)`
`boolean`	`hasNext()`
`boolean`	`hasPrevious()`
`java.lang.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.
`java.lang.Object`	`previous()`
`int`	`previousIndex()`
`Node`	`previousNode()` Returns the previous element in the iterator as a Node
`void`	`remove()`
`void`	`set(java.lang.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 java.util.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)

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

currentDepth

public int currentDepth()

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

Specified by:: currentDepth in interface TreeIterator

public java.lang.Object next()

Specified by:: next in interface java.util.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           [ * ]: considerd next node (nextListNextNode)
                                            \   
               [   ]       [   ]     [   ]   `---> [ * ]    nextNodes

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

Everytime next is called, the last used node is compared with the next node of the next iterator (the arrow int 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 then the current one, equally long, or shorter.

hasPrevious

public boolean hasPrevious()

Specified by:: hasPrevious in interface java.util.ListIterator

previousNode

public Node previousNode()