| 
 | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
java.lang.Objectgroovy.lang.ListWithDefault<T>
public final class ListWithDefault<T>
A wrapper for List which automatically grows the list when either get(int) or
 getAt(int) is called with an index greater than or equal to size().
| Method Summary | ||
|---|---|---|
|  void | add(int i,
    T t) | |
|  boolean | add(T t) | |
|  boolean | addAll(Collection<? extends T> ts) | |
|  boolean | addAll(int i,
       Collection<? extends T> ts) | |
|  void | clear() | |
|  boolean | contains(Object o) | |
|  boolean | containsAll(Collection<?> objects) | |
|  boolean | equals(Object obj) | |
|  T | get(int index)Returns the element at the given index but grows the list if needed. | |
|  T | getAt(int index)Overwrites subscript operator handling by redirecting to get(int). | |
|  int | hashCode() | |
|  int | indexOf(Object o) | |
|  boolean | isEmpty() | |
|  Iterator<T> | iterator() | |
|  int | lastIndexOf(Object o) | |
|  ListIterator<T> | listIterator() | |
|  ListIterator<T> | listIterator(int i) | |
| static
 | newInstance(List<T> items,
            boolean lazyDefaultValues,
            Closure initClosure) | |
|  T | remove(int i) | |
|  boolean | remove(Object o) | |
|  boolean | removeAll(Collection<?> objects) | |
|  boolean | retainAll(Collection<?> objects) | |
|  T | set(int i,
    T t) | |
|  int | size() | |
|  List<T> | subList(int fromIndex,
        int toIndex)Returns a view of a portion of this list. | |
|  Object[] | toArray() | |
| 
 | toArray(T[] ts) | |
| Methods inherited from class java.lang.Object | 
|---|
| clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait | 
| Method Detail | 
|---|
public static <T> List<T> newInstance(List<T> items,
                                      boolean lazyDefaultValues,
                                      Closure initClosure)
public int size()
size in interface Collection<T>size in interface List<T>public boolean isEmpty()
isEmpty in interface Collection<T>isEmpty in interface List<T>public boolean contains(Object o)
contains in interface Collection<T>contains in interface List<T>public Iterator<T> iterator()
iterator in interface Iterable<T>iterator in interface Collection<T>iterator in interface List<T>public Object[] toArray()
toArray in interface Collection<T>toArray in interface List<T>public <T> T[] toArray(T[] ts)
toArray in interface Collection<T>toArray in interface List<T>public boolean add(T t)
add in interface Collection<T>add in interface List<T>public boolean remove(Object o)
remove in interface Collection<T>remove in interface List<T>public boolean containsAll(Collection<?> objects)
containsAll in interface Collection<T>containsAll in interface List<T>public boolean addAll(Collection<? extends T> ts)
addAll in interface Collection<T>addAll in interface List<T>
public boolean addAll(int i,
                      Collection<? extends T> ts)
addAll in interface List<T>public boolean removeAll(Collection<?> objects)
removeAll in interface Collection<T>removeAll in interface List<T>public boolean retainAll(Collection<?> objects)
retainAll in interface Collection<T>retainAll in interface List<T>public void clear()
clear in interface Collection<T>clear in interface List<T>public T getAt(int index)
get(int).
index - an index (might be greater or equal to size(), or smaller than 0)
index or the default valuepublic T get(int index)
index is
 greater than or equal to size(), the list will grow to the new size and a default value calculated
 using the initClosure will be used to populate the missing value and returned.
 
 If lazyDefaultValues is true any gaps when growing the list are filled
 with nulls. Subsequent attempts to retrieve items from the list from those gap index values
 will, upon finding null, call the initClosure to populate the list for the
 given list value. Hence, when in this mode, nulls cannot be stored in this list.
 If lazyDefaultValues is false any gaps when growing the list are filled
 eagerly by calling the initClosure for all gap indexes during list growth.
 No calls to initClosure are made except during list growth and it is ok to
 store null values in the list when in this mode.
 
 This implementation breaks
 the contract of List.get(int) as it a) possibly modifies the underlying list and b) does
 NOT throw an IndexOutOfBoundsException when index < 0 || index >= size().
get in interface List<T>index - an index (might be greater or equal to size(), or smaller than 0)
index or the default value
public T set(int i,
             T t)
set in interface List<T>
public void add(int i,
                T t)
add in interface List<T>public T remove(int i)
remove in interface List<T>public int indexOf(Object o)
indexOf in interface List<T>public int lastIndexOf(Object o)
lastIndexOf in interface List<T>public ListIterator<T> listIterator()
listIterator in interface List<T>public ListIterator<T> listIterator(int i)
listIterator in interface List<T>public boolean equals(Object obj)
equals in interface Collection<T>equals in interface List<T>equals in class Objectpublic int hashCode()
hashCode in interface Collection<T>hashCode in interface List<T>hashCode in class Object
public List<T> subList(int fromIndex,
                       int toIndex)
subList in interface List<T>fromIndex - low endpoint of the subList (inclusive)toIndex - upper endpoint of the subList (exclusive)
| 
 | Copyright © 2003-2012 The Codehaus. All rights reserved. | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||