public abstract class FastCollection<E> extends java.lang.Object implements java.util.Collection<E>, java.lang.Iterable<E>, XMLSerializable, java.io.Serializable, Realtime
This class represents collections which can quickly be iterated over
(forward or backward) and which an be made thread-safe
and/or unmodifiable.
Fast collections can be iterated over without creating new objects
and without using iterators .
public boolean search(Object item, FastCollection c) {
for (Record r = c.head(), end = c.tail(); (r = r.getNext()) != end;) {
if (item.equals(c.valueOf(r))) return true;
}
return false;
}
Fast collections are thread-safe when marked shared
(can be read, iterated over or modified concurrently).
public class Foo {
private static final Collection<Foo> INSTANCES = new FastTable().shared();
public Foo() {
INSTANCES.add(this);
}
public static void showInstances() {
for (Foo foo : INSTANCES) { // Iterations are thread-safe even if new Foo instances are added.
System.out.println(foo);
}
}
}
Users may provide a read-only view of any FastCollection
instance using the unmodifiable() method (the view is
thread-safe if the collection is shared).
class Foo {
private static final FastTable<Foo> INSTANCES = new FastTable().shared();
Foo() {
INSTANCES.add(this);
}
public static Collection<Foo> getInstances() {
return INSTANCES.unmodifiable(); // Returns a public unmodifiable view over the shared collection.
}
}
Finally, FastCollection may use custom comparators for element equality or ordering if the collection is
ordered (e.g. FastTree).
| Modifier and Type | Class and Description |
|---|---|
static interface |
FastCollection.Record
This interface represents the collection records which can directly be
iterated over.
|
| Modifier | Constructor and Description |
|---|---|
protected |
FastCollection()
Default constructor.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
add(E o)
Appends the specified value to the end of this collection
(optional operation).
|
boolean |
addAll(java.util.Collection<? extends E> c)
Appends all of the values in the specified collection to the end of
this collection, in the order that they are returned by the specified
collection's iterator.
|
void |
clear()
Removes all of the values from this collection (optional operation).
|
boolean |
contains(java.lang.Object o)
Indicates if this collection contains the specified value.
|
boolean |
containsAll(java.util.Collection<?> c)
Indicates if this collection contains all of the values of the
specified collection.
|
abstract void |
delete(FastCollection.Record record)
Deletes the specified record from this collection.
|
boolean |
equals(java.lang.Object obj)
Compares the specified object with this collection for equality.
|
FastComparator<? super E> |
getValueComparator()
Returns the value comparator for this collection (default
FastComparator.DEFAULT). |
int |
hashCode()
Returns the hash code for this collection.
|
abstract FastCollection.Record |
head()
Returns the head record of this collection; it is the record such as
head().getNext() holds the first collection value. |
boolean |
isEmpty()
Indicates if this collection is empty.
|
java.util.Iterator<E> |
iterator()
Returns an iterator over the elements in this collection
(allocated on the stack when executed in a
StackContext). |
boolean |
remove(java.lang.Object o)
Removes the first occurrence in this collection of the specified value
(optional operation).
|
boolean |
removeAll(java.util.Collection<?> c)
Removes from this collection all the values that are contained in the
specified collection.
|
boolean |
retainAll(java.util.Collection<?> c)
Retains only the values in this collection that are contained in the
specified collection.
|
java.util.Collection<E> |
shared()
Returns a thread-safe read-write view of this collection.
|
abstract int |
size()
Returns the number of values in this collection.
|
abstract FastCollection.Record |
tail()
Returns the tail record of this collection; it is the record such as
tail().getPrevious() holds the last collection value. |
java.lang.Object[] |
toArray()
Returns a new array allocated on the heap containing all of the values
in this collection in proper sequence.
|
<T> T[] |
toArray(T[] array)
Fills the specified array with the values of this collection in
the proper sequence.
|
java.lang.String |
toString()
Returns the
String representation of this
FastCollection. |
Text |
toText()
Returns the textual representation of this collection.
|
java.util.Collection<E> |
unmodifiable()
Returns the unmodifiable view associated to this collection.
|
abstract E |
valueOf(FastCollection.Record record)
Returns the collection value for the specified record.
|
public abstract int size()
size in interface java.util.Collection<E>public abstract FastCollection.Record head()
head().getNext() holds the first collection value.public abstract FastCollection.Record tail()
tail().getPrevious() holds the last collection value.public abstract E valueOf(FastCollection.Record record)
record - the record whose current value is returned.public abstract void delete(FastCollection.Record record)
Implementation must ensure that removing a record from the collection does not affect in any way the records preceding the record being removed (it might affect the next records though, e.g. in a list collection, the indices of the subsequent records will change).
record - the record to be removed.java.lang.UnsupportedOperationException - if not supported.public java.util.Collection<E> unmodifiable()
UnsupportedOperationException being thrown.public java.util.Collection<E> shared()
Returns a thread-safe read-write view of this collection.
The default implementation performs synchronization on read and write. Sub-classes may provide more efficient implementation (e.g. only synchronizing on writes modifying the internal data structure).
Having a shared collection does not mean that modifications made by onethread are automatically viewed by others thread. Which in practice is not an issue. In a well-behaved system, threads need to synchronize only at predetermined synchronization points (the fewer the better).
public java.util.Iterator<E> iterator()
StackContext).public FastComparator<? super E> getValueComparator()
FastComparator.DEFAULT).public boolean add(E o)
Note: This default implementation always throws
UnsupportedOperationException.
add in interface java.util.Collection<E>o - the value to be appended to this collection.true (as per the general contract of the
Collection.add method).java.lang.UnsupportedOperationException - if not supported.public boolean remove(java.lang.Object o)
remove in interface java.util.Collection<E>o - the value to be removed from this collection.true if this collection contained the specified
value; false otherwise.java.lang.UnsupportedOperationException - if not supported.public void clear()
clear in interface java.util.Collection<E>java.lang.UnsupportedOperationException - if not supported.public boolean isEmpty()
isEmpty in interface java.util.Collection<E>true if this collection contains no value;
false otherwise.public boolean contains(java.lang.Object o)
contains in interface java.util.Collection<E>o - the value whose presence in this collection
is to be tested.true if this collection contains the specified
value;false otherwise.public boolean addAll(java.util.Collection<? extends E> c)
addAll in interface java.util.Collection<E>c - collection whose values are to be added to this collection.true if this collection changed as a result of
the call; false otherwise.public boolean containsAll(java.util.Collection<?> c)
containsAll in interface java.util.Collection<E>c - collection to be checked for containment in this collection.true if this collection contains all of the values
of the specified collection; false otherwise.public boolean removeAll(java.util.Collection<?> c)
removeAll in interface java.util.Collection<E>c - collection that defines which values will be removed from
this collection.true if this collection changed as a result of
the call; false otherwise.public boolean retainAll(java.util.Collection<?> c)
retainAll in interface java.util.Collection<E>c - collection that defines which values this set will retain.true if this collection changed as a result of
the call; false otherwise.public java.lang.Object[] toArray()
Note: To avoid heap allocation toArray(Object[]) is
recommended.
toArray in interface java.util.Collection<E>toArray(new Object[size()])public <T> T[] toArray(T[] array)
Note: Unlike standard Collection, this method does not try to resize the array using reflection (which might not be supported) if the array is too small. UnsupportedOperationException is raised if the specified array is too small for this collection.
toArray in interface java.util.Collection<E>array - the array into which the values of this collection
are to be stored.java.lang.UnsupportedOperationException - if array.length < size()public Text toText()
public java.lang.String toString()
String representation of this
FastCollection.toString in class java.lang.ObjecttoText().toString()public boolean equals(java.lang.Object obj)
List instances).
Equality comparisons are performed using this collection
value comparator.equals in interface java.util.Collection<E>equals in class java.lang.Objectobj - the object to be compared for equality with this collectiontrue if the specified object is a collection with
the same content and iteration order when necessary;
false otherwise.public int hashCode()
hashCode in interface java.util.Collection<E>hashCode in class java.lang.ObjectCopyright © 2005 - 2007 Javolution.