LinkedTreeSupport (JOAFIP "Abstract" Parent Project 4.0.0b9)

java.lang.Object
- net.sf.joafip.java.util.support.linked.tree.LinkedTreeSupport<E>

Type Parameters:
E - the set element type

All Implemented Interfaces:

Serializable, Cloneable, Iterable<E>, IListSupport<E>, ISupportListenable<E>, ILinkedListSupportNodeManager<E>
```
@StoreNotUseStandardSerialization
@StorableClass
public class LinkedTreeSupport<E>
extends Object
implements IListSupport<E>, ILinkedListSupportNodeManager<E>, Iterable<E>, Cloneable, Serializable
```
minimum for linked tree set management
use implementation in element type of Object.equals(Object) and Object.hashCode() for access to element
maintains a doubly-linked list running through all of its entries. This linked list defines the iteration ordering

Author:

luc peuvrier

See Also:
Serialized Form

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`LinkedTreeSupport(boolean concurrentAccess)`
`protected`	`LinkedTreeSupport(Comparator<? super E> comparator, boolean concurrentAccess)`
	`LinkedTreeSupport(IInstanceFactory instanceFactory, boolean concurrentAccess)`
`protected`	`LinkedTreeSupport(IInstanceFactory instanceFactory, Comparator<? super E> comparator, boolean concurrentAccess)`

Method Summary

Methods
Modifier and Type	Method and Description
`E`	`add(int index, E element)` add element at index position
`E`	`addAtBegin(E element)`
`E`	`addAtEnd(E element)` add element at end of the list
`E`	`addReplace(E element)` add element at end of the list if equals element not already in the list, else replace the equals element
`ILinkedListSupportNode<E>`	`addToTree(E element)`
`void`	`addToTree(ILinkedListSupportNode<E> node)`
`void`	`clear()` clear the list
`LinkedTreeSupport<E>`	`clone()`
`E`	`closestGreaterOrEqual(E element)`
`E`	`closestLessOrEqual(E element)`
`boolean`	`contains(Object object)` to check if the set contains an element equals to a reference object equality check is done using `Object.equals` element implementation
`void`	`decrementSize()`
`ListIterator<E>`	`descendingIterator()` Returns an iterator over the elements in this list in reverse sequential order.
`boolean`	`equals(Object object)`
`E`	`first()`
`E`	`get(int index)`
`E`	`get(Object object)` get object in the set equals to an object equality check is done using `Object.equals` element implementation
`Comparator<? super E>`	`getComparatorForComparable()`
`IEqualsHashComparator`	`getEqualsHashComparator()`
`E`	`getFirst()` get the first element of the list null returned if empty list or if first element is null
`ILinkedListSupportNode<E>`	`getFirstNode()`
`E`	`getLast()` get the last element of the list null returned if empty list or if last element is null
`ILinkedListSupportNode<E>`	`getLastNode()` get last node of the list, null for empty list package visibility, should be used only by `LinkedListSupportIterator`
`LinkedListSupportManager<E>`	`getListManager()`
`ILinkedListSupportNode<E>`	`getRoot()` get the root node, null for empty list should be used only by `LinkedListSupportIterator` and `ILinkedListSupportNodeManager` implementation
`int`	`getSize()`
`RedBlackTree<ILinkedListSupportNode<E>>`	`getTree()`
`int`	`hashCode()`
`void`	`incrementSize()`
`int`	`indexOf(Object object)`
`boolean`	`isEmpty()`
`ListIterator<E>`	`iterator()` next will return the first element if list not empty no previous element
`ListIterator<E>`	`iterator(int index)` next will return element at index position
`E`	`last()`
`int`	`lastIndexOf(Object object)`
`boolean`	`moveDown(E element)`
`boolean`	`moveToFirstPosition(E element)`
`boolean`	`moveToLastPosition(E element)`
`static LinkedTreeSupport`	`newInstance(IInstanceFactory instanceFactory, boolean concurrentAccess)`
`static LinkedTreeSupport`	`newInstance(IInstanceFactory instanceFactory, Comparator comparator, boolean concurrentAccess)`
`ILinkedListSupportNode<E>`	`newLinkedListNode()`
`E`	`remove(int index)` remove element at index
`E`	`remove(Object object)` remove element from the set equality check is done using `Object.equals` element implementation
`E`	`removeFirst()` remove first element of the list
`void`	`removeFromTree(E element)`
`E`	`removeGreater()`
`E`	`removeLast()` remove last element of the list
`void`	`removeListener()`
`E`	`removeSmaller()`
`void`	`resetSize()`
`E`	`set(E element, int index)` add element at position
`void`	`setLastNode(ILinkedListSupportNode<E> lastNode)`
`void`	`setListener(ISupportListener<E> listener)`
`void`	`setListManager(LinkedListSupportManager<E> listManager)`
`void`	`setRoot(ILinkedListSupportNode<E> rootNode)`
`void`	`setSize(int size)`
`void`	`setTree(TreeSupport<ILinkedListSupportNode<E>> tree)`
`E`	`strictlyGreater(E element)`
`E`	`strictlyLess(E element)`

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

