All Classes and Interfaces

Class	Description
AbstractMessageTemplate
Accessibles	Utility class for working with AccessibleObject/Member's
BoxedTypes
CheckedBiFunction<T1,T2,R>	Variant of BiFunction that behaves like BiFunction, but which allows checked Exception's to be thrown from its CheckedBiFunction.apply(Object, Object) method – the first function argument type – the second function argument type – the function result type
CheckedConsumer<T>	Variant of Consumer that behaves like Consumer, but which allows checked Exception's to be thrown from its CheckedConsumer.accept(Object) method
CheckedExceptionRethrownException	Used by the various Checked functional interfaces to indicate that a Checked Exception has been catched and rethrown
CheckedFunction<T,R>	Variant of Function that behaves like Function, but which allows checked Exception's to be thrown from its CheckedFunction.apply(Object) method – the function argument type – the function result type
CheckedRunnable	Variant of Runnable that behaves like Runnable, but which allows checked Exception's to be thrown from its CheckedRunnable.run() method
CheckedSupplier<R>	Variant of Supplier that behaves like Supplier, but which allows checked Exception's to be thrown from its CheckedSupplier.get() method
CheckedTripleFunction<T1,T2,T3,R>	Variant of TripleFunction that behaves like TripleFunction, but which allows checked Exception's to be thrown from its CheckedTripleFunction.apply(Object, Object, Object) method – the first function argument type – the second function argument type – the third function argument type – the function result type
Classes	Utility class for working with Class's
ComparableEmpty	Represents a ComparableTuple with zero elements
ComparablePair<T1 extends Comparable<? super T1>,T2 extends Comparable<? super T2>>	Represents a ComparableTuple with two elements. Note: ComparablePair supports ComparablePair.equals(Object) comparison using subclasses, e.g.:
ComparableSingle<T1 extends Comparable<? super T1>>	Represents a ComparableTuple with one element. Note: ComparableSingle supports ComparableSingle.equals(Object) comparison using subclasses, e.g.:
ComparableTriple<T1 extends Comparable<? super T1>,T2 extends Comparable<? super T2>,T3 extends Comparable<? super T3>>	Represents a ComparableTuple with three elements. Note: ComparableTriple supports ComparableTriple.equals(Object) comparison using subclasses, e.g.:
ComparableTuple<CONCRETE_TUPLE extends ComparableTuple<CONCRETE_TUPLE>>	Base interface for all ComparableTuple's. A ComparableTuple is an immutable object that can contain the following (supported) number of elements: Number of element in TupleConcrete ComparableTuple typeFactory method 0ComparableEmptyComparableTuple.empty() 1ComparableSingleComparableTuple.of(Comparable) 2ComparablePairComparableTuple.of(Comparable, Comparable) 3ComparableTripleComparableTuple.of(Comparable, Comparable, Comparable) Note: ComparableTuple (and its subclasses) supports Object.equals(Object) comparison using subclasses for the different subclasses
Constructors	Utility class for working with Constructor's
DefaultInterceptorChain<OPERATION,RESULT,INTERCEPTOR_TYPE extends Interceptor>	Default implementation for the InterceptorChain.
Either<T1,T2>	Represents a Tuple with two potential elements, but where only one element can have a value at a time This is used to represent a choice type that can have two different values, but only one value at a time. The value can either be Either._1() OR Either._2() Use Either(Object, Object) or Either.of_1(Object)/Either.of_2(Object) to create a new Either instance Use Either.is_1() or Either.is_2() to check which value is non-null and Either._1() or Either._2() to get the value of the element. Conditional logic can be applied using Either.ifIs_1(Consumer) or Either.ifIs_2(Consumer)
ElseIfExpression<RETURN_TYPE>	The ElseIf/Else part of an IfExpression
Empty	Represents a Tuple with zero elements
Exceptions
FailFast	Collection of Objects.requireNonNull(Object) replacement methods
Fields	Utility class for working with Field's
GenericType<T>	Using this class makes it possible to capture a generic/parameterized argument type, such as List<Money>, instead of having to rely on the classical .class construct. When you specify a type reference using .class you loose any Generic/Parameterized information, as you cannot write List<Money>.class, only List.class. With GenericType you can specify and capture parameterized type information You can specify a parameterized type using GenericType: var genericType = new GenericType<List<Money>>(){}; The GenericType.type/GenericType.getType() will return List.class And GenericType.genericType/GenericType.getGenericType() will return ParameterizedType, which can be introspected further You can also supply a non-parameterized type to GenericType: var genericType = new GenericType<Money>(){}; In which case GenericType.type/GenericType.getType() will return Money.class And GenericType.genericType/GenericType.getGenericType() will return Money.class
GetFieldException
IfExpression<RETURN_TYPE>	An if expression is an IfExpression.If(boolean, Object) and ElseIfExpression.Else(Object), with multiple optional intermediate ElseIfExpression.ElseIf(boolean, Object)'s, which returns a value of the evaluation of the if expression:
IfPredicate	An IfPredicate is evaluated to resolve if an IfExpression or ElseIfExpression element is true and hence the return value from the ifReturnValueSupplier must be returned
Interceptor	Each interceptor, configured on the method allows you to perform before, after or around interceptor logic according to your needs. The Interceptor is built around supporting Intercepting specific Operations, where an Operation is determined by the user of the Interceptor.
InterceptorChain<OPERATION,RESULT,INTERCEPTOR_TYPE extends Interceptor>	Generic interceptor chain concept that supports intercepting concrete Interceptor operations to modify the behaviour or add to the default behaviour
InterceptorOrder	Annotation that can be applied to interceptors to control their order of execution in the InterceptorChain The lower the number the higher the priority. An interceptor with order 1 will be invoked before an interceptor with order 10.
Interfaces	Utility class for working with Interfaces's
InvocationException
InvocationStrategy	Determines which among as set of matching methods are invoked
Lifecycle	Common process life cycle interface
Lists	List utility methods
LoadingClassFailedException
Message	A Message is an instance of a MessageTemplate with parameters bound to it A Message instance is e.g. useful for error/validation reporting. Example creating a Message from a MessageTemplate4:
MessageFormatter	Slf4J compatible message formatter. The MessageFormatter supports formatting a message using Slf4J style message anchors:
MessageFormatter.NamedArgumentBinding	Named argument binding instance
MessageTemplate	The MessageTemplate concept supports structured messages with typed parameters. Each MessageTemplate instance has a unique MessageTemplate.getKey() that clearly identifies the MessageTemplate. MessageTemplate keys can be nested, to support message hierarchies:
MessageTemplate0	Represents a MessageTemplate accepting 0 parameters. Example defining a MessageTemplate0's:
MessageTemplate1<PARAM_1>	Represents a MessageTemplate accepting 1 parameter Example defining a MessageTemplate1's:
MessageTemplate2<PARAM_1,PARAM_2>	Represents a MessageTemplate accepting 2 parameters Example defining a MessageTemplate2's:
MessageTemplate3<PARAM_1,PARAM_2,PARAM_3>	Represents a MessageTemplate accepting 3 parameters Example defining a MessageTemplate3's:
MessageTemplate4<PARAM_1,PARAM_2,PARAM_3,PARAM_4>	Represents a MessageTemplate accepting 4 parameters Example defining a MessageTemplate4's:
MessageTemplates	Marker interface for classes or interfaces that contain MessageTemplate fields, which can be queried using MessageTemplates.getMessageTemplates(Class, boolean) Example of a concrete MessageTemplates subclass:
MethodInvocationFailedException
MethodPatternMatcher<ARGUMENT_COMMON_ROOT_TYPE>	Strategy interface that determines the mechanics of which methods are candidates for matching, what type a given method supports and how the method is invoked
Methods	Utility class for working with Method's
Network
NoFieldFoundException
NoMatchingMethodFoundException
NoMatchingMethodsHandler	Consumer that will be called if PatternMatchingMethodInvoker.invoke(Object) or PatternMatchingMethodInvoker.invoke(Object, NoMatchingMethodsHandler) is called with an argument that doesn't match any methods
Pair<T1,T2>	Represents a Tuple with two elements. Note: Pair supports Pair.equals(Object) comparison using subclasses, e.g.:
Parameters	Utility class for working with Methods/Method parameters and Constructors/Constructor declaration parameters or method/constructor call arguments
Parameters.NULL_ARGUMENT_TYPE	Class used to represent the unknown type for a null parameter to Parameters.argumentTypes(Object...)
PatternMatchingMethodInvoker<ARGUMENT_COMMON_ROOT_TYPE>	The purpose of the PatternMatchingMethodInvoker is to support pattern matching a set of typed methods against a concrete argument and have the method(s) that match the type resolved by the MethodPatternMatcher.resolveInvocationArgumentTypeFromObject(Object) will be invoked by the MethodPatternMatcher.invokeMethod(Method, Object, Object, Class) with the argument
ReflectionException
Reflector	Caching Java Reflection helper Encapsulates Constructors, Methods and Fields while providing high-level method for invoking constructors, method and getting/setting fields Depending on the version of Java you're using you may need to explicitly add something like the following to your Module Config or Java arguments to ensure that Reflector is allowed to perform Java reflection See https://docs.oracle.com/en/java/javase/17/migrate/migrating-jdk-8-later-jdk-releases.html#GUID-12F945EB-71D6-46AF-8C3D-D354FD0B1781 for more information and to understand the implications of adding the --add-opens argument.
SetFieldException
Single<T1>	Represents a Tuple with one element. Note: Single supports Single.equals(Object) comparison using subclasses, e.g.:
SingleArgumentAnnotatedMethodPatternMatcher<ARGUMENT_COMMON_ROOT_TYPE>	A strategy that matches methods annotated with matchOnMethodsAnnotatedWith and have a single method argument that is the same type or a sub-type of the ARGUMENT_COMMON_ROOT_TYPE Example using parameterized types:
StopWatch	Stop watch feature that allows you to time operations
Streams	Utility class for working with streams.
ThreadFactoryBuilder	Builder for a ThreadFactory to allow setting thread names, auto increment thread numbers, etc.
Timing
TimingWithResult<R>	The result of StopWatch.time(Supplier)
TooManyMatchingFieldsFoundException
TooManyMatchingMethodsFoundException
Triple<T1,T2,T3>	Represents a Tuple with three elements. Note: Triple supports equals(Object) comparison using subclasses, e.g.:
TripleFunction<T1,T2,T3,R>	Represents a function that accepts three arguments and produces a result. This is a specialization of the Function interface.
Tuple<CONCRETE_TUPLE extends Tuple<CONCRETE_TUPLE>>	Base interface for all Tuple's. A Tuple is an immutable object that can contain the following (supported) number of elements: Number of element in TupleConcrete Tuple typeFactory method 0EmptyTuple.empty() 1SingleTuple.of(Object) 2PairTuple.of(Object, Object) 3TripleTuple.of(Object, Object, Object) Note: Tuple (and its subclasses) supports Object.equals(Object) comparison using subclasses for the different subclasses