| AbstractWeakValueMap<K,V> |
Class to provide a map with weak values, backed by a given map
|
| AbstractWeakValueMap.WeakValueRef<K,V> |
A weak value ref that also knows its key in the map.
|
| AbstractWeakValueNavigableMap<K,V> |
Class to provide a navigable, e.g., tree-, map with weak values
|
| AbstractWeakValueNavigableMap.NavigableView<K,V> |
A view of this same map that limits or changes the order of the keys
|
| Algorithms |
Algorithms is a class containing static methods that implement
general algorithms based on objects returned from a data model.
|
| BitTree |
The BitTree class maintains a set of ordered keys between the values of
0 and N.
|
| BooleanArray |
Data structure to set bits to indicate in use.
|
| ByteArray |
Array of bytes that grows as needed.
|
| ByteArrayArray |
Array of byte[] that grows as needed.
|
| CallbackAccumulator<T> |
An implementation of Accumulator that allows clients to easily process items as
they arrive. |
| CaseInsensitiveDuplicateStringComparator |
Comparator for sorting Strings in a case insensitive way except that case insensitive duplicates
are then sub-sorted by reverse case so that lower case is before upper case.
|
| CopyOnReadWeakSet<T> |
|
| Counter |
Simple class used to avoid immutable objects and autoboxing when storing changing integer
primitives in a collection.
|
| DataTable |
Table for managing rows and columns of data.
|
| DoubleArray |
Array of doubles that grows as needed.
|
| DoubleArrayArray |
Array of double[] that grows as needed.
|
| FilteringAccumulatorWrapper<T> |
A class that allows clients to wrap a given accumulator, only adding elements that pass the
given filter.
|
| FixedSizeHashMap<K,V> |
A simple implementation of a LRU map that will throw away entries that exceed the given
maximum size.
|
| FixedSizeStack<E> |
Creates a fixed size stack.
|
| FloatArray |
Array of floats that grows as needed.
|
| FloatArrayArray |
Array of float[] that grows as needed.
|
| FullKeySet |
Implementation of the ShortKeySet interface that always contains
all the possible keys.
|
| IndexRange |
Class for holding a begin and end index.
|
| IntArray |
Array of ints that grows as needed.
|
| IntArrayArray |
Array of int[] that grows as needed.
|
| IntArrayList |
An ArrayList type object for ints.
|
| IntIndexManager |
Class to generate int indexes to be used for arrays or tables.
|
| IntIntHashtable |
Class that implements a hashtable with int keys and int values.
|
| IntKeyIndexer |
This class converts arbitrary int keys into compacted int indexes suitable
for use as indexes into an array or table.
|
| IntListIndexer |
Class to manage multiple linked lists of int indexes.
|
| IntObjectHashtable<T> |
Class that implements a hashtable with int keys and Object values.
|
| IntSet |
Class for storing a set of integers
|
| ListAccumulator<T> |
|
| LongArray |
Array of longs that grows as needed.
|
| LongArrayArray |
Array of long[] that grows as needed.
|
| LongArrayList |
An ArrayList for longs.
|
| LongDoubleHashtable |
Class that implements a hashtable with long keys and double values.
|
| LongIntHashtable |
Class that implements a hashtable with long keys and int values.
|
| LongKeyIndexer |
This class converts arbitrary long keys into compacted int indexes suitable
for use as indexes into an array or table.
|
| LongLongHashtable |
Class that implements a hashtable with long keys and long values.
|
| LongObjectHashtable<T> |
Class that implements a hashtable with long keys and Object values.
|
| LRUMap<K,V> |
A LRU (Least Recently Used) map that maintains access-order (newest to oldest)
iteration over the elements.
|
| LRUSet<T> |
An ordered set-like data structure.
|
| ManagedDataTable |
Data table that keeps track of rows that are occupied.
|
| ObjectArray |
Array of objects that grows as needed.
|
| ObjectCache |
ObjectClass provides a fixed-size long-key-based object cache.
|
| ObjectIntHashtable<T> |
Class that implements a hashtable with Object keys and int values.
|
| ObjectKeyIndexer<T> |
This class converts arbitrary Objects into compacted int indexes suitable
for use as indexes into an array or table.
|
| ObjectLongHashtable<T> |
Class that implements a hashtable with Object keys and long values.
|
| ObjectRangeMap<T> |
Associates objects with long index ranges.
|
| ObjectValueRange<T> |
Associates an integer value with a numeric range.
|
| Prime |
Class that provides a static nextPrime method that gives out prime numbers
that are useful in a buffer doubling strategy with all buffer sizes being prime.
|
| PriorityQueue<T> |
Maintains a list of objects in priority order where priority is just
an integer value.
|
| PropertySetIndexRangeIterator |
Iterator over Property Set Index ranges that have the same value
|
| QueueStub<E> |
A do-nothing, stubbed version of the Queue interface.
|
| Range |
A class for holding a minimum and maximum signed int values that define a range.
|
| RangeMap |
Stores ranges of int values throughout "long" space.
|
| RedBlackEntry<K,V> |
|
| RedBlackKeySet |
A RedBlack Tree implementation of the ShortKeySet interface.
|
| RedBlackLongKeySet |
A RedBlack Tree implementation of a long key set.
|
| RedBlackTree<K extends java.lang.Comparable<K>,V> |
A RedBlack Tree implementation with K type keys and place to store V type values.
|
| SetAccumulator<T> |
|
| ShortArray |
Array of shorts that grows as needed.
|
| ShortArrayArray |
Array of byte[] that grows as needed.
|
| ShortKeyIndexer |
This class converts arbitrary short keys into compacted short indexes suitable
for use as indexes into an array or table.
|
| ShortListIndexer |
Class to manage multiple linked lists of short indexes.
|
| ShortLongHashtable |
Class that implements a hashtable with Short keys and long values.
|
| ShortObjectHashtable |
Class that implements a hashtable with short keys and Object values.
|
| ShortRangeMap |
Stores ranges of short values throughout "long" space.
|
| ShortStringHashtable |
Class that implements a hashtable with short keys and String values.
|
| SizeLimitedAccumulatorWrapper<T> |
|
| SoftCacheMap<K,V> |
Class to manage a "soft" HaspMap that keeps its keys as soft references so
they can be reclaimed if needed.
|
| SortedRangeList |
Provides a list of integer ranges that are maintained in sorted order.
|
| Stack<E> |
The Stack class represents a last-in-first-out (LIFO) stack of objects.
|
| StringArray |
Array of Strings that grows as needed.
|
| StringArrayArray |
Array of String[] that grows as needed.
|
| StringIntHashtable |
Class that implements a hashtable with String keys and int values.
|
| StringKeyIndexer |
This class converts arbitrary Strings into compacted int indexes suitable
for use as indexes into an array or table.
|
| SynchronizedListAccumulator<T> |
|
| ValueRange |
Associates an integer value with a numeric range.
|
| WeakDataStructureFactory |
Factory for creating containers to use in various threading environments
|
| WeakSet<T> |
|
| WeakValueHashMap<K,V> |
Class to provide a hash map with weak values.
|
| WeakValueTreeMap<K,V> |
Class to provide a tree map with weak values.
|