xapi.collect.impl

Class IntToAbstract<V>

java.lang.Object

xapi.collect.impl.IntToAbstract<V>

All Implemented Interfaces:

IntTo<V>, CollectionProxy<Integer,V>

public class IntToAbstract<V>
extends Object
implements IntTo<V>

Nested Class Summary

Nested classes/interfaces inherited from interface xapi.collect.api.IntTo

IntTo.IntToIterable<T>, IntTo.IntToIterator<T>, IntTo.Many<T>

Constructor Summary

Constructors

Constructor and Description
IntToAbstract(CollectionProxy<Integer,V> store, CollectionOptions opts, Comparator<V> comparator)

Method Summary

Modifier and Type	Method and Description
boolean	add(V item)
boolean	addAll(Iterable<V> items)
boolean	addAll(V... items)
Deque<V>	asDeque() If this IntTo is mutable, you will be getting a DequeProxy, backed by this IntTo.
List<V>	asList() If this IntTo is mutable, you will be getting a ListProxy, backed by this IntTo.
Set<V>	asSet() If this IntTo is mutable, you will be getting a SetProxy, backed by this IntTo.
V	at(int index)
void	clear()
ObjectTo<Integer,V>	clone(CollectionOptions options)
boolean	contains(V value)
Map.Entry<Integer,V>	entryFor(Object key)
boolean	findRemove(V value, boolean all)
Iterable<V>	forEach()
V	get(Object key)
int	indexOf(V value)
boolean	insert(int pos, V item)
boolean	isEmpty()
protected Map.Entry<Integer,V>	newEntry(int size, V item)
V	pop()
void	push(V item)
V	put(int key, V value)
V	put(Map.Entry<Integer,V> value)
boolean	remove(int index)
V	remove(Object key)
void	set(int index, V value)
void	setValue(Object key, Object value)
int	size()
V[]	toArray()
Collection<V>	toCollection(Collection<V> into)
Map<Integer,V>	toMap(Map<Integer,V> into)

Methods inherited from class java.lang.Object

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

Constructor Detail

IntToAbstract

public IntToAbstract(CollectionProxy<Integer,V> store,
                     CollectionOptions opts,
                     Comparator<V> comparator)

Method Detail

forEach

public Iterable<V> forEach()

Specified by:

forEach in interface IntTo<V>

size

public int size()

Specified by:

size in interface CollectionProxy<Integer,V>

toArray

public V[] toArray()

Specified by:

toArray in interface CollectionProxy<Integer,V>

add

public boolean add(V item)

Specified by:

add in interface IntTo<V>

insert

public boolean insert(int pos,
                      V item)

Specified by:

insert in interface IntTo<V>

newEntry

protected Map.Entry<Integer,V> newEntry(int size,
                                        V item)

push

public void push(V item)

Specified by:

push in interface IntTo<V>

pop

public V pop()

Specified by:

pop in interface IntTo<V>

toCollection

public Collection<V> toCollection(Collection<V> into)

Specified by:

toCollection in interface CollectionProxy<Integer,V>

toMap

public Map<Integer,V> toMap(Map<Integer,V> into)

Specified by:

toMap in interface CollectionProxy<Integer,V>

clone

public ObjectTo<Integer,V> clone(CollectionOptions options)

Specified by:

clone in interface CollectionProxy<Integer,V>

contains

public boolean contains(V value)

Specified by:

contains in interface IntTo<V>

at

public V at(int index)

Specified by:

at in interface IntTo<V>

indexOf

public int indexOf(V value)

Specified by:

indexOf in interface IntTo<V>

remove

public boolean remove(int index)

Specified by:

remove in interface IntTo<V>

findRemove

public boolean findRemove(V value,
                          boolean all)

Specified by:

findRemove in interface IntTo<V>

set

public void set(int index,
                V value)

Specified by:

set in interface IntTo<V>

asList

public List<V> asList()

Description copied from interface: IntTo

If this IntTo is mutable, you will be getting a ListProxy, backed by this IntTo. If the underlying IntTo forbids duplicates, the ListProxy will act like a set.

If this IntTo is immutable, you are getting an ArrayList you can mutate as you wish.

Specified by:

asList in interface IntTo<V>

asSet

public Set<V> asSet()

Description copied from interface: IntTo

If this IntTo is mutable, you will be getting a SetProxy, backed by this IntTo. This SetProxy will call remove(item) before every addInternal(item). If this IntTo is immutable, you are getting a HashSet you can mutate as you wish.

Specified by:

asSet in interface IntTo<V>

asDeque

public Deque<V> asDeque()

Description copied from interface: IntTo

If this IntTo is mutable, you will be getting a DequeProxy, backed by this IntTo. If the underlying IntTo forbids duplicates, the DequeProxy will act like a set. If this IntTo is immutable, you are getting a LinkedList you can mutate as you wish.

Specified by:

asDeque in interface IntTo<V>

get

public V get(Object key)

Specified by:

get in interface CollectionProxy<Integer,V>

put

public V put(int key,
             V value)

put

public V put(Map.Entry<Integer,V> value)

Specified by:

put in interface CollectionProxy<Integer,V>

remove

public V remove(Object key)

Specified by:

remove in interface CollectionProxy<Integer,V>

isEmpty

public boolean isEmpty()

Specified by:

isEmpty in interface CollectionProxy<Integer,V>

clear

public void clear()

Specified by:

clear in interface CollectionProxy<Integer,V>

entryFor

public Map.Entry<Integer,V> entryFor(Object key)

Specified by:

entryFor in interface CollectionProxy<Integer,V>

setValue

public void setValue(Object key,
                     Object value)

Specified by:

setValue in interface CollectionProxy<Integer,V>

addAll

public boolean addAll(Iterable<V> items)

Specified by:

addAll in interface IntTo<V>

addAll

public boolean addAll(V... items)

Specified by:

addAll in interface IntTo<V>