All Classes and Interfaces

Class	Description
AbstractConcurrentService	Abstract implementation of Service making its concurrent.
AbstractConcurrentSizedCollectionWrapper<W>
AbstractImmutableSet<E>	Abstract base for custom immutable Set implementations.
AbstractManagedPendingService<O,S,R>	Abstract implementation of ManagedPendingService.
AbstractManagedPendingService.State	States in which this service can be.
AbstractValueStorage<K,V>	Abstract base for ValueStorage.
Any	Marker indicating that the annotated type parameter does not matter thus any unchecked casts from this type to any other are safe and never lead to unspecified behaviour.
ArrayUtils	Utilities for working with arrays.
AsmDelegateFactory	Implementation of delegate factory which uses runtime class generation via ASM.
AsmUtil	Utility for common ObjectWeb ASM tasks.
AutoEnumCollectors	Collectors for use with enums with automatic type inference.
BlackHole	Black hole.
BooleanBinaryOperator	Represents an operation on a single boolean operand that produces a boolean result.
BooleanConsumer	Represents an operation that accepts a single boolean argument and returns no result.
BooleanFunction<R>	Represents a function that accepts a boolean argument and produces result of specified type.
BooleanPredicate	Represents a predicate (boolean-valued function) of one argument.
BooleanUnaryOperator	Represents an operation on a single boolean operand that produces a boolean} result.
BooleanWrapper	Primitive wrapper of boolean.
BooleanWrapper.AtomicBooleanWrapper	BooleanWrapper implementation based on AtomicBoolean.
BooleanWrapper.BooleanBooleanWrapper	BooleanWrapper implementation based on boolean.
ByteBinaryOperator	Represents an operation on a single byte operand that produces a byte result.
BytecodeLibrary	Library used for bytecode manipulations.
BytePredicate	Represents a predicate (boolean-valued function) of one argument.
ByteRange	Range specialization for byte.
Cache<K,V>	Simple cache interface.
CacheFactory	Factory used for creation of generic caches.
CacheFactory.NeverCacheFactory	CacheFactory which always creates no-op caches.
Caches	Utility for creating commonly used caches depending on runtime capabilities.
CachingGeneratingDelegateFactory	Base for implementing delegate factory using internal CachingGeneratingDelegateFactory.DelegateWrapperFactory cached for each unique type.
CachingGeneratingDelegateFactory.DelegateWrapperFactory<T>	Delegate-wrapper factory responsible for creating delegate wrappers based on the specified supplier.
CaffeineCache	Utilities for creation of Caffeine-based cache factories.
CharBinaryOperator	Represents an operation on a single char operand that produces a char result.
CharPredicate	Represents a predicate (boolean-valued function) of one argument.
CharRange	Range specialization for char.
ClassDefiner	Object used for runtime class definition.
ClassLoadingUtil	General purpose utility for Class-related operations.
ClassNamingStrategy	Object responsible for creating class names at runtime.
ClassNamingStrategy.PaginatedClassNamingStrategy	Class naming strategy appending numeric IDs to the base name.
ClassUtil	Utility for class-related stuff.
CollectionFactory	Factory used for creation of special collections at classload.
CommonBytecodeLibrary	Common bytecode libraries.
CompletableFutures	Utilities related to completable futures.
ConcurrentCollections	An utility for creating concurrent Collection wrappers.
ConcurrentCollectionWrapper<E,W extends Collection<E>>
ConcurrentDequeWrapper<E,W extends Deque<E>>
ConcurrentListWrapper<E,W extends List<E>>
ConcurrentMapWrapper<K,V,W extends Map<K,V>>
ConcurrentQueueWrapper<E,W extends Queue<E>>
ConcurrentSetFromMapWrapper<E,W extends Map<E,Boolean>>
ConcurrentSetWrapper<E,W extends Set<E>>
ConcurrentWrapper<W>	Base for all concurrent wrappers.
DataSerializer<T>	Serializer of arbitary data.
DataSerializer.NullableDataSerializer<T>	Data serializer for nullable types.
DataSerializer.OptionalDataSerializer<T>	Data serializer for optional types.
DataSerializers	Common data serializers.
DataSerializers.SizeAwareFactory<C>	Factory which creates something based on the size parameter.
DelegateFactories	Utility making use of delegate factories easier.
DelegateFactory	Factory capable of creating type-safe delegating wrappers.
DontOverrideEqualsAndHashCode	Deprecated. this annotation is applicable by default thus it is redundant
DoubleBinaryOperator	Represents an operation on a single double operand that produces a double result.
DoublePredicate	Represents a predicate (boolean-valued function) of one argument.
DoubleRange	Range specialization for double.
EnumCollectors	Collectors for use with enums.
FloatBinaryOperator	Represents an operation on a single float operand that produces a float result.
FloatPredicate	Represents a predicate (boolean-valued function) of one argument.
FloatRange	Range specialization for float.
FullAccessLookupFactories	Utility for accessing lookup factories giving practically full access.
GcClassDefiners	Utility for accessing class definers capable od defining garbage-collected classes.
IntBinaryOperator	Represents an operation on a single int operand that produces a int result.
IntegerParseError	An error occurring while parsing an integer (e.g.
IntPredicate	Represents a predicate (boolean-valued function) of one argument.
IntRange	Range specialization for int.
IntWrapper	Primitive wrapper of int.
IntWrapper.AtomicIntWrapper	IntWrapper implementation based on AtomicInteger.
IntWrapper.PrimitiveIntWrapper	IntWrapper implementation based on int.
InvokeFactory<F,T>	Factory for implementing functional interfaces at runtime.
InvokeUtil	Utility for common scenarios related to Java Invoke API.
IOWrappers	An utility for creating wrappers over java.io classes.
Iterables	Utilities related to iterables.
Lazy<T>	A wrapper for a value initialized once needed.
Lazy.DoubleCheckedLazy<T>	Thread-safe (using double-checked locking) lazy getting its value from the specified value supplier.
Lazy.LockingWeakLazy<T>	Thread-safe (using read-write-lock) weak lazy getting its value from the specified value supplier.
Lazy.SimpleLazy<T>	Non-thread-safe lazy getting its value from the specified value supplier.
Lazy.SimpleWeakLazy<T>	Non-thread-safe (using double-checked locking) weak lazy getting its value from the specified value supplier.
Lazy.ThreadLocalLazy<T>	Lazy which stores its values thread-locally.
LegacyClassExtensions	Extensions to provide new Class methods on older Java versions.
LegacyOptionalExtensions	Extensions to provide new Optional methods on older Java versions.
LegacyStreamExtensions	Extensions to provide new Stream methods on older Java versions.
LongBinaryOperator	Represents an operation on a single long operand that produces a long result.
LongPredicate	Represents a predicate (boolean-valued function) of one argument.
LongRange	Range specialization for long.
LongWrapper	Primitive wrapper of long.
LongWrapper.AtomicLongWrapper	LongWrapper implementation based on AtomicLong.
LongWrapper.PrimitiveLongWrapper	LongWrapper implementation based on long.
LookupFactory	Factory responsible for creating full-access lookups.
ManagedPendingService<O,S,R>	A managed pending service.
MapFiller<K,V>	A helper-object to fill the map implementing the chain pattern.
MapFiller.SimpleMapFiller<K,V>	An utility-object to fill the map following the chain pattern which may useful when initializing class fields.
MapUtil	Utilities related to Map.
MethodHandleInvocationMode	Mode of MethodHandle invocation.
MethodTypeUtil	Utilities related to method types.
MutablePair<F,S>	Mutable Pair.
MutablePair.SimpleMutablePair<F,S>	Simple implementation of MutablePair.
NonAutoCloseable	A wrapper for AutoCloseable which disables its AutoCloseable.close() method instead providing NonAutoCloseable.doClose() method for explicit closing of this object.
NonAutoCloseableInputStream	A NonAutoCloseable wrapper for InputStream.
NonAutoCloseableOutputStream	A NonAutoCloseable wrapper for OutputStream.
NonAutoCloseableReader	A NonAutoCloseable wrapper for Reader.
NonAutoCloseableWriter	A NonAutoCloseable wrapper for Writer.
NullSafetyExtensions	Extensions to provide null-safety on nullable types.
NumberUtil	Utilities related to numbers.
Numeric	Interface analog of Number.
ObjectUtil	Utilities for common object operations.
Own	Marker indicating the owner of a mutable object.
Pair<F,S>	A container holding two values.
Pair.SimplePair<F,S>	Simple implementation of Pair.
PendingService<O,S,R>	A service which gives per-owner access to its owned service.
PendingService.OwnedService<S,R>	An owned service which must be closed once the owner is ready with it.
Predicates	Common implementations of Predicate.
PrimitiveWrapper<W>	Mutable wrapper of a primitive type, this is mostly useful for passing these to lambdas.
ProxyDelegateFactory	Implementation of delegate factory which uses runtime proxy generation via Proxy.
RandomUtil	Utility for getting random values.
Range<T>	Range limiting some value.
Recursions	Utilities for performing common recursive operations.
Ref	Marker indicating the non-owner of a mutable object.
ReferenceUtil	Utility for reference-related features.
ReferenceWrapper<T>	Wrapper of a reference.
ReferenceWrapper.AtomicReferenceWrapper<T>	ReferenceWrapper implementation based on AtomicReference.
ReferenceWrapper.PrimitiveReferenceWrapper<T>	ReferenceWrapper implementation based on primitive reference.
Result<T,E>	A tagged union representing either a successful result or an error.
Result.Error<T,E>	Representation of an error result.
Result.Extensions	Extensions for Result providing type-specific specializations which are impossible via generic virtual methods.
Result.NotErrorException	An exception thrown whenever Result.unwrapError() is called on a successful result.
Result.NotSuccessException	An exception thrown whenever Result.unwrap() is called on an error result.
Result.NullError	Holder of a null-error result.
Result.NullSuccess	Holder of a null-success result.
Result.Success<T,E>	Representation of a successful result.
Runnables	Utilities related to runnables.
Service	A simple service mach may be enabled and disabled.
ShortBinaryOperator	Represents an operation on a single short operand that produces a short result.
ShortPredicate	Represents a predicate (boolean-valued function) of one argument.
ShortRange	Range specialization for short.
SimpleInvokeFactory<F,T>	Simple implementation of InvokeFactory.
SimpleValueStorage<V>	Simple value storage based on AbstractValueStorage using strings as its keys.
SizedCollection	A sized collection.
SneakyThrower	Utility used for rethrowing checked exceptions as unchecked.
ThrowingBiFunction<T,U,R,X extends Throwable>	An extension of BiFunction allowing throwing calls in its body.
ThrowingConsumer<T,X extends Throwable>	An extension of Consumer allowing throwing calls in its body.
ThrowingFunction<T,R,X extends Throwable>	An extension of Function allowing throwing calls in its body.
ThrowingRunnable<X extends Throwable>	An extension of Runnable allowing throwing calls in its body.
ThrowingSupplier<T,X extends Throwable>	An extension of Supplier allowing throwing calls in its body.
TypeHints	Utilities related to special hacks around Java's types, especially generics.
TypeHints.TypeHint	Marks the specified method argument as a type hint.
UncheckedCasts	Commonly used unchecked casts.
UnsafeInternals	Commonly used unsafe Java internals.
UsesBytecodeModification	Marker indicating that the annotated element uses (or attempts to use) bytecode-modification library(ies).
UuidUtil	Utility for UUID-related functionality.
ValueContainer<T>	A value which may be present (which includes null) or not-present.
ValueContainer.Containing<T>	A simple value-container which is meant to keep one unchanged value.
ValueContainer.Empty<T>	Empty value-container.
ValueContainer.EmptyValueException	An exception thrown whenever ValueContainer.get() is called on an empty value container.
ValueContainer.OfNull<T>	Non-empty value-container containing null.
ValueContainer.Supplying<T>	Value-container which provides new values for each request.
ValueStorage<K,V>	Storage of values which is made for sharing values which is unavailable via direct standard APIs such as initializing static final fields of generated classes.