- Constructor Detail
  - LinkedTreeSupport
```
protected LinkedTreeSupport(boolean concurrentAccess)
```
  - LinkedTreeSupport
```
public LinkedTreeSupport(IInstanceFactory instanceFactory,
                 boolean concurrentAccess)
```
  - LinkedTreeSupport
```
protected LinkedTreeSupport(Comparator<? super E> comparator,
                 boolean concurrentAccess)
```
  - LinkedTreeSupport
```
protected LinkedTreeSupport(IInstanceFactory instanceFactory,
                 Comparator<? super E> comparator,
                 boolean concurrentAccess)
```
- Method Detail
  - newInstance
```
public static LinkedTreeSupport newInstance(IInstanceFactory instanceFactory,
                            boolean concurrentAccess)
```
  - newInstance
```
public static LinkedTreeSupport newInstance(IInstanceFactory instanceFactory,
                            Comparator comparator,
                            boolean concurrentAccess)
```
  - removeListener
```
public void removeListener()
```
    Specified by:
    
    removeListener in interface ISupportListenable<E>
  - setListener
```
public void setListener(ISupportListener<E> listener)
```
    Specified by:
    
    setListener in interface ISupportListenable<E>
  - getEqualsHashComparator
```
public IEqualsHashComparator getEqualsHashComparator()
```
    Specified by:
    
    getEqualsHashComparator in interface ILinkedListSupportNodeManager<E>
  - getComparatorForComparable
```
public Comparator<? super E> getComparatorForComparable()
```
  - get
```
public E get(Object object)
```
    get object in the set equals to an object
    equality check is done using Object.equals element implementation
    
    Specified by:
    
    get in interface IListSupport<E>
    
    Parameters:
    object - reference object
    
    Returns:
    the object of the set equals to reference object
  - get
```
public E get(int index)
```
    Specified by:
    
    get in interface IListSupport<E>
    
    Returns:
    element at position index
  - getFirst
```
public E getFirst()
```
    Description copied from interface: IListSupport
    
    get the first element of the list
    null returned if empty list or if first element is null
    
    Specified by:
    
    getFirst in interface IListSupport<E>
    
    Returns:
    first element of the list
  - getLast
```
public E getLast()
```
    Description copied from interface: IListSupport
    
    get the last element of the list
    null returned if empty list or if last element is null
    
    Specified by:
    
    getLast in interface IListSupport<E>
    
    Returns:
    first element of the list
  - indexOf
```
public int indexOf(Object object)
```
    Specified by:
    
    indexOf in interface IListSupport<E>
    
    Returns:
    the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element
  - lastIndexOf
```
public int lastIndexOf(Object object)
```
    Specified by:
    
    lastIndexOf in interface IListSupport<E>
    
    Returns:
    the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element
  - contains
```
public boolean contains(Object object)
```
    to check if the set contains an element equals to a reference object
    equality check is done using Object.equals element implementation
    
    Specified by:
    
    contains in interface IListSupport<E>
    
    Parameters:
    object - the reference object
    
    Returns:
    true if an element equals to reference object is in the set
  - add
```
public E add(int index,
    E element)
```
    Description copied from interface: IListSupport
    
    add element at index position
    
    Specified by:
    
    add in interface IListSupport<E>
    
    Parameters:
    index - position for add
    element - element to add
    
    Returns:
    replaced element, null if none
  - addAtBegin
```
public E addAtBegin(E element)
```
    Specified by:
    
    addAtBegin in interface IListSupport<E>
    
    Parameters:
    element - element to add at begin of list
    
    Returns:
    replaced element, null if none
  - addAtEnd
```
public E addAtEnd(E element)
```
    Description copied from interface: IListSupport
    
    add element at end of the list
    
    Specified by:
    
    addAtEnd in interface IListSupport<E>
    
    Parameters:
    element - the element to add
    
    Returns:
    the replaced element, null if none
  - addReplace
```
public E addReplace(E element)
```
    Description copied from interface: IListSupport
    
    add element at end of the list if equals element not already in the list, else replace the equals element
    
    Specified by:
    
    addReplace in interface IListSupport<E>
  - addToTree
```
public void addToTree(ILinkedListSupportNode<E> node)
```
  - addToTree
```
public ILinkedListSupportNode<E> addToTree(E element)
```
  - remove
```
public E remove(Object object)
```
    remove element from the set
    equality check is done using Object.equals element implementation
    
    Specified by:
    
    remove in interface IListSupport<E>
    
    Parameters:
    object - the element reference to remove
    
    Returns:
    the instance of the removed element, null if none removed
  - remove
```
public E remove(int index)
```
    Description copied from interface: IListSupport
    
    remove element at index
    
    Specified by:
    
    remove in interface IListSupport<E>
    
    Parameters:
    index - position of element to remove
    
    Returns:
    the removed element
  - removeLast
```
public E removeLast()
```
    Description copied from interface: IListSupport
    
    remove last element of the list
    
    Specified by:
    
    removeLast in interface IListSupport<E>
    
    Returns:
    element removed, null if element removed was null or if empty list
  - removeFirst
```
public E removeFirst()
```
    Description copied from interface: IListSupport
    
    remove first element of the list
    
    Specified by:
    
    removeFirst in interface IListSupport<E>
    
    Returns:
    element removed, null if element removed was null or if empty list
  - removeFromTree
```
public void removeFromTree(E element)
```
  - set
```
public E set(E element,
    int index)
```
    Description copied from interface: IListSupport
    
    add element at position
    
    Specified by:
    
    set in interface IListSupport<E>
    
    Returns:
    instance of the element replaced, null if none
  - clear
```
public void clear()
```
    Description copied from interface: IListSupport
    
    clear the list
    
    Specified by:
    
    clear in interface IListSupport<E>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface IListSupport<E>
    
    Returns:
    true if list empty
  - getLastNode
```
public ILinkedListSupportNode<E> getLastNode()
```
    Description copied from interface: ILinkedListSupportNodeManager
    
    get last node of the list, null for empty list
    package visibility, should be used only by LinkedListSupportIterator
    
    Specified by:
    
    getLastNode in interface ILinkedListSupportNodeManager<E>
    
    Returns:
    last node of the list, null for empty list
  - getFirstNode
```
public ILinkedListSupportNode<E> getFirstNode()
```
    Specified by:
    
    getFirstNode in interface ILinkedListSupportNodeManager<E>
  - getRoot
```
public ILinkedListSupportNode<E> getRoot()
```
    Description copied from interface: ILinkedListSupportNodeManager
    
    get the root node, null for empty list
    should be used only by LinkedListSupportIterator and ILinkedListSupportNodeManager implementation
    
    Specified by:
    
    getRoot in interface ILinkedListSupportNodeManager<E>
    
    Returns:
    the root node, null for empty list
  - newLinkedListNode
```
public ILinkedListSupportNode<E> newLinkedListNode()
```
    Specified by:
    
    newLinkedListNode in interface ILinkedListSupportNodeManager<E>
  - setLastNode
```
public void setLastNode(ILinkedListSupportNode<E> lastNode)
```
    Specified by:
    
    setLastNode in interface ILinkedListSupportNodeManager<E>
  - setRoot
