com.github.dm.jrt.function

Class Functions

java.lang.Object

com.github.dm.jrt.function.Functions

public class Functions
extends Object

Utility class supporting functional programming.

Created by davide-maestroni on 09/21/2015.

Method Summary

Methods

Modifier and Type	Method and Description
static <IN1,IN2> BiConsumerWrapper<IN1,IN2>	biSink() Returns a bi-consumer wrapper just discarding the passed inputs. The returned object will support concatenation and comparison.
static <IN,OUT> FunctionWrapper<IN,OUT>	castTo(Class<? extends OUT> type) Returns a function wrapper casting the passed inputs to the specified class. The returned object will support concatenation and comparison.
static <IN,OUT> FunctionWrapper<IN,OUT>	castTo(ClassToken<? extends OUT> token) Returns a function wrapper casting the passed inputs to the specified class token type. The returned object will support concatenation and comparison.
static <OUT> SupplierWrapper<OUT>	constant(OUT result) Returns a supplier wrapper always returning the same result. The returned object will support concatenation and comparison.
static <OUT> CommandInvocation<OUT>	consumerCommand(Consumer<? super ResultChannel<OUT>> consumer) Builds and returns a new command invocation based on the specified consumer instance. In order to prevent undesired leaks, the class of the specified consumer must have a static context.
static <IN,OUT> InvocationFactory<IN,OUT>	consumerFactory(BiConsumer<? super List<? extends IN>,? super ResultChannel<OUT>> consumer) Builds and returns a new invocation factory based on the specified bi-consumer instance. In order to prevent undesired leaks, the class of the specified bi-consumer must have a static context.
static <IN,OUT> FilterInvocation<IN,OUT>	consumerFilter(BiConsumer<? super IN,? super ResultChannel<OUT>> consumer) Builds and returns a new filter invocation based on the specified bi-consumer instance. In order to prevent undesired leaks, the class of the specified bi-consumer must have a static context.
static <IN1,IN2> BiFunctionWrapper<IN1,IN2,IN1>	first() Returns a bi-function wrapper just returning the first passed argument. The returned object will support concatenation and comparison.
static <IN,OUT> InvocationFactory<IN,OUT>	functionFactory(Function<? super List<? extends IN>,OUT> function) Builds and returns a new invocation factory based on the specified function instance. In order to prevent undesired leaks, the class of the specified function must have a static context.
static <IN,OUT> FilterInvocation<IN,OUT>	functionFilter(Function<? super IN,OUT> function) Builds and returns a new filter invocation based on the specified function instance. In order to prevent undesired leaks, the class of the specified function must have a static context.
static <IN> FunctionWrapper<IN,IN>	identity() Returns the identity function wrapper. The returned object will support concatenation and comparison.
static <IN> PredicateWrapper<IN>	isEqual(Object targetRef) Returns a predicate wrapper testing for equality to the specified object. The returned object will support concatenation and comparison.
static <IN> PredicateWrapper<IN>	isInstanceOf(Class<?> type) Returns a predicate wrapper testing whether the passed inputs are instances of the specified class. The returned object will support concatenation and comparison.
static <IN> PredicateWrapper<IN>	isNull() Returns a predicate wrapper returning true when the passed argument is null. The returned object will support concatenation and comparison.
static <IN> PredicateWrapper<IN>	isSame(Object targetRef) Returns a predicate wrapper testing for identity to the specified object. The returned object will support concatenation and comparison.
static <IN> PredicateWrapper<IN>	negative() Returns a predicate wrapper always returning the false. The returned object will support concatenation and comparison.
static <IN> PredicateWrapper<IN>	notNull() Returns a predicate wrapper returning true when the passed argument is not null. The returned object will support concatenation and comparison.
static OutputConsumerBuilder<Object>	onComplete(Consumer<Void> consumer) Returns an output consumer builder employing the specified consumer function to handle the invocation completion.
static OutputConsumerBuilder<Object>	onError(Consumer<RoutineException> consumer) Returns an output consumer builder employing the specified consumer function to handle the invocation errors.
static <OUT> OutputConsumerBuilder<OUT>	onOutput(Consumer<OUT> consumer) Returns an output consumer builder employing the specified consumer function to handle the invocation outputs.
static <IN> PredicateWrapper<IN>	positive() Returns a predicate wrapper always returning the true. The returned object will support concatenation and comparison.
static <IN> FilterInvocation<IN,IN>	predicateFilter(Predicate<? super IN> predicate) Builds and returns a new filter invocation based on the specified predicate instance. Only the inputs which satisfies the predicate will be passed on, while the others will be filtered out. In order to prevent undesired leaks, the class of the specified predicate must have a static context.
static <IN1,IN2> BiFunctionWrapper<IN1,IN2,IN2>	second() Returns a bi-function wrapper just returning the second passed argument. The returned object will support concatenation and comparison.
static <IN> ConsumerWrapper<IN>	sink() Returns a consumer wrapper just discarding the passed inputs. The returned object will support concatenation and comparison.
static <OUT> CommandInvocation<OUT>	supplierCommand(Supplier<OUT> supplier) Builds and returns a new command invocation based on the specified supplier instance. In order to prevent undesired leaks, the class of the specified supplier must have a static context.
static <IN,OUT> InvocationFactory<IN,OUT>	supplierFactory(Supplier<? extends Invocation<IN,OUT>> supplier) Builds and returns a new invocation factory based on the specified supplier instance. In order to prevent undesired leaks, the class of the specified supplier must have a static context.
static <IN1,IN2> BiConsumerWrapper<IN1,IN2>	wrapBiConsumer(BiConsumer<IN1,IN2> consumer) Wraps the specified bi-consumer instance so to provide additional features. The returned object will support concatenation and comparison.
static <IN1,IN2,OUT> BiFunctionWrapper<IN1,IN2,OUT>	wrapBiFunction(BiFunction<IN1,IN2,OUT> function) Wraps the specified bi-function instance so to provide additional features. The returned object will support concatenation and comparison.
static <IN> ConsumerWrapper<IN>	wrapConsumer(Consumer<IN> consumer) Wraps the specified consumer instance so to provide additional features. The returned object will support concatenation and comparison.
static <IN,OUT> FunctionWrapper<IN,OUT>	wrapFunction(Function<IN,OUT> function) Wraps the specified function instance so to provide additional features. The returned object will support concatenation and comparison.
static <IN> PredicateWrapper<IN>	wrapPredicate(Predicate<IN> predicate) Wraps the specified predicate instance so to provide additional features. The returned object will support concatenation and comparison.
static <OUT> SupplierWrapper<OUT>	wrapSupplier(Supplier<OUT> supplier) Wraps the specified supplier instance so to provide additional features. The returned object will support concatenation and comparison.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

biSink

@NotNull
public static <IN1,IN2> BiConsumerWrapper<IN1,IN2> biSink()

Returns a bi-consumer wrapper just discarding the passed inputs.
The returned object will support concatenation and comparison.

Type Parameters:

IN1 - the first input data type.

IN2 - the second input data type.

Returns:

the bi-consumer wrapper.

castTo

@NotNull
public static <IN,OUT> FunctionWrapper<IN,OUT> castTo(@NotNull
                                              Class<? extends OUT> type)

Returns a function wrapper casting the passed inputs to the specified class.
The returned object will support concatenation and comparison.

Type Parameters:

IN - the input data type.

OUT - the output data type.

Parameters:

type - the class type.

Returns:

the function wrapper.

castTo

@NotNull
public static <IN,OUT> FunctionWrapper<IN,OUT> castTo(@NotNull
                                              ClassToken<? extends OUT> token)

Returns a function wrapper casting the passed inputs to the specified class token type.
The returned object will support concatenation and comparison.

Type Parameters:

IN - the input data type.

OUT - the output data type.

Parameters:

token - the class token.

Returns:

the function wrapper.

constant

@NotNull
public static <OUT> SupplierWrapper<OUT> constant(OUT result)

Returns a supplier wrapper always returning the same result.
The returned object will support concatenation and comparison.

Type Parameters:

OUT - the output data type.

Parameters:

result - the result.

Returns:

the supplier wrapper.

consumerCommand

@NotNull
public static <OUT> CommandInvocation<OUT> consumerCommand(@NotNull
                                                   Consumer<? super ResultChannel<OUT>> consumer)

Builds and returns a new command invocation based on the specified consumer instance.
In order to prevent undesired leaks, the class of the specified consumer must have a static context.

Note that the passed object is expected to behave like a function, that is, it must not retain a mutable internal state.
Note also that any external object used inside the function must be synchronized in order to avoid concurrency issues.

Type Parameters:

OUT - the output data type.

Parameters:

consumer - the consumer instance.

Returns:

the command invocation.

consumerFactory

@NotNull
public static <IN,OUT> InvocationFactory<IN,OUT> consumerFactory(@NotNull
                                                         BiConsumer<? super List<? extends IN>,? super ResultChannel<OUT>> consumer)

Builds and returns a new invocation factory based on the specified bi-consumer instance.
In order to prevent undesired leaks, the class of the specified bi-consumer must have a static context.

Note that the passed object is expected to behave like a function, that is, it must not retain a mutable internal state.
Note also that any external object used inside the function must be synchronized in order to avoid concurrency issues.

Type Parameters:

IN - the input data type.

OUT - the output data type.

Parameters:

consumer - the bi-consumer instance.

Returns:

the invocation factory.

consumerFilter

@NotNull
public static <IN,OUT> FilterInvocation<IN,OUT> consumerFilter(@NotNull
                                                       BiConsumer<? super IN,? super ResultChannel<OUT>> consumer)

Builds and returns a new filter invocation based on the specified bi-consumer instance.
In order to prevent undesired leaks, the class of the specified bi-consumer must have a static context.

Note that the passed object is expected to behave like a function, that is, it must not retain a mutable internal state.
Note also that any external object used inside the function must be synchronized in order to avoid concurrency issues.

Type Parameters:

IN - the input data type.

OUT - the output data type.

Parameters:

consumer - the bi-consumer instance.

Returns:

the filter invocation.

first

@NotNull
public static <IN1,IN2> BiFunctionWrapper<IN1,IN2,IN1> first()

Returns a bi-function wrapper just returning the first passed argument.
The returned object will support concatenation and comparison.

Type Parameters:

IN1 - the first input data type.

IN2 - the second input data type.

Returns:

the bi-function wrapper.

functionFactory

@NotNull
public static <IN,OUT> InvocationFactory<IN,OUT> functionFactory(@NotNull
                                                         Function<? super List<? extends IN>,OUT> function)

Builds and returns a new invocation factory based on the specified function instance.
In order to prevent undesired leaks, the class of the specified function must have a static context.

Note that the passed object is expected to behave like a function, that is, it must not retain a mutable internal state.
Note also that any external object used inside the function must be synchronized in order to avoid concurrency issues.

Type Parameters:

IN - the input data type.

OUT - the output data type.

Parameters:

function - the function instance.

Returns:

the invocation factory.

functionFilter

@NotNull
public static <IN,OUT> FilterInvocation<IN,OUT> functionFilter(@NotNull
                                                       Function<? super IN,OUT> function)

Builds and returns a new filter invocation based on the specified function instance.
In order to prevent undesired leaks, the class of the specified function must have a static context.

Note that the passed object is expected to behave like a function, that is, it must not retain a mutable internal state.
Note also that any external object used inside the function must be synchronized in order to avoid concurrency issues.

Type Parameters:

IN - the input data type.

OUT - the output data type.

Parameters:

function - the function instance.

Returns:

the filter invocation.

identity

@NotNull
public static <IN> FunctionWrapper<IN,IN> identity()

Returns the identity function wrapper.
The returned object will support concatenation and comparison.

Type Parameters:

IN - the input data type.

Returns:

the function wrapper.

isEqual

@NotNull
public static <IN> PredicateWrapper<IN> isEqual(@Nullable
                                        Object targetRef)

Returns a predicate wrapper testing for equality to the specified object.
The returned object will support concatenation and comparison.

Type Parameters:

IN - the input data type.

Parameters:

targetRef - the target reference.

Returns:

the predicate wrapper.

isInstanceOf

@NotNull
public static <IN> PredicateWrapper<IN> isInstanceOf(@NotNull
                                             Class<?> type)

Returns a predicate wrapper testing whether the passed inputs are instances of the specified class.
The returned object will support concatenation and comparison.

Type Parameters:

IN - the input data type.

Parameters:

type - the class type.

Returns:

the predicate wrapper.

isNull

@NotNull
public static <IN> PredicateWrapper<IN> isNull()

Returns a predicate wrapper returning true when the passed argument is null.
The returned object will support concatenation and comparison.

Type Parameters:

IN - the input data type.

Returns:

the predicate wrapper.

isSame

@NotNull
public static <IN> PredicateWrapper<IN> isSame(@Nullable
                                       Object targetRef)

Returns a predicate wrapper testing for identity to the specified object.
The returned object will support concatenation and comparison.

Type Parameters:

IN - the input data type.

Parameters:

targetRef - the target reference.

Returns:

the predicate wrapper.

negative

@NotNull
public static <IN> PredicateWrapper<IN> negative()

Returns a predicate wrapper always returning the false.
The returned object will support concatenation and comparison.

Type Parameters:

IN - the input data type.

Returns:

the predicate wrapper.

notNull

@NotNull
public static <IN> PredicateWrapper<IN> notNull()

Returns a predicate wrapper returning true when the passed argument is not null.
The returned object will support concatenation and comparison.

Type Parameters:

IN - the input data type.

Returns:

the predicate wrapper.

onComplete

@NotNull
public static OutputConsumerBuilder<Object> onComplete(@NotNull
                                               Consumer<Void> consumer)

Returns an output consumer builder employing the specified consumer function to handle the invocation completion.

Parameters:

consumer - the consumer function.

Returns:

the builder instance.

onError

@NotNull
public static OutputConsumerBuilder<Object> onError(@NotNull
                                            Consumer<RoutineException> consumer)

Returns an output consumer builder employing the specified consumer function to handle the invocation errors.

Parameters:

consumer - the consumer function.

Returns:

the builder instance.

onOutput

@NotNull
public static <OUT> OutputConsumerBuilder<OUT> onOutput(@NotNull
                                                Consumer<OUT> consumer)

Returns an output consumer builder employing the specified consumer function to handle the invocation outputs.

Type Parameters:

OUT - the output data type.

Parameters:

consumer - the consumer function.

Returns:

the builder instance.

positive

@NotNull
public static <IN> PredicateWrapper<IN> positive()

Returns a predicate wrapper always returning the true.
The returned object will support concatenation and comparison.

Type Parameters:

IN - the input data type.

Returns:

the predicate wrapper.

predicateFilter

@NotNull
public static <IN> FilterInvocation<IN,IN> predicateFilter(@NotNull
                                                   Predicate<? super IN> predicate)

Builds and returns a new filter invocation based on the specified predicate instance.
Only the inputs which satisfies the predicate will be passed on, while the others will be filtered out.
In order to prevent undesired leaks, the class of the specified predicate must have a static context.

Note that the passed object is expected to behave like a function, that is, it must not retain a mutable internal state.
Note also that any external object used inside the function must be synchronized in order to avoid concurrency issues.

Type Parameters:

IN - the input data type.

Parameters:

predicate - the predicate instance.

Returns:

the invocation factory.

second

@NotNull
public static <IN1,IN2> BiFunctionWrapper<IN1,IN2,IN2> second()

Returns a bi-function wrapper just returning the second passed argument.
The returned object will support concatenation and comparison.

Type Parameters:

IN1 - the first input data type.

IN2 - the second input data type.

Returns:

the bi-function wrapper.

sink

@NotNull
public static <IN> ConsumerWrapper<IN> sink()

Returns a consumer wrapper just discarding the passed inputs.
The returned object will support concatenation and comparison.

Type Parameters:

IN - the input data type.

Returns:

the consumer wrapper.

supplierCommand

@NotNull
public static <OUT> CommandInvocation<OUT> supplierCommand(@NotNull
                                                   Supplier<OUT> supplier)

Builds and returns a new command invocation based on the specified supplier instance.
In order to prevent undesired leaks, the class of the specified supplier must have a static context.

Note that the passed object is expected to behave like a function, that is, it must not retain a mutable internal state.
Note also that any external object used inside the function must be synchronized in order to avoid concurrency issues.

Type Parameters:

OUT - the output data type.

Parameters:

supplier - the supplier instance.

Returns:

the command invocation.

supplierFactory

@NotNull
public static <IN,OUT> InvocationFactory<IN,OUT> supplierFactory(@NotNull
                                                         Supplier<? extends Invocation<IN,OUT>> supplier)

Builds and returns a new invocation factory based on the specified supplier instance.
In order to prevent undesired leaks, the class of the specified supplier must have a static context.

Note that the passed object is expected to behave like a function, that is, it must not retain a mutable internal state.
Note also that any external object used inside the function must be synchronized in order to avoid concurrency issues.

Type Parameters:

IN - the input data type.

OUT - the output data type.

Parameters:

supplier - the supplier instance.

Returns:

the invocation factory.

wrapBiConsumer

@NotNull
public static <IN1,IN2> BiConsumerWrapper<IN1,IN2> wrapBiConsumer(@NotNull
                                                          BiConsumer<IN1,IN2> consumer)

Wraps the specified bi-consumer instance so to provide additional features.
The returned object will support concatenation and comparison.

Note that the passed object is expected to behave like a function, that is, it must not retain a mutable internal state.
Note also that any external object used inside the function must be synchronized in order to avoid concurrency issues.

Type Parameters:

IN1 - the first input data type.

IN2 - the second input data type.

Parameters:

consumer - the bi-consumer instance.

Returns:

the wrapped bi-consumer.

wrapBiFunction

@NotNull
public static <IN1,IN2,OUT> BiFunctionWrapper<IN1,IN2,OUT> wrapBiFunction(@NotNull
                                                                  BiFunction<IN1,IN2,OUT> function)

Wraps the specified bi-function instance so to provide additional features.
The returned object will support concatenation and comparison.

Note that the passed object is expected to behave like a function, that is, it must not retain a mutable internal state.
Note also that any external object used inside the function must be synchronized in order to avoid concurrency issues.

Type Parameters:

IN1 - the first input data type.

IN2 - the second input data type.

OUT - the output data type.

Parameters:

function - the bi-function instance.

Returns:

the wrapped bi-function.

wrapConsumer

@NotNull
public static <IN> ConsumerWrapper<IN> wrapConsumer(@NotNull
                                            Consumer<IN> consumer)

Wraps the specified consumer instance so to provide additional features.
The returned object will support concatenation and comparison.

Note that the passed object is expected to behave like a function, that is, it must not retain a mutable internal state.
Note also that any external object used inside the function must be synchronized in order to avoid concurrency issues.

Type Parameters:

IN - the input data type.

Parameters:

consumer - the consumer instance.

Returns:

the wrapped consumer.

wrapFunction

@NotNull
public static <IN,OUT> FunctionWrapper<IN,OUT> wrapFunction(@NotNull
                                                    Function<IN,OUT> function)

Wraps the specified function instance so to provide additional features.
The returned object will support concatenation and comparison.

Note that the passed object is expected to behave like a function, that is, it must not retain a mutable internal state.
Note also that any external object used inside the function must be synchronized in order to avoid concurrency issues.

Type Parameters:

IN - the input data type.

OUT - the output data type.

Parameters:

function - the function instance.

Returns:

the wrapped function.

wrapPredicate

@NotNull
public static <IN> PredicateWrapper<IN> wrapPredicate(@NotNull
                                              Predicate<IN> predicate)

Wraps the specified predicate instance so to provide additional features.
The returned object will support concatenation and comparison.

Note that the passed object is expected to behave like a function, that is, it must not retain a mutable internal state.
Note also that any external object used inside the function must be synchronized in order to avoid concurrency issues.

Type Parameters:

IN - the input data type.

Parameters:

predicate - the predicate instance.

Returns:

the wrapped predicate.

wrapSupplier

@NotNull
public static <OUT> SupplierWrapper<OUT> wrapSupplier(@NotNull
                                              Supplier<OUT> supplier)

Wraps the specified supplier instance so to provide additional features.
The returned object will support concatenation and comparison.

Note that the passed object is expected to behave like a function, that is, it must not retain a mutable internal state.
Note also that any external object used inside the function must be synchronized in order to avoid concurrency issues.

Type Parameters:

OUT - the output data type.

Parameters:

supplier - the supplier instance.

Returns:

the wrapped supplier.