All Classes and Interfaces
Class
Description
A variant of the interface
Runnable
with a
Action.run()
method that allows to throw an exception.An implementation of
Spliterator
that aggregates the elements of the stream based on a provided
Predicate.Use the application error to signal the abort of an application.
This implementation of
This implementation of
Error
allows to set a flag that indicates whether this instance was already
logged or not.A wrapper for locks that supports the
try-with-resources feature of Java 7.This exception is thrown when an operation fails.
The implementation of
AutoLock.This is a specialized implementation for the
IllegalArgumentException
that should be used instead of the latter in cases where a blank String is
provided as an illegal argument value.This annotation allows to add information about applied fixes to a program
element.
This is a specialized implementation for the
IllegalArgumentException
that should be used instead of the latter in cases where a
CharSequence
provided as a method argument is too long according to some external
constraints, like the column definition of a database.A generic wrapper for checked exceptions.
This annotation will be used to provide version information
for each class in a project.
This class provides a bunch of commonly used constants.
A functional interface whose
Constraint.evaluate()
method return a boolean and can throw an
Exception
in case of an errorSome functions for DEBUG and TEST output to the console.
The default implementation of
The implementation of
StringConverter
for types that are derived from
Enum.The implementation of
DefaultEnumStringConverter.fromString(CharSequence)
provided here uses
Class.getEnumConstants()
to find the enum value:The default implementation for
MapStream.This is a specialized implementation for the
IllegalArgumentException
that should be used instead of the latter in cases where an empty String,
array or
Collection
argument is provided as an illegal argument value.This is a
FunctionalInterface
meant to process a given error code and to throw an exception based on
that, or to cause some side effects.The annotation container for
@BUG
annotations.Some helper methods for the use with lambdas and functional
interfaces.
This implementation of
StringConverter
allows to create an instance of StringConverter for an arbitrary
type on the fly.The definition for a getter method.
This implementation of
RuntimeException
will be thrown when an attempted operation is not valid for the current
context.This implementation of
Error
should be thrown in all cases where an exception was caught that seemed to
be impossible to be thrown.A value combined with an index, indicating its position in an ordered
sequence.
A selector function takes an array of values and returns the respective
array index for the selected value.
A "container" exception for exception thrown within
lambda expressions.
A holder for a lazy initialised object instance.
The implementation of the interface
Lazy.Allows to execute an operation with an obtained lock.
The implementation of
LockExecutor.A stream of
Map.Entry<K,V>.An implementation of
Spliterator
that merges streams.The marker annotation for methods that are meant to be overwritten in child
classes.
An implementation of a name-value-pair.
This is a specialized implementation for the
IllegalArgumentException
that should be used instead of the latter in cases where null is
provided as an illegal argument value.Represents a supplier of
Number-valued
results.This class consists of several utility methods working on
Object
instances, similar to those on
Arrays
or
Collections.A variant of the interface
Supplier
with a
Operation.get()
method that allows to throw an exception.The implementation of a tupel.
This is the marker annotation for a "Playground
Class"
Prints a formatted message.
This implementation of
Error
should be called from private constructors of static classes
(classes that does not allow any instances because they have only static
methods or constants).This is the marker annotation for a "Main" class.
Associates a property name to a method.
A selector function takes an array of values and returns the respective
array index for the selected value.
Some useful implementations of the
Selector
interface.The definition for a setter method.
An implementation of
Spliterator
that skips elements on the stream that do not match the provided condition.Instances of the class
SoftLazy allow to lazy load data that may be
needed more than once, but not permanently.The implementation for the
SoftLazy
interface.Instances of this record are meant to be used as the return values for
methods that should either return a proper result, or an error code.
This class allows to intercept the calls to the methods of
Stream.Utility class providing static methods for performing various operations on
Streams.
Defines the conversion between Strings and object instances,
where the concrete behaviour is defined by the implementation of the
interface.
The implementation for the
StringConverter
service methods.This interface defines a method to compose a String
representation from arbitrary objects.
An implementation of
Spliterator
that takes elements from a stream while the given
Predicate
returns true.The TCE version of the interface
BiConsumer
that represents an operation that accepts two input arguments and returns
no result.The TCE version of the interface
BiFunction
that represents a function that accepts two arguments and produces a
result.The TCE version of the interface
BinaryOperator
that represents an operation upon two operands of the same type, producing
a result of the same type as the operands.The TCE version of the interface
Consumer
that represents an operation that accepts a single input argument and
returns no result.The TCE version of the interface
Function
that represents a function that accepts one argument and produces a
result.The TCE version of the interface
Predicate
that represents a predicate (boolean-valued function) of one argument.The TCE version of the interface
Supplier
that represents a supplier of results.The TCE version of the interface
TriConsumer
that represents an operation that accepts three input arguments and returns
no result.The TCE version of the interface
Different from the method
This is a functional interface whose functional method is
TriFunction
that represents a function that accepts three arguments and produces a
result.Different from the method
Function.apply()
the method
TCETriFunction.apply(Object, Object, Object)
of this interface declares to throw a
checked exception.This is a functional interface whose functional method is
TCETriFunction.apply(Object, Object, Object).A builder for an implementation of
ThreadFactory.The implementation of
ThreadFactoryBuilder.The implementation of
ThreadFactory
that is returned by
ThreadFactoryBuilder.build().An implementation of
ThreadGroup
that allows to configure the behaviour of
ThreadGroupExt.uncaughtException(Thread, Throwable)Represents an operation that accepts three input arguments and
returns no result.
Represents an operation that accepts three input arguments and
produces a result.
This implementation of
Error
should be thrown in all cases where an unexpected exception was caught.An implementation of
Spliterator
that which takes a seed value and applies a generator to create the next
value, feeding each new value back into the generator to create subsequent
values.This is a specialized implementation for
Error
that is to be thrown especially from the default branch of a
switch statement that uses an enum type as selector.This is a marker annotation for a utility class.
This is a specialized implementation for the
IllegalArgumentException
that is meant as the root for a hierarchy of exceptions caused by
validation errors.An implementation of
Spliterator
that zips two streams into one.