All Classes and Interfaces
Class
Description
Base class for immutable byte[]-backed String replacements.
A ring buffer which aggregates its contents according to a user-defined aggregation function.
A ring buffer which aggregates its contents according to a user-defined aggregation function.
A ring buffer which aggregates its contents according to a user-defined aggregation function.
A ring buffer which aggregates its contents according to a user-defined aggregation function.
A ring buffer which aggregates its contents according to a user-defined aggregation function.
A ring buffer which aggregates its contents according to a user-defined aggregation function.
A ring buffer which aggregates its contents according to a user-defined aggregation function.
A ring buffer which aggregates its contents according to a user-defined aggregation function.
Dummy StringCache implementation for code that won't benefit from caching, just wants to use the StringCompatible
mechanisms for efficient String creation.
Assertion methods for simple runtime program verification.
RuntimeException to be thrown on assertion failures.A set of conventions for logging exceptions and asynchronously exiting the JVM.
See documentation in the interface and parent class for details.
See documentation in the interface and parent class for details.
Common parent for CharSequenceAdapters that store chars as single bytes (for simple encodings).
A simple circular buffer for primitive values, like java.util.concurrent.ArrayBlockingQueue but without the
synchronization and collection overhead.
A simple circular buffer for primitive values, like java.util.concurrent.ArrayBlockingQueue but without the
synchronization and collection overhead.
This class provides base functionality for several implementations of CharSequenceAdapter.
StringBuilder-like CharSequenceAdapter implementation.
Static helpers for hashCode, equality, and comparison of CharSequences.
SimpleReference with an additional cleanup callback.
A statistic that represents the composite or rolled-up value of a set of child statistics, as best as possible.
Immutable byte[]-backed String replacement.
This cache follows the same design as ConcurrentUnboundedStringCache, but uses a KeyedObjectCache (bounded,
concurrent-get, "pseudo-random pseudo-LRU" replacement) for its internal storage.
Common interface for LockFreeArrayQueue and variants.
A very limited interface is specified, in order to decouple typeAdapter pooling and related concerns from the cache
itself.
A statistic where each value represents a additive quantity, and thus the sum of the values does have meaning.
A simple circular buffer for primitive values, like java.util.concurrent.ArrayBlockingQueue but without the
synchronization and collection overhead.
SimpleReference implementation that allows a downgrade from strongly reachable to weakly reachable.
This interface is a slightly weaker version of java.io.Externalizable, in that it only allows the use of the
DataInput and -Output interfaces for reading and writing, not ObjectInput and -Output.
Encoding info enum, to help code determine what assumptions it can make about a CharSet, as well as simplification
for encode/decode operations.
String utility methods related to assertions.
FastArrayMap<K extends Comparable<K> & Externalizable & Copyable<K>,V extends Externalizable & Copyable<V>>
A generic interface for signaling a fatal error fatal errors.
A simple circular buffer for primitive values, like java.util.concurrent.ArrayBlockingQueue but without the
synchronization and collection overhead.
Strongly-held SimpleReference.
A simple circular buffer for primitive values, like java.util.concurrent.ArrayBlockingQueue but without the
synchronization and collection overhead.
The central idea is that we can use an open-addressed map as a bounded cache with concurrent get and synchronized put
access.
KeyValuePair<K extends Externalizable & Comparable<K> & Copyable<K>,V extends Externalizable & Copyable<V>>
A Java implementation of the algorithm described in:
Philippas Tsigas, Yi Zhang, "A simple, fast and scalable non-blocking concurrent FIFO queue for shared memory
multiprocessor systems", Proceedings of the thirteenth annual ACM symposium on Parallel algorithms and architectures,
p.134-143, July 2001, Crete Island, Greece
This version modifies the way we choose which NULL to use when dequeuing: 1) We let the head and tail pointers range
over the entire set of 32-bit unsigned values.
Collects output for efficient textual logging.
Allows objects to be smart about appending themselves to LogOutput instances...
A LogOutput implementation, designed solely as an adapter for LogOutputAppendable's to produce Strings.
A simple circular buffer for primitive values, like java.util.concurrent.ArrayBlockingQueue but without the
synchronization and collection overhead.
A very simple
Map for small maps with Integer keys (uses direct array access) that creates no garbage (except
when expanding).This is a special version of
ArrayList that can be substituted for a regular Array list but produces no
garbage.A very simple
Set for small sets (uses linear time algorithms) that creates no garbage (except when
expanding).This is a ridiculously simple, light-as-I-can-make-it, but decidedly single-purpose data structure.
A handful of simple mathematical utilities.
A simple circular buffer for primitive values, like java.util.concurrent.ArrayBlockingQueue but without the
synchronization and collection overhead.
An object canonicalization cache, suitable for use with objects that define equals(...) in such a way as to identify
objects that can be mutually substituted in a manner appropriate for the application using the cache.
Allows cache users to supercede the equals() and hashCode() methods of their input items, and supply an
alternative object to cache.
Unbounded StringCache built around a OpenAddressedCanonicalizationCache, which only enforces weak reachability on its
STRING_LIKE_TYPE members.
A Simple generic pair.
Provides a pool of reusable items.
Must implement at least: Multiple threads may call give(), one thread may call take()
Must implement at least: Multiple threads may call give(), multiple threads may call take()
Must implement at least: Multiple threads may call take(), one thread may call give()
Must implement at least: One thread may call give(), one thread may call take()
SimpleReference implementation with built-in reference-counting and pooling support.Indicates that a
Pool is empty and no more items can be Pool.take()n.Captures
System.out and System.err.Basis for LIFO, FIFO, Pool, and variants
Must implement at least: Multiple threads may call consume(), one thread may call produce()
Must implement at least: Multiple threads may call produce(), one thread may call consume()
Must implement at least: Multiple threads may call produce(), multiple threads may call consume()
Must implement at least: One thread may call produce(), one thread may call consume()
A "random-access" priority queue.
the queue adapter
Encapsulates an object reference so it can be passed and modified.
Requirement methods for simple runtime program verification.
RuntimeException to be thrown on requirement failures.Utility for holding strong references to otherwise unreachable classes (e.g.
A trivial circular buffer, like java.util.concurrent.ArrayBlockingQueue but without all the synchronization and
collection cruft.
This interface specifies a safe clone operation that never throws a CloneNotSupported exception, and also allows a
bound to be placed on the result object's type.
A simple circular buffer for primitive values, like java.util.concurrent.ArrayBlockingQueue but without the
synchronization and collection overhead.
Simple reference interface used by CachedReference.
Allows classes to register interest in receiving application level calls to
System.out and
System.err.A statistic where each value represents a snapshot of the state of the system, and thus the sum of the values does
not have any meaning.
A non-static interface to the Stats component.
An implementation that delegates to
print streams.This creates an interface (with more permissive argument types, and generified return types) for most public instance
methods of class String.
Generic caching interface for Strings and String-like CharSequences.
Abstracts type-specific functionality for use by StringCache implementations.
Type adapter for CompressedStrings.
Type adapter for MappedCompressedStrings.
Type adapter for Strings.
Marker interface for CharSequences to be used in StringCache implementations.
SimpleReference implementation that delegates to an internal SimpleReference which can be replaced
using the SwappableDelegatingReference.swapDelegate(SimpleReference, SimpleReference) method.A pool that
holds at least
size items,
creates size items in the pool immediately,
blocks (busily) whenever the pool overflows or underflows,
optionally clears the items given to it, and
IS thread-safe
A pool that
holds at least
size items,
creates size items in the pool immediately,
creates a new item when the pool underflows,
discards the item when the pool overflows,
optionally clears the items given to it, and
IS thread-safe
A weakly-held CleanupReference.
A helper for manging a list of WeakReferences.
SimpleReference implementation created to interpose a strong/hard reference in place of a weak reference, with
reachability subject to the continued reachability of the wrapped referent via the wrapped reference.
Weakly-held SimpleReference.