```
public void setRoot(ILinkedListSupportNode<E> rootNode)
```
    Specified by:
    
    setRoot in interface ILinkedListSupportNodeManager<E>
  - getSize
```
public int getSize()
```
    Specified by:
    
    getSize in interface IListSupport<E>
    
    Specified by:
    
    getSize in interface ILinkedListSupportNodeManager<E>
    
    Returns:
    number of elements in the list
  - decrementSize
```
public void decrementSize()
```
    Specified by:
    
    decrementSize in interface ILinkedListSupportNodeManager<E>
  - incrementSize
```
public void incrementSize()
```
    Specified by:
    
    incrementSize in interface ILinkedListSupportNodeManager<E>
  - resetSize
```
public void resetSize()
```
    Specified by:
    
    resetSize in interface ILinkedListSupportNodeManager<E>
  - getListManager
```
public LinkedListSupportManager<E> getListManager()
```
  - iterator
```
public ListIterator<E> iterator()
```
    Description copied from interface: IListSupport
    
    next will return the first element if list not empty
    no previous element
    
    Specified by:
    
    iterator in interface Iterable<E>
    
    Specified by:
    
    iterator in interface IListSupport<E>
    
    Returns:
    iterator on this list, set to start at begin of this list
  - iterator
```
public ListIterator<E> iterator(int index)
```
    Description copied from interface: IListSupport
    
    next will return element at index position
    
    Specified by:
    
    iterator in interface IListSupport<E>
    
    Parameters:
    index - start of the iteration
    
    Returns:
    iterator on this list, set to start at index element
  - descendingIterator
```
public ListIterator<E> descendingIterator()
```
    Description copied from interface: IListSupport
    
    Returns an iterator over the elements in this list in reverse sequential order. The elements will be returned in order from last (tail) to first (head).
    
    Specified by:
    
    descendingIterator in interface IListSupport<E>
    
    Returns:
    an iterator over the elements in this list in reverse sequence
  - closestGreaterOrEqual
```
public E closestGreaterOrEqual(E element)
```
  - closestLessOrEqual
```
public E closestLessOrEqual(E element)
```
  - strictlyGreater
```
public E strictlyGreater(E element)
```
  - strictlyLess
```
public E strictlyLess(E element)
```
  - removeSmaller
```
public E removeSmaller()
```
  - removeGreater
```
public E removeGreater()
```
  - first
```
public E first()
```
  - last
```
public E last()
```
  - moveToLastPosition
```
public boolean moveToLastPosition(E element)
```
  - moveToFirstPosition
```
public boolean moveToFirstPosition(E element)
```
  - moveDown
```
public boolean moveDown(E element)
```
    Parameters:
    element -
    
    Returns:
    true if move down, false if not found or already at end of the list
  - clone
```
public LinkedTreeSupport<E> clone()
```
    Overrides:
    
    clone in class Object
  - setListManager
```
public void setListManager(LinkedListSupportManager<E> listManager)
```
  - setSize
```
public void setSize(int size)
```
  - setTree
```
public void setTree(TreeSupport<ILinkedListSupportNode<E>> tree)
```
  - equals
```
public boolean equals(Object object)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - getTree
```
@Fortest
public RedBlackTree<ILinkedListSupportNode<E>> getTree()
```

Class LinkedTreeSupport<E>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

LinkedTreeSupport

LinkedTreeSupport

LinkedTreeSupport

LinkedTreeSupport

Method Detail

newInstance

newInstance

removeListener

setListener

getEqualsHashComparator

getComparatorForComparable

get

get

getFirst

getLast

indexOf

lastIndexOf

contains

add

addAtBegin

addAtEnd

addReplace

addToTree

addToTree

remove

remove

removeLast

removeFirst

removeFromTree

set

clear

isEmpty

getLastNode

getFirstNode

getRoot

newLinkedListNode

setLastNode

setRoot

getSize

decrementSize

incrementSize

resetSize

getListManager

iterator

iterator

descendingIterator

closestGreaterOrEqual

closestLessOrEqual

strictlyGreater

strictlyLess

removeSmaller

removeGreater

first

last

moveToLastPosition

moveToFirstPosition

moveDown

clone

setListManager

setSize

setTree

equals

hashCode

getTree