de.caff.generics.function

Interface Function4<R,P1,P2,P3,P4>

Type Parameters:

R - return type

P1 - parameter type 1

P2 - parameter type 2

P3 - parameter type 3

P4 - parameter type 4

All Superinterfaces:

java.util.function.Function<ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,R>, Function1<R,ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface
public interface Function4<R,P1,P2,P3,P4>
extends Function1<R,ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>

Function with four parameters.

Author:

Rammi

See Also:

Function0, Function1, Function2, Function3, Function5, Function6, Function7, Function8, Function9

Method Summary

Modifier and Type	Method and Description
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP> Function1<R,FP>	after1(java.util.function.Function<FP,FR> before) Get a chained function which first applies the given function, then this one.
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2> Function2<R,FP1,FP2>	after2(java.util.function.BiFunction<FP1,FP2,FR> before) Get a chained function which first applies the given 2-parameter function, then this one.
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3> Function3<R,FP1,FP2,FP3>	after3(Function3<FR,FP1,FP2,FP3> before) Get a chained function which first applies the given 3-parameter function, then this one.
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5> Function5<R,FP1,FP2,FP3,FP4,FP5>	after5(Function5<FR,FP1,FP2,FP3,FP4,FP5> before) Get a chained function which first applies the given 5-parameter function, then this one.
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6> Function6<R,FP1,FP2,FP3,FP4,FP5,FP6>	after6(Function6<FR,FP1,FP2,FP3,FP4,FP5,FP6> before) Get a chained function which first applies the given 6-parameter function, then this one.
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7> Function7<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7>	after7(Function7<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7> before) Get a chained function which first applies the given 7-parameter function, then this one.
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> Function8<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8>	after8(Function8<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> before) Get a chained function which first applies the given 8-parameter function, then this one.
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> Function9<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9>	after9(Function9<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> before) Get a chained function which first applies the given 9-parameter function, then this one.
default <T> Function4<T,P1,P2,P3,P4>	andThen(java.util.function.Function<? super R,? extends T> after) Get a chained function which first applies this function and then the given function to the returned value.
default R	apply(ITuple4<? extends P1,? extends P2,? extends P3,? extends P4> tuple4) Expand a tuple into the arguments of this function.
R	apply(P1 arg1, P2 arg2, P3 arg3, P4 arg4) Run the function.
default R	applyOrDefault(P1 arg1, P2 arg2, P3 arg3, P4 arg4, R fallback) Apply this function, but take care to create a fallback.
static <E extends java.lang.Exception,RR,PP1,PP2,PP3,PP4> Function4<RR,PP1,PP2,PP3,PP4>	nonFragile(FragileFunction4<? extends RR,E,? super PP1,? super PP2,? super PP3,? super PP4> fragileFunction) Convert a 4-argument function which might throw a checked exception into one which does throw an unchecked exception.
static <E extends java.lang.Exception,RR,PP1,PP2,PP3,PP4> Function4<RR,PP1,PP2,PP3,PP4>	nonFragile(FragileFunction4<? extends RR,E,? super PP1,? super PP2,? super PP3,? super PP4> fragileFunction, RR fallback) Convert a 4-argument function which might throw a checked exception into one which will return a default value instead of throwing an exception.
static <E extends java.lang.Exception,RR,PP1,PP2,PP3,PP4> Function4<RR,PP1,PP2,PP3,PP4>	nonFragileX(FragileFunction4<? extends RR,E,? super PP1,? super PP2,? super PP3,? super PP4> fragileFunction, Function5<? extends RR,? super E,? super PP1,? super PP2,? super PP3,? super PP4> exceptionHandler) Convert a 4-argument function which might throw a checked exception into one for which you can decide what happens with the exception.
default Function3<R,P2,P3,P4>	partial1(P1 argument) Get a partially applied function.
default Function3<R,P1,P3,P4>	partial2(P2 argument) Get a partially applied function.
default Function3<R,P1,P2,P4>	partial3(P3 argument) Get a partially applied function.
default Function3<R,P1,P2,P3>	partial4(P4 argument) Get a partially applied function.

Methods inherited from interface de.caff.generics.function.Function1

after, applyNonNull, applyOrDefault, fallback, fallback, from, from, nonFragile, nonFragile, nonFragileX, partial, withFallback

Methods inherited from interface java.util.function.Function

compose, identity

Method Detail

apply

R apply(P1 arg1,
        P2 arg2,
        P3 arg3,
        P4 arg4)

Run the function.

Parameters:

arg1 - function argument 1

arg2 - function argument 2

arg3 - function argument 3

arg4 - function argument 4

Returns:

return value

apply

default R apply(@NotNull
                ITuple4<? extends P1,? extends P2,? extends P3,? extends P4> tuple4)

Expand a tuple into the arguments of this function.

Specified by:

apply in interface java.util.function.Function<ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,R>

Parameters:

tuple4 - tuple to expand

Returns:

the result of calling this function with the arguments set from the tuple

applyOrDefault

@NotNull
default R applyOrDefault(P1 arg1,
                                  P2 arg2,
                                  P3 arg3,
                                  P4 arg4,
                                  @NotNull
                                  R fallback)

Apply this function, but take care to create a fallback. Thiw will return the fallback when apply(Object, Object, Object, Object) returns null.

Parameters:

arg1 - first argument of this function

arg2 - second argument of this function

arg3 - third argument of this function

arg4 - fourth argument of this function

fallback - fallback value returned if function returns null

Returns:

the non-null result of calling apply(Object, Object, Object, Object), or fallback if the result was null

partial1

@NotNull
default Function3<R,P2,P3,P4> partial1(P1 argument)

Get a partially applied function.

Parameters:

argument - value applied for first argument

Returns:

partially evaluated function

partial2

@NotNull
default Function3<R,P1,P3,P4> partial2(P2 argument)

Get a partially applied function.

Parameters:

argument - value applied for second argument

Returns:

partially evaluated function

partial3

@NotNull
default Function3<R,P1,P2,P4> partial3(P3 argument)

Get a partially applied function.

Parameters:

argument - value applied for third argument

Returns:

partially evaluated function

partial4

@NotNull
default Function3<R,P1,P2,P3> partial4(P4 argument)

Get a partially applied function.

Parameters:

argument - value applied for fourth argument

Returns:

partially evaluated function

andThen

@NotNull
default <T> Function4<T,P1,P2,P3,P4> andThen(@NotNull
                                                      java.util.function.Function<? super R,? extends T> after)

Get a chained function which first applies this function and then the given function to the returned value.

Specified by:

andThen in interface java.util.function.Function<ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,R>

Specified by:

andThen in interface Function1<R,ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>

Type Parameters:

T - result type of returned function

Parameters:

after - function to apply after this one

Returns:

function chain

after1

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP> Function1<R,FP> after1(@NotNull
                                                                                                                     java.util.function.Function<FP,FR> before)

Get a chained function which first applies the given function, then this one. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP - function before's parameter type, same for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

after2

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2> Function2<R,FP1,FP2> after2(@NotNull
                                                                                                                               java.util.function.BiFunction<FP1,FP2,FR> before)

Get a chained function which first applies the given 2-parameter function, then this one. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP1 - function before's first parameter type, sane for returned function

FP2 - function before's second parameter type, same for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

after3

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3> Function3<R,FP1,FP2,FP3> after3(@NotNull
                                                                                                                                       Function3<FR,FP1,FP2,FP3> before)

Get a chained function which first applies the given 3-parameter function, then this one. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP1 - function before's first parameter type, sane for returned function

FP2 - function before's second parameter type, sane for returned function

FP3 - function before's third parameter type, sane for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

after5

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5> Function5<R,FP1,FP2,FP3,FP4,FP5> after5(@NotNull
                                                                                                                                                       Function5<FR,FP1,FP2,FP3,FP4,FP5> before)

Get a chained function which first applies the given 5-parameter function, then this one. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP1 - function before's first parameter type, sane for returned function

FP2 - function before's second parameter type, sane for returned function

FP3 - function before's third parameter type, sane for returned function

FP4 - function before's fourth parameter type, sane for returned function

FP5 - function before's fifth parameter type, sane for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

after6

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6> Function6<R,FP1,FP2,FP3,FP4,FP5,FP6> after6(@NotNull
                                                                                                                                                               Function6<FR,FP1,FP2,FP3,FP4,FP5,FP6> before)

Get a chained function which first applies the given 6-parameter function, then this one. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP1 - function before's first parameter type, sane for returned function

FP2 - function before's second parameter type, sane for returned function

FP3 - function before's third parameter type, sane for returned function

FP4 - function before's fourth parameter type, sane for returned function

FP5 - function before's fifth parameter type, sane for returned function

FP6 - function before's sixth parameter type, sane for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

after7

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7> Function7<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7> after7(@NotNull
                                                                                                                                                                       Function7<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7> before)

Get a chained function which first applies the given 7-parameter function, then this one. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP1 - function before's first parameter type, sane for returned function

FP2 - function before's second parameter type, sane for returned function

FP3 - function before's third parameter type, sane for returned function

FP4 - function before's fourth parameter type, sane for returned function

FP5 - function before's fifth parameter type, sane for returned function

FP6 - function before's sixth parameter type, sane for returned function

FP7 - function before's seventh parameter type, sane for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

after8

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> Function8<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> after8(@NotNull
                                                                                                                                                                               Function8<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> before)

Get a chained function which first applies the given 8-parameter function, then this one. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP1 - function before's first parameter type, sane for returned function

FP2 - function before's second parameter type, sane for returned function

FP3 - function before's third parameter type, sane for returned function

FP4 - function before's fourth parameter type, sane for returned function

FP5 - function before's fifth parameter type, sane for returned function

FP6 - function before's sixth parameter type, sane for returned function

FP7 - function before's seventh parameter type, sane for returned function

FP8 - function before's seventh parameter type, sane for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

after9

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> Function9<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> after9(@NotNull
                                                                                                                                                                                       Function9<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> before)

Get a chained function which first applies the given 9-parameter function, then this one. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP1 - function before's first parameter type, sane for returned function

FP2 - function before's second parameter type, sane for returned function

FP3 - function before's third parameter type, sane for returned function

FP4 - function before's fourth parameter type, sane for returned function

FP5 - function before's fifth parameter type, sane for returned function

FP6 - function before's sixth parameter type, sane for returned function

FP7 - function before's seventh parameter type, sane for returned function

FP8 - function before's seventh parameter type, sane for returned function

FP9 - function before's ninth parameter type, sane for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

nonFragile

@NotNull
static <E extends java.lang.Exception,RR,PP1,PP2,PP3,PP4> Function4<RR,PP1,PP2,PP3,PP4> nonFragile(@NotNull
                                                                                                            FragileFunction4<? extends RR,E,? super PP1,? super PP2,? super PP3,? super PP4> fragileFunction)

Convert a 4-argument function which might throw a checked exception into one which does throw an unchecked exception. The returned function will instead throw an unchecked WrappedFragileException for any checked exception thrown during apply(Object, Object, Object, Object).

Type Parameters:

E - exception type

RR - result type of incoming and outgoing function.

PP1 - type of first parameter of returned functions

PP2 - type of second parameter of returned functions

PP3 - type of third parameter of returned functions

PP4 - type of fourth parameter of returned functions

Parameters:

fragileFunction - function throwing a checked exception

Returns:

non-fragile function

nonFragile

@NotNull
static <E extends java.lang.Exception,RR,PP1,PP2,PP3,PP4> Function4<RR,PP1,PP2,PP3,PP4> nonFragile(@NotNull
                                                                                                            FragileFunction4<? extends RR,E,? super PP1,? super PP2,? super PP3,? super PP4> fragileFunction,
                                                                                                            RR fallback)

Convert a 4-argument function which might throw a checked exception into one which will return a default value instead of throwing an exception. Please note that the exception is lost in this case.

Type Parameters:

E - exception type

RR - result type of incoming and outgoing function.

PP1 - type of first parameter of returned functions

PP2 - type of second parameter of returned functions

PP3 - type of third parameter of returned functions

PP4 - type of fourth parameter of returned functions

Parameters:

fragileFunction - function throwing a checked exception

fallback - fallback returned when fragileFunction has thrown an exception

Returns:

non-fragile function

nonFragileX

@NotNull
static <E extends java.lang.Exception,RR,PP1,PP2,PP3,PP4> Function4<RR,PP1,PP2,PP3,PP4> nonFragileX(@NotNull
                                                                                                             FragileFunction4<? extends RR,E,? super PP1,? super PP2,? super PP3,? super PP4> fragileFunction,
                                                                                                             @NotNull
                                                                                                             Function5<? extends RR,? super E,? super PP1,? super PP2,? super PP3,? super PP4> exceptionHandler)

Convert a 4-argument function which might throw a checked exception into one for which you can decide what happens with the exception. The exception handler allows

• throw an unchecked exception instead (compare Function1.nonFragile(FragileFunction1))
• provide a fallback value (compare Function1.nonFragile(FragileFunction1, Object))
• include logging in one of the above
• and more...

Type Parameters:

E - exception type

RR - result type of incoming and outgoing function.

PP1 - type of first parameter of returned functions

PP2 - type of second parameter of returned functions

PP3 - type of third parameter of returned functions

PP4 - type of fourth parameter of returned functions

Parameters:

fragileFunction - function throwing a checked exception

exceptionHandler - exception handler. Its return value will be used as return value of the returned function.

Returns:

non-fragile function