|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object com.levigo.util.base.glazedlists.AbstractEventList<E> com.levigo.util.base.glazedlists.TransformedList<E,E> com.levigo.util.base.glazedlists.SeparatorList<E>
public class SeparatorList<E>
A list that adds separator objects before each group of elements.
SeparatorList is writable, however, attempts to write over separators
will always produce an IllegalArgumentException
. For example,
calling TransformedList.add(int, Object)
, TransformedList.set(int, Object)
or
TransformedList.remove(int)
with a an index that actually corresponds to a
separator in this list will produce an IllegalArgumentException
.
This is because there is no corresponding index for separators in the source
list; separators are added by this SeparatorList. All index-based write
operations must be performed on indexes known to correspond to non-separator
elements.
Warning: this class won't work very well with generics because separators are mixed in, which will be a different class than the other list elements.
Warning: This class is
thread ready but not thread safe. See EventList
for an example
of thread safe code.
Developer Preview this class is still under heavy development and subject to API changes. It's also really slow at the moment and won't scale to lists of size larger than a hundred or so efficiently.
Nested Class Summary | |
---|---|
static interface |
SeparatorList.Separator<E>
A separator heading the elements of a group. |
Field Summary |
---|
Fields inherited from class com.levigo.util.base.glazedlists.TransformedList |
---|
source |
Fields inherited from class com.levigo.util.base.glazedlists.AbstractEventList |
---|
publisher, readWriteLock, updates |
Constructor Summary | |
---|---|
SeparatorList(EventList<E> source,
Comparator<? super E> comparator,
int minimumSizeForSeparator,
int defaultLimit)
Construct a SeparatorList overtop of the source list by
using the given comparator to compute groups of similar
source items. |
Method Summary | |
---|---|
protected int |
getSourceIndex(int mutationIndex)
Gets the index in the source EventList that corresponds to the
specified index. |
protected boolean |
isWritable()
Gets whether the source EventList is writable via this API. |
void |
listChanged(ListEvent<E> listChanges)
When the underlying list changes, this notification allows the object to repaint itself or update itself as necessary. |
void |
setComparator(Comparator<E> comparator)
Set the Comparator used to determine how elements are split
into groups. |
int |
size()
Returns the number of elements in this list. |
Methods inherited from class com.levigo.util.base.glazedlists.TransformedList |
---|
add, addAll, clear, dispose, get, remove, removeAll, retainAll, set |
Methods inherited from class com.levigo.util.base.glazedlists.AbstractEventList |
---|
add, addAll, addListEventListener, contains, containsAll, equals, getPublisher, getReadWriteLock, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, remove, removeListEventListener, subList, toArray, toArray, toString |
Methods inherited from class java.lang.Object |
---|
clone, finalize, getClass, notify, notifyAll, wait, wait, wait |
Constructor Detail |
---|
public SeparatorList(EventList<E> source, Comparator<? super E> comparator, int minimumSizeForSeparator, int defaultLimit)
source
list by
using the given comparator
to compute groups of similar
source items. For each group a single separator will be present in this
SeparatorList provided the group contains at least the
minimumSizeForSeparator
number of items (otherwise they are
left without a separator). In addition this SeparatorList will never
show more than the defaultLimit
number of group elements
from any given group.
source
- the list containing the raw items to be groupedcomparator
- the Comparator which defines the grouping logicminimumSizeForSeparator
- the number of elements which must exist
in a group in order for a separator to be createddefaultLimit
- the maximum number of element to display for a group;
extra elements are truncatedMethod Detail |
---|
public int size()
size
in interface Collection<E>
size
in interface List<E>
size
in class TransformedList<E,E>
protected int getSourceIndex(int mutationIndex)
EventList
that corresponds to the
specified index. More formally, returns the index such that
this.get(i) == source.get(getSourceIndex(i))
for all
legal values of i
.
getSourceIndex
in class TransformedList<E,E>
protected boolean isWritable()
EventList
is writable via this API.
Extending classes must override this method in order to make themselves writable.
isWritable
in class TransformedList<E,E>
public void setComparator(Comparator<E> comparator)
Comparator
used to determine how elements are split
into groups.
Performance Note: sorting will take O(N * Log N)
time.
Warning: This method is
thread ready but not thread safe. See EventList
for an example
of thread safe code.
public void listChanged(ListEvent<E> listChanges)
It is mandatory that the calling thread has obtained the write lock on the source list. This is because the calling thread will have written to the source list to cause this event. This condition guarantees that no writes can occur while the listener is handling this event. It is an error to write to the source list while processing an event.
listChanged
in interface ListEventListener<E>
listChanged
in class TransformedList<E,E>
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |