org.magicwerk.brownies.collections (Brownies-Collections 0.9.23 API)

Interface Summary
Interface	Description
ICollection<E>	IList is an abstract class which offers all interfaces offered by both ArrayList and LinkedList.
ICollectionTools	ICollectionTools offers default implementations of Collection functionality.
IListable<E>	Interface `IListable` offers a minimalist interface for accessing a list or an array.

Class Summary
Class	Description
BigList<E>	BigList is a list optimized for storing large number of elements.
BigList.ReadOnlyBigList<E>	A read-only version of `Key1List`.
CollectionAsSet<K>	Implements a Set based on a Collection.
GapList<E>	Class {link GapList} combines the strengths of both `ArrayList` and `LinkedList`.
GapList.ReadOnlyList<E>	A read-only version of `GapList`.
IList<E>	Class `IList` is the abstract class which offers all interfaces implemented by ArrayList.
IList.IListableFromArray<E>	Wrapper to treat an array as `IListable`.
IList.IListableFromCollection<E>	Wrapper to treat a `Collection` as `IListable`.
IList.IListableFromList<E>	Wrapper to treat a `List` as `IListable`.
IList.IListableFromMult<E>	Wrapper to treat a repeated element as `IListable`.
IListAsDeque<E>	Class `IListAsDeque` implements a `Deque` based on a `IList`.
ImmutableMapEntry<K,E>	Read-only implementation of Map.Entry.
Key1Collection<E,K>	Key1Collection implements a collection with 1 key.
Key1Collection.Builder<E,K>	Builder to construct Key1Collection instances.
Key1List<E,K>	Key1List implements a key list with 1 key.
Key1List.Builder<E,K>	Builder to construct Key1List instances.
Key1List.ReadOnlyKey1List<E,K>	A read-only version of `Key1List`.
Key1Set<E,K>	Key1Set implements a set.
Key1Set.Builder<E,K>	Builder to construct Key1Set instances.
Key2Collection<E,K1,K2>	Key2Collection implements a collection with 2 keys.
Key2Collection.Builder<E,K1,K2>	Builder to construct Key2Collection instances.
Key2List<E,K1,K2>	Key2List implements a key list with 2 keys.
Key2List.Builder<E,K1,K2>	Builder to construct Key2List instances.
Key2List.ReadOnlyKey2List<E,K1,K2>	A read-only version of `Key2List`.
Key2Set<E,K1,K2>	Key2Set implements a set.
Key2Set.Builder<E,K1,K2>	Builder to construct Key2Set instances.
KeyCollection<E>	KeyCollection implements a collection.
KeyCollection.Builder<E>	Builder to construct KeyCollection instances.
KeyCollectionAsMap<K,E>	Implements a Map based on a key map in a KeyCollection or KeyList.
KeyCollectionAsSet<E>	Implements a Set based on a Collection.
KeyCollectionImpl<E>	Add: - validation fails: null / constraint - duplicate not allowed (mode replace) Triggers: - triggers are called after the add/remove operation has finished - if an exception is thrown in the trigger, the change already made to the collection is not undone
KeyCollectionImpl.BuilderImpl<E>	Implementation of builder.
KeyCollectionImpl.BuilderImpl.KeyMapBuilder<E,K>
KeyList<E>	KeyList implements a list.
KeyList.Builder<E>	Builder to construct KeyList instances.
KeyList.ImmutableKeyList<E>	A read-only version of `KeyList`.
KeyListImpl<E>	A KeyList add key handling features to GapList.
KeySet<E>	KeySet implements a set.
KeySet.Builder<E>	Builder to construct KeySet instances.
Listables	Class `Listables` contains implementations of the `IListable` interface for `List`s and arrays.
Listables.IListableArray<E>	Class `Listables.IListableArray` implements the `IListable` interface for arrays.
Listables.IListableList<E>	Class `Listables.IListableList` implements the `IListable` interface for `List`s.

Package org.magicwerk.brownies.collections Description

Brownies Collections complements the Java Collections Framework.

GapList combines the strengths of both ArrayList and LinkedList. It is implemented to offer both efficient random access to elements by index (as ArrayList does) and at the same time efficient adding and removing elements to and from beginning and end (as LinkedList does). It also exploits the locality of reference often seen in applications to further improve performance, e.g. for iterating over the list.
BigList is a list optimized for storing large number of elements. It stores the elements in fixed size blocks so for adding and removing only few elements must be moved. Blocks are split or merged as needed and maintained in a tree for fast access. Copying a BigList is very efficient as it is implemented using a copy-on-write approach.
Both GapList and BigList have been designed to be used as drop-in replacement for ArrayList, LinkedList or ArrayDequeu by offering all their methods. Additionally many more helpful methods are available provided by the common abstract class IList.
There are specialized List implementations for all primitive data types. As the storage is realized using arrays of primitives, memory is saved and execution speed increased. These classes are named IntGapList/IntBigList, LongGapList/LongBigList, etc.
For each primitive list class like IntGapList there is also wrapper which allows you to access the primitive data through the standard List interface. With this approach you can save memory and continue to use the code working with lists. These classes are named IntObjGapList/IntObjBigList, LongObjGapList/LongObjBigList, etc.
To increase developer productivity, keys and constraints have been added to collections in an orthogonal and declarative way. These features offered by classes implementing the Collection (classes KeyCollection, Key1Collection, Key2Collection) and the List interface (classes KeyList, Key1List, Key2List).