All Classes (essentials-shared 0.9.12 API)

All Classes Interface Summary Class Summary Enum Summary Exception Summary
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 0`ComparableEmptyComparableTuple.empty()` 1`ComparableSingleComparableTuple.of(Comparable)` 2`ComparablePairComparableTuple.of(Comparable, Comparable)` 3`ComparableTripleComparableTuple.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 `type`/`getType()` will return `List.class` And `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 `type`/`getType()` will return `Money.class` And `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
Interfaces	Utility class for working with `Interfaces`'s
InvocationException
InvocationStrategy	Determines which among as set of matching methods are invoked
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.
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
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 `Triple.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 0`EmptyTuple.empty()` 1`SingleTuple.of(Object)` 2`PairTuple.of(Object, Object)` 3`TripleTuple.of(Object, Object, Object)` Note: `Tuple` (and its subclasses) supports `Object.equals(Object)` comparison using subclasses for the different subclasses