KeyedSet (org.genantics:keyedset 0.1 API)

java.lang.Object
- org.genantics.set.KeyedSet<K,T>

All Implemented Interfaces:

Iterable<T>

Direct Known Subclasses:

KeyedSet.Empty
```
public class KeyedSet<K extends Comparable<K>,T extends Keyed<K>>
extends Object
implements Iterable<T>
```
Immutable set based on AVL tree. Any operation that changes the set returns a new set that shares structure with the original set.
KeyedSet does not implement java.util.Set, as the interface is not well-suited to an immutable set, but provides the common set operations and a number of map-like operations. Null values are not allowed. The containsAll, containsAny, addAll, removeAll and retainAll could be faster if methods specialized to KeyedSet were added.

Author:

Bob Foster

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`KeyedSet.Empty<T extends Keyed<K>,K extends Comparable<K>>` Empty is a singleton object representing the empty set.
`protected class`	`KeyedSet.ReverseTreeIterable`
`protected class`	`KeyedSet.ReverseTreeIterator`
`protected class`	`KeyedSet.ReverseValueIterable`
`protected class`	`KeyedSet.ReverseValueIterator`
`protected class`	`KeyedSet.TreeIterable`
`protected class`	`KeyedSet.TreeState`
`protected class`	`KeyedSet.ValueIterable`
`protected class`	`KeyedSet.ValueIterator`

Field Summary

Fields
Modifier and Type Field and Description

static KeyedSet EMPTY

protected int height

protected KeyedSet<K,T> left

protected T member

protected KeyedSet<K,T> right

Fields
Modifier and Type	Field and Description
`static KeyedSet`	`EMPTY`
`protected int`	`height`
`protected KeyedSet<K,T>`	`left`
`protected T`	`member`
`protected KeyedSet<K,T>`	`right`

Constructor Summary

Constructors
Modifier	Constructor and Description
	`KeyedSet(Iterable<T> iterable)` Construct set from iterable.
`protected`	`KeyedSet(T element, KeyedSet<K,T> left, KeyedSet<K,T> right)` Constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`KeyedSet<K,T>`	`add(T element)` Add an element to the set.
`KeyedSet<K,T>`	`add(T element, boolean[] added)` Convenience method for java.util.Set, which returns true if the element was not already present in the tree.
`KeyedSet<K,T>`	`addAll(Iterable<T> iterable)` Add all elements in iterable to set.
`protected KeyedSet<K,T>`	`addElement(T element, boolean[] added)` addEntry returns this tree with added element
`protected KeyedSet<K,T>`	`balanceTree(KeyedSet<K,T> node)`
`KeyedSet<K,T>`	`clear()` Vacuous method for compatibility.
`void`	`collect(Collection<T> collection)` Add all elements to collection.
`boolean`	`contains(T value)`
`boolean`	`containsAll(Iterable<T> elements)`
`boolean`	`containsAny(Iterable<T> elements)`
`boolean`	`containsKey(K key)` Test if tree contains the specified key.
`protected boolean`	`containsKey(T value)`
`KeyedSet<K,T>`	`delete(K key)` Delete the element with matching key.
`KeyedSet<K,T>`	`delete(K key, boolean[] deleted)` Delete the element with matching key.
`KeyedSet<K,T>`	`deleteFirst()` Delete the first element of the tree.
`protected KeyedSet<K,T>`	`deleteKey(K key, boolean[] deleted)`
`KeyedSet<K,T>`	`deleteLast()` Delete the last element of the tree.
`Iterable<T>`	`elements()` Return an iterable that can be used in foreach to obtain elements in ascending order.
`boolean`	`equals(Object o)` Compare sets.
`KeyedSet<K,T>`	`filter(Filter filter)` Filter the set, removing all elements for which the `test` method returns false.
`T`	`get(K key)` Get the element with matching key.
`protected int`	`getBalance()`
`T`	`getFirst()` Get the first element in the tree.
`T`	`getLast()` Get the last element in the tree.
`int`	`hashCode()` Get the hashCode for the set.
`protected void`	`init()`
`boolean`	`isEmpty()`
`Iterator<T>`	`iterator()` Return an iterator over the elements of the set in ascending order.
`Iterable<K>`	`keys()` Get an iterable that can be used in foreach to obtain keys in ascending order.
`protected KeyedSet<K,T>`	`newTree(T element, KeyedSet<K,T> left, KeyedSet<K,T> right)` Function that wraps constructor.
`void`	`prettyPrint()`
`protected void`	`prettyPrint(String indent)`
`KeyedSet<K,T>`	`remove(T element)` Remove an element if the keys match and the values are equal.
`KeyedSet<K,T>`	`remove(T element, boolean[] removed)` Remove an element if the keys match and the values are equal.
`KeyedSet<K,T>`	`removeAll(Iterable<T> iterable)` Remove all elements in iterable from tree.
`protected KeyedSet<K,T>`	`removeElement(T element, boolean[] removed)`
`protected KeyedSet<K,T>`	`removeHigh(KeyedSet<K,T> node, KeyedSet<K,T> high)`
`KeyedSet<K,T>`	`retainAll(Iterable<T> iterable)` Get all elements in both set and iterable.
`Iterable<T>`	`reverseElements()` Return an iterable that can be used in foreach to obtain elements in descending order.
`Iterator<T>`	`reverseIterator()` Return an iterator over the elements of the set in descending order.
`Iterable<K>`	`reverseKeys()` Get an iterable that can be used in foreach to obtain keys in descending order.
`protected KeyedSet<K,T>`	`setLeft(KeyedSet<K,T> left)`
`protected KeyedSet<K,T>`	`setRight(KeyedSet<K,T> right)`
`int`	`size()` Get the tree size.
`String`	`toString()`
`boolean`	`visitFwd(ConditionalVisitor visitor)` Visit elements in order.
`void`	`visitFwd(Visitor visitor)` Visit all elements in order.
`boolean`	`visitRev(ConditionalVisitor visitor)` Visit all elements in reverse order.
`void`	`visitRev(Visitor visitor)` Visit all elements in reverse order.

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

- Field Detail
  - member
```
protected T extends Keyed<K> member
```
  - left
```
protected KeyedSet<K extends Comparable<K>,T extends Keyed<K>> left
```
  - right
```
protected KeyedSet<K extends Comparable<K>,T extends Keyed<K>> right
```
  - height
```
protected int height
```
  - EMPTY
```
public static final KeyedSet EMPTY
```
- Constructor Detail
  - KeyedSet
```
public KeyedSet(Iterable<T> iterable)
```
    Construct set from iterable.
    
    Parameters:
    iterable - elements of new set
  - KeyedSet
```
protected KeyedSet(T element,
        KeyedSet<K,T> left,
        KeyedSet<K,T> right)
```
    Constructor. Not intended to be directly called by users.
    
    Parameters:
    element - value of node
    left - left subtree
    right - right subtree
- Method Detail
  - newTree
```
protected KeyedSet<K,T> newTree(T element,
                    KeyedSet<K,T> left,
                    KeyedSet<K,T> right)
```
    Function that wraps constructor. Might be overridden by subclass.
    
    Parameters:
    element - value of node
    left - left subtree
    right - right subtree
    
    Returns:
    new tree
  - init
```
protected void init()
```
  - equals
```
public boolean equals(Object o)
```
    Compare sets. This is an O(n) operation.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    o - object
    
    Returns:
    true if both sets contain the same number of elements and for each pairwise element equals returns true; otherwise, false
  - hashCode
```
public int hashCode()
```
    Get the hashCode for the set. This is an O(n) operation.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    hash code
  - size
```
public int size()
```
    Get the tree size. Note this is an O(n) operation. Use isEmpty() rather than getSize() == 0.
    
    Returns:
    the number of elements in the set
  - containsKey
```
public boolean containsKey(K key)
```
    Test if tree contains the specified key.
    
    Parameters:
    key -
    
    Returns:
    true if key matched in tree; otherwise, false
  - getFirst
```
public T getFirst()
```
    Get the first element in the tree.
    
    Returns:
    element with lowest key value
  - getLast
```
public T getLast()
```
    Get the last element in the tree.
    
    Returns:
    element with highest key value
  - deleteFirst
```
public KeyedSet<K,T> deleteFirst()
```
    Delete the first element of the tree. If called with an empty tree, returns an empty tree.
    
    Returns:
    tree without first element, if any
  - deleteLast
```
public KeyedSet<K,T> deleteLast()
```
    Delete the last element of the tree. If called with an empty tree, returns an empty tree.
    
    Returns:
    tree without last element, if any
  - keys
```
public Iterable<K> keys()
```
    Get an iterable that can be used in foreach to obtain keys in ascending order.
    
    Returns:
    iterable
  - reverseKeys
```
public Iterable<K> reverseKeys()
```
    Get an iterable that can be used in foreach to obtain keys in descending order.
    
    Returns:
    iterable
  - getBalance
```
protected int getBalance()
```
  - setLeft
```
protected KeyedSet<K,T> setLeft(KeyedSet<K,T> left)
```
  - setRight
```
protected KeyedSet<K,T> setRight(KeyedSet<K,T> right)
```
  - contains
```
public boolean contains(T value)
```
  - containsKey
```
protected boolean containsKey(T value)
```
  - isEmpty
```
public boolean isEmpty()
```
    Returns:
    true if set is empty; otherwise false
  - add
```
public KeyedSet<K,T> add(T element)
```
    Add an element to the set.
    
    Parameters:
    element -
    
    Returns:
    new tree containing element
  - add
```
public KeyedSet<K,T> add(T element,
                boolean[] added)
```
    Convenience method for java.util.Set, which returns true if the element was not already present in the tree.
    
    Parameters:
    element - to add
    added - on return, added[0] true if element added and set size increased by 1; otherwise false; added[1] true if element with matching key was replaced (set size unchange); otherwise false; if neither are true, the element was already in the set
    
    Returns:
    set containing element
  - addElement
```
protected KeyedSet<K,T> addElement(T element,
                       boolean[] added)
```
    addEntry returns this tree with added element
  - get
```
public T get(K key)
```
    Get the element with matching key.
    
    Parameters:
    key -
    
    Returns:
    element or null if not found
  - delete
```
public KeyedSet<K,T> delete(K key)
```
    Delete the element with matching key. If an element is deleted, the size of the returned tree will be one less than this.
    
    Parameters:
    key -
    
    Returns:
    new tree without matching element, if any
  - delete
```
public KeyedSet<K,T> delete(K key,
                   boolean[] deleted)
```
    Delete the element with matching key. If an element is deleted, the size of the returned tree will be one less than this.
    
    Parameters:
    key -
    deleted - deleted[0] true if the size of the tree reduced by 1; otherwise false
    
    Returns:
    new tree without matching element, if any
  - deleteKey
```
protected KeyedSet<K,T> deleteKey(K key,
                      boolean[] deleted)
```
  - balanceTree
```
protected KeyedSet<K,T> balanceTree(KeyedSet<K,T> node)
```
  - remove
```
public KeyedSet<K,T> remove(T element)
```
    Remove an element if the keys match and the values are equal. If the element is removed, the size of the returned tree will be less than the size of this tree.
    
    Parameters:
    element -
    
    Returns:
    set with element removed
  - remove
```
public KeyedSet<K,T> remove(T element,
                   boolean[] removed)
```
    Remove an element if the keys match and the values are equal. If the element is removed, the size of the returned tree will be less than the size of this tree.
    
    Parameters:
    element -
    removed - on return, removed[0] true if element removed and set size reduced by 1; otherwise, false
    
    Returns:
  - removeElement
```
protected KeyedSet<K,T> removeElement(T element,
                          boolean[] removed)
```
  - removeHigh
```
protected KeyedSet<K,T> removeHigh(KeyedSet<K,T> node,
                       KeyedSet<K,T> high)
```
  - iterator
```
public Iterator<T> iterator()
```
    Return an iterator over the elements of the set in ascending order. Since the tree is immutable, the iterator will never throw ConcurrentModificationException.
    
    Specified by:
    
    iterator in interface Iterable<T extends Keyed<K>>
    
    Returns:
    iterator
  - reverseIterator
```
public Iterator<T> reverseIterator()
```
    Return an iterator over the elements of the set in descending order. Since the tree is immutable, the iterator will never throw ConcurrentModificationException.
    
    Returns:
    iterator
  - elements
```
public Iterable<T> elements()
```
    Return an iterable that can be used in foreach to obtain elements in ascending order.
    
    Returns:
    iterable
    See Also:
    iterator()
  - reverseElements
```
public Iterable<T> reverseElements()
```
    Return an iterable that can be used in foreach to obtain elements in descending order.
    
    Returns:
    iterable
    See Also:
    reverseIterator()
  - addAll
```
public KeyedSet<K,T> addAll(Iterable<T> iterable)
```
    Add all elements in iterable to set.
    
    Parameters:
    iterable - elements to add
    
    Returns:
    set + iterable elements
  - removeAll
```
public KeyedSet<K,T> removeAll(Iterable<T> iterable)
```
    Remove all elements in iterable from tree.
    
    Parameters:
    iterable - elements to remove
    
    Returns:
    set - iterable elements
  - retainAll
```
public KeyedSet<K,T> retainAll(Iterable<T> iterable)
```
    Get all elements in both set and iterable.
    
    Parameters:
    iterable -
    
    Returns:
    {element} such that element in set and element in iterable
  - visitFwd
```
public void visitFwd(Visitor visitor)
```
    Visit all elements in order.
    
    Parameters:
    visitor - visits each element
  - visitFwd
```
public boolean visitFwd(ConditionalVisitor visitor)
```
    Visit elements in order.
    
    Parameters:
    visitor - visits each element, returning false if next element is to be visited; otherwise true (desired/last element found)
    
    Returns:
    false if all elements visited; otherwise, true
  - visitRev
```
public void visitRev(Visitor visitor)
```
    Visit all elements in reverse order.
    
    Parameters:
    visitor - visits each element
  - visitRev
```
public boolean visitRev(ConditionalVisitor visitor)
```
    Visit all elements in reverse order.
    
    Parameters:
    visitor - visits each element, returning false if next element is to be visited; otherwise true (desired element found)
    
    Returns:
    false if all elements visited; otherwise true
  - filter
```
public KeyedSet<K,T> filter(Filter filter)
```
    Filter the set, removing all elements for which the test method returns false.
    
    Parameters:
    filter -
    
    Returns:
    filtered tree
  - collect
```
public void collect(Collection<T> collection)
```
    Add all elements to collection.
    
    Parameters:
    collection - target
  - containsAll
```
public boolean containsAll(Iterable<T> elements)
```
    Parameters:
    elements -
    
    Returns:
    true if set contains all elements in elements; otherwise false
  - containsAny
```
public boolean containsAny(Iterable<T> elements)
```
    Parameters:
    elements -
    
    Returns:
    true if set contains any elements in elements; otherwise false
  - clear
```
public KeyedSet<K,T> clear()
```
    Vacuous method for compatibility.
    
    Returns:
    empty tree
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - prettyPrint
```
public void prettyPrint()
```
  - prettyPrint
```
protected void prettyPrint(String indent)
```

Class KeyedSet<K extends Comparable<K>,T extends Keyed<K>>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

member

left

right

height

EMPTY

Constructor Detail

KeyedSet

KeyedSet

Method Detail

newTree

init

equals

hashCode

size

containsKey

getFirst

getLast

deleteFirst

deleteLast

keys

reverseKeys

getBalance

setLeft

setRight

contains

containsKey

isEmpty

add

add

addElement

get

delete

delete

deleteKey

balanceTree

remove

remove

removeElement

removeHigh

iterator

reverseIterator

elements

reverseElements

addAll

removeAll

retainAll

visitFwd

visitFwd

visitRev

visitRev

filter

collect

containsAll

containsAny

clear

toString

prettyPrint

prettyPrint