|
Class Summary |
| Aggregator<W,V> |
|
| Aggregator.Collector<X> |
|
| AndPredicate<T> |
Implements a boolean and of the contained set of predicates |
| ArgumentParser |
Provide a cleaner way of handling arguments to
public static void main (String args[]). |
| Arithmetic |
Arithmetic is an abstract class that encapsulates the idea of doing simple
arithmetic operations on instances of the sub-types of
java.lang.Number. |
| Arithmetic.Operation |
Enumeration class capturing binary operations on instances of
java.lang.Number. |
| ArithmeticOperations |
|
| ArithmeticUtil |
|
| ArrayUtil |
Array Utilities. |
| Assert |
This class defines and implements various Assert methods |
| Asynchronous |
Dummy type for RPC's that are asynchronizes and have a void return type. |
| Base64 |
Base64. |
| BatchMapProcessor |
Convenience class that abstracts the notion of processing a map of
objects in batches. |
| BatchProcessor |
Convenience class that abstracts the notion of
processing a collection of objects in chunks of a given size. |
| BatchSizer |
Is a class that defines how a stream of objects should be batched. |
| BatchSizer.Fixed |
Is a batch sizer that uses a simple fixed batch size. |
| BooleanArray |
A DynamicArray of Booleans |
| BufferPool<T extends Buffer> |
This abstract self cleaning pool of Buffer instances can be extended by subclasses
for specific types of Buffers, for example CharBuffer and ByteBuffer. |
| ByteBufferPool |
This class implements a self cleaning pool of ByteBuffers, each wrapped around a byte
array of the configured buffer length. |
| CharBufferPool |
This class implements a self cleaning pool of CharBuffers, each wrapped around a char
array of the configured buffer length. |
| ChecksumManager |
Service that manages ComponentChecksums. |
| Chrono |
Simple timing class, used for timing one or more trials of an event. |
| ChronoWithMemory |
Chrono subclass which displayed more information when being printed. |
| ClassExtension |
The ClassExtension class is the abstract superclass for all ClassExtension subclasses. |
| ClassExtensionRegistry |
The ClassExtensionRegistry class provides a convenient and
consistent way to cache ClassExtension subclasses. |
| ClassUtil |
ClassUtil. |
| ComponentChecksum |
The abstract class to support checking the that
the runtime configuration of components are consistent
within a cluster. |
| CompositePredicate<T> |
|
| ConsistentHashRing<T> |
The Consistent Hash Ring is a data structure that is used to
load balance resources across several server nodes. |
| ConsistentHashRing.MD5HashFunction |
A MD5 hash function which is a good alternative for uniform hashing. |
| Constants |
Constants for well known values |
| Crypt |
Crypt |
| Crypto |
Disclaimer. |
| DatabaseBaseId |
This is a stripped down BaseId, for use in tools
(such as migration) below the level of ObjectServer. |
| Date |
The Date class implements helper functions on top of
the java.util.Date class. |
| DateUtil |
|
| DefaultRejectedExecutionHandler |
|
| DefaultThreadManager |
Default implementation that doesn't do anything. |
| Deque |
This class implements a double-ended queue (pronounced like
"deck"). |
| DoubleArray |
A DynamicArray of Doubles |
| DynamicArray |
A DynamicArray is like List except that is exposes the underlying
array. |
| EncodingMap |
|
| EqHashtable |
This class extends Hashtable, but provides for pointer hashing and
equality instead of hashCode() and equals() equality. |
| EqLRUHashtable |
This class extends LRUHashtable, but provides for pointer hashing and
equality instead of hashCode() and equals() equality. |
| EventLoop |
A simple event loop |
| EventQueue |
A simple queue of events that can be added to and waited on by
multiple threads |
| Factory<T> |
Convenience generic factory class. |
| FastStringBuffer |
Object subclass resembling the java.lang.StringBuffer class (an object that
manages a mutable string). |
| Feature<T> |
Represents a feature or capability in the system and can answer the
question of whether the feature is enabled in an instance of a given
context, which is specified by the generic T parameter. |
| FeatureConfig<T> |
Different products will fetch configuration in various ways: file, DB, etc. |
| FeatureSet<T> |
A feature set groups a set of features (Feature) by name. |
| FileArray |
A DynamicArray of Files |
| FileCompare |
An implementation of Compare for Files |
| FileComponentChecksum |
This class extends the ComponentChecksum class to compute a
checksum for files and directories. |
| FileOutputStreamHolder |
|
| FileReplacer |
Utility class that supports replacing a given base file
with a new file (typically, a new version of that file.)
There is support for obtaining an OutputStream
to write a changed version of the file, applying the
changes, then reverting the changes (you can apply
and revert changes as many times as desired) before finally
committing either the applied or reverted changes
(dropping the files used for temporary storage.)
The temporary files are stored in the same directory as the base file. |
| FileUtil |
File Utilities. |
| Fmt |
Formatted output. |
| FormatBuffer |
A version of a FastStringBuffer that is able to append some basic
java types directly without having to use intermediate
strings. |
| Function<K> |
Generic class that represents a function returning a type K. |
| Function.MethodFunction<T> |
Convenience nested class that adapts a Method into a
Function |
| GlobalLocking |
Finder class for the GlobalLockingService |
| GlobalLockUtil |
A helper class for acquiring and releasing global lock |
| GlobalState |
|
| Gridtable |
A two-dimensional map. |
| GrowOnlyGridTable |
A two-dimensional GrowOnlyHashtable. |
| GrowOnlyHashSet |
A GrowOnlyHashSet built on top of a GrowOnlyHashTable. |
| GrowOnlyHashtable<K,V> |
A version of Hashtable that... |
| GrowOnlyHashtable.IdentityMap<K,V> |
|
| GZipUtil |
Utility class to perform gzip on strings, byte arrays, etc. |
| Hashtable |
A Hashtable class that has a number of performance improvements
over other Hashtable classes. |
| HeapTimerQueue |
An implementation of a TimerQueue that stores the Timers in a PriorityQueue. |
| Holder<V> |
Convenience class that makes it a little simpler to write a lazily evalated
value. |
| HTML |
Some HTML helpers |
| HTTP |
HTTP. |
| IntCompanionSort |
provides functions for sorting arrays of objects, with integer companion arrays |
| IntegerArray |
A DynamicArray of Integers |
| IntegerCompare |
|
| InternCharToString |
This class implements an instance of a GrowOnlyHashtable with the
following properties:
-- implements a version of intern() that does not have the small
size limitations of the native intern() methods on at least hp and
nt. |
| IOUtil |
Input/Output Utilities. |
| IOUtil.BufferHolder |
Holds a byte buffer for use in this class while copying bytes around. |
| IteratorUnion |
An enumeration that is the union of a list of enumerations. |
| JavaThreadFactory |
A ThreadFactory for plain Java Threads |
| LinearLRUHashtable |
Provides an LRUHashtable that uses linear growth (the LRUHashtable class
uses exponential growth). |
| Link |
Link implements a fairly textbook "link" suitable for use
in a doubly linked list. |
| LinkableList |
LinkableList implements a fairly straightforward doubly linked
list. |
| LinkedList |
This class implements a basic doublely linked list. |
| LinkedTimerQueue |
A TimerQueue implemented using a linked list of Timers. |
| LinkPayload |
LinkPayload is a simply wrapper around Link that
includes a payload reference. |
| ListUtil |
List Utilities. |
| ListUtil.Comparator<T extends List<?>> |
Is a java.util.Comparator for Lists based on
a supplied elementComparator that delegates to
ListUtil.compare(java.util.List, java.util.List, java.util.Comparator) when doing the comparison. |
| LockHandler |
|
| LockHandlerContext |
|
| LockManager |
|
| LRUEntry |
An entry in LRUHashtable. |
| LRUHashtable |
A hashtable that tracks the age of entries. |
| MapArray |
A DynamicArray of Maps |
| MapBasedSet |
A generic implementation of the Set built on top of a Map. |
| MapUtil |
Map Utilities. |
| MasterPasswordClient |
Manages master password. |
| MathUtil |
Math Utilities. |
| MaxEncodedString |
|
| MemoryOptimizedMap<K,V> |
This is a map implementation that is very memory efficient for very small maps. |
| MemoryStats |
Simple class that captures the current memory situation. |
| MessageDigestUtil |
A utility class for generating message digests, suitable for
password hashing. |
| MIME |
MIME. |
| MimeEncoding |
This class is generated by Add Language Tool. |
| ModifiableInteger |
This is a handy class to use in cases where Integer needs to be part of a
Collection object, yet needs to be modified very frequently. |
| ModMofNPredicate<T> |
Implements a predicate on the mod of some hash function of T. |
| MultiKeyHashtable |
A MultiKeyHashtable class that allows for multiple keys per entry. |
| MultiValueHashtable |
A map like class that can store multiple values for the
keys. |
| NamedList |
|
| NamedValue |
Simple class to store a simple pair name/value |
| NoCrypto |
Disclaimer. |
| NonCachingClassLoader |
Implementation of a ClassLoader that can be used to force
reloading of class files from the file system. |
| NotPredicate<T> |
Implements a boolean not of the contained predicate. |
| ObjectArray |
A DynamicArray of Objects
No array() needed because the underlying array is the same type |
| ObjectLockManager |
This class maintains a set of objects that can be exclusively
locked. |
| ObjectUtil |
This is a class of static methods useful for Objects in general. |
| OptimizingGridtable |
|
| OrderedHashtable |
An OrderedHashtable is just like a normal Hashtable except that it
remembers the order the keys were added to the table and, whenever keys()
or elements() is called, they are returned in that order. |
| OrPredicate<T> |
Implements a boolean or of the contained set of predicates |
| Parameters |
Interface to access easily configuration parameters |
| PerformanceCheck |
PerformanceCheck defines a set of expected performance boundaries for task
execution. |
| PerformanceChecker |
Object used by the PerformanceCheck to check a specific
metric (or PerformanceStateCore). |
| PerformanceState |
This class maintains performance state for the current thread. |
| PerformanceState.Stats |
|
| PerformanceStateCore |
This class is the root for performance counters. |
| PerformanceStateCore.EventDetail |
|
| PerformanceStateCore.Instance |
the real data bearing instance |
| PerformanceStateCounter |
A thread specific counter. |
| PerformanceStateCounter.Instance |
the real instance |
| PerformanceStateCPUTimedCounter |
A performance counter for thread CPU time. |
| PerformanceStateCPUTimedCounter.Instance |
|
| PerformanceStateTimedCounter |
|
| PerformanceStateTimedCounter.Instance |
the real instance |
| PermutationIterator |
A PermutationIterator produces a series of permutations of the
requested size from a source array of objects. |
| Pool |
Generic resource pooling mechanism |
| Predicate<T> |
|
| Predicate.Constant<T> |
|
| ProgressMonitor |
This class stores the user-visible progress information for the current
thread so that it can be queried / reflected by a progress panel in the UI. |
| PropertyGetter<T,P> |
|
| PropertyHasher<T> |
|
| PropertyTable |
PropertyTable is an extension of a Map
which provides additional convenience methods and some minor semantic
changes. |
| QuickTableDiff |
Simple command line tool to diff to table files. |
| ReadOnlyMap<K,V> |
A Map-like object that can't be modified - not because it is immutable
(which would raise a run-time exception), but because it has no API
for modifying it. |
| ReferenceHandler |
Handles paramaters via indirect references. |
| ReferenceSyntaxParser |
This class provides methods to parse Strings that may contain
remote and/or local references. |
| RegexFunction |
|
| ResourceService |
The fundamental API to resolving localized resources. |
| SecurityHelper |
Very poor stop-gap measure to prevent bogus access to some vital stuff. |
| SelfCleaningPool<T> |
Generic resource pooling mechanism, that uses Timer to return allocated storage to be
garbage collected when it is no longer needed for current usage patterns. |
| SelfCleaningPool.PoolFloat<T> |
Nested class that wraps up an actual resource instance. |
| ServerUtil |
|
| SetUtil |
Set Utilities. |
| SignalHandler |
Wrapper around the sun.misc.SignalHandler to avoid having the rest
of the application to depend on this undocumented class and as such
can be changed in any Java release. |
| SimpleComponentChecksum |
A simple implementation of ComponentChecksum that saves
a stored byte array. |
| Sort |
Sort provides functions for sorting arrays of objects. |
| SparseVector |
Object subclass that manages an array of objects. |
| StateFactory |
|
| StringArray |
A DynamicArray of Strings |
| StringCompare |
An implementation of Compare for Strings |
| StringCompareIgnoreCase |
An case insensitve implementation of Compare for Strings |
| StringUtil |
String Utilities. |
| StringUtil.SearchResult |
Small struct class that captures the result of search for a string
within some other unidentified string or stream. |
| SubsetIterator |
A SubsetIterator produces a series of subsets of the requested size
from a source array of objects. |
| SystemUtil |
System Utilities. |
| SystemUtil.ValidCaller |
A simple bean to hold the attributes of a valid caller for use by validateCaller
method. |
| TableUtil |
Table file Utilities. |
| ThreadDebugKey |
A key to use with ThreadDebugState. |
| ThreadDebugState |
This class maintains debug state for the current thread. |
| ThreadDebugState.StateMap |
|
| ThreadedQueue |
This is a ThreadedQueue used for a producer/consumer model of
threads. |
| ThreadGroupLocalState |
|
| ThreadLocalHolder<V> |
|
| ThreadManager.NoOp |
Ultra simple implementation: all methods are no-op |
| ThreadNameAbbreviation |
Maintain short names for threads. |
| ThreadPool |
Standard non-extensible thread pool implememtation on top of
queue. |
| ThreadPoolRejectedExecutionHandler |
A concrete implementation of RejectedExecutionHandler for ThreadPools. |
| Timer |
Object subclass that causes an action to occur at a predefined
rate. |
| TimerQueue |
Private class to manage a queue of Timers. |
| TokenTable |
A table of tokens that map to objects. |
| TreeIterable<T> |
|
| URLUtil |
URL Utilities. |
| Vector |
Object subclass that manages an array of objects. |
| Version |
This class provides access to build version information. |
| VersionComponentChecksum |
Component checksum for the application version. |
| WhiteListPredicate<T,P> |
Implements a predicate for checking whether a property on T (fetched via
property getter) is contained in the white-list |
| WriteResistantMap<K,V> |
Similar to a ReadOnlyMap, but with a method getMap enabling
the caller to get direct access to the underlying Map, which may then
be modified. |