IntToList (XApi - Dev uber jar 0.5 API)

java.lang.Object
- xapi.collect.impl.IntToList<E>

All Implemented Interfaces:: IntTo<E>, CollectionProxy<Integer,E>

public class IntToList<E>
extends Object
implements IntTo<E>

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

IntToList(Class<? extends E> cls)

Constructors
Constructor and Description
`IntToList(Class<? extends E> cls)`

Method Summary

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

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

- Constructor Detail
  - IntToList
```
public IntToList(Class<? extends E> cls)
```
- Method Detail
  - forEach
```
public Iterable<E> forEach()
```
    Specified by:
    
    forEach in interface IntTo<E>
  - clone
```
public ObjectTo<Integer,E> clone(CollectionOptions options)
```
    Specified by:
    
    clone in interface CollectionProxy<Integer,E>
  - put
```
public E put(Map.Entry<Integer,E> item)
```
    Specified by:
    
    put in interface CollectionProxy<Integer,E>
  - entryFor
```
public Map.Entry<Integer,E> entryFor(Object key)
```
    Specified by:
    
    entryFor in interface CollectionProxy<Integer,E>
  - get
```
public E get(Object key)
```
    Specified by:
    
    get in interface CollectionProxy<Integer,E>
  - setValue
```
public void setValue(Object key,
                     Object value)
```
    Specified by:
    
    setValue in interface CollectionProxy<Integer,E>
  - remove
```
public E remove(Object key)
```
    Specified by:
    
    remove in interface CollectionProxy<Integer,E>
  - size
```
public int size()
```
    Specified by:
    
    size in interface CollectionProxy<Integer,E>
  - toArray
```
public E[] toArray()
```
    Specified by:
    
    toArray in interface CollectionProxy<Integer,E>
  - toCollection
```
public Collection<E> toCollection(Collection<E> into)
```
    Specified by:
    
    toCollection in interface CollectionProxy<Integer,E>
  - newCollection
```
protected Collection<E> newCollection()
```
  - toMap
```
public Map<Integer,E> toMap(Map<Integer,E> into)
```
    Specified by:
    
    toMap in interface CollectionProxy<Integer,E>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface CollectionProxy<Integer,E>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface CollectionProxy<Integer,E>
  - add
```
public boolean add(E item)
```
    Specified by:
    
    add in interface IntTo<E>
  - addAll
```
public boolean addAll(E... items)
```
    Specified by:
    
    addAll in interface IntTo<E>
  - addAll
```
public boolean addAll(Iterable<E> items)
```
    Specified by:
    
    addAll in interface IntTo<E>
  - insert
```
public boolean insert(int pos,
                      E item)
```
    Specified by:
    
    insert in interface IntTo<E>
  - contains
```
public boolean contains(E value)
```
    Specified by:
    
    contains in interface IntTo<E>
  - at
```
public E at(int index)
```
    Specified by:
    
    at in interface IntTo<E>
  - indexOf
```
public int indexOf(E value)
```
    Specified by:
    
    indexOf in interface IntTo<E>
  - remove
```
public boolean remove(int index)
```
    Specified by:
    
    remove in interface IntTo<E>
  - findRemove
```
public boolean findRemove(E value,
                          boolean all)
```
    Specified by:
    
    findRemove in interface IntTo<E>
  - set
```
public void set(int index,
                E value)
```
    Specified by:
    
    set in interface IntTo<E>
  - push
```
public void push(E value)
```
    Specified by:
    
    push in interface IntTo<E>
  - pop
```
public E pop()
```
    Specified by:
    
    pop in interface IntTo<E>
  - asList
```
public List<E> 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<E>
  - asSet
```
public Set<E> 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<E>
  - asDeque
```
public Deque<E> 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<E>
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class IntToList<E>

Nested Class Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

IntToList

Method Detail

forEach

clone

put

entryFor

get

setValue

remove

size

toArray

toCollection

newCollection

toMap

isEmpty

clear

add

addAll

addAll

insert

contains

at

indexOf

remove

findRemove

set

push

pop

asList

asSet

asDeque

toString