de.caff.generics.function

Interface FragileFunction4<R,E extends java.lang.Exception,P1,P2,P3,P4>

Type Parameters:

R - return type

E - exception type

P1 - first parameter type

P2 - second parameter type

P3 - third parameter type

P4 - fourth parameter type

All Superinterfaces:

FragileFunction1<R,E,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 FragileFunction4<R,E extends java.lang.Exception,P1,P2,P3,P4>
extends FragileFunction1<R,E,ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>

Function with four parameters, possibly throwing a checked exception.

Author:

Rammi

Method Summary

Modifier and Type	Method and Description
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 Function4<R,P1,P2,P3,P4>	nonFragile() Convert this to a non-fragile function which does not throw a checked exception.
default Function4<R,P1,P2,P3,P4>	nonFragile(R fallback) Convert this to a non-fragile function which does not throw a checked exception.
default Function4<R,P1,P2,P3,P4>	nonFragileX(Function5<? extends R,? super E,? super P1,? super P2,? super P3,? super P4> exceptionHandler) Convert this to a non-fragile function which does not throw a checked exception.
default FragileFunction3<R,E,P2,P3,P4>	partial1(P1 argument) Get a partially applied function.
default FragileFunction3<R,E,P1,P3,P4>	partial2(P2 argument) Get a partially applied function.
default FragileFunction3<R,E,P1,P2,P4>	partial3(P3 argument) Get a partially applied function.
default FragileFunction3<R,E,P1,P2,P3>	partial4(P4 argument) Get a partially applied function.

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

nonFragileX

Method Detail

apply

R apply(P1 arg1,
        P2 arg2,
        P3 arg3,
        P4 arg4)
 throws E extends java.lang.Exception

Run the function.

Parameters:

arg1 - first argument

arg2 - second argument

arg3 - third argument

arg4 - fourth argument

Returns:

return value

Throws:

E - typed exception

E extends java.lang.Exception

apply

default R apply(@NotNull
                ITuple4<? extends P1,? extends P2,? extends P3,? extends P4> tuple4)
         throws E extends java.lang.Exception

Expand a tuple into the arguments of this function.

Specified by:

apply in interface FragileFunction1<R,E extends java.lang.Exception,ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>

Parameters:

tuple4 - tuple to expand

Returns:

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

Throws:

E - typed exception

E extends java.lang.Exception

nonFragile

@NotNull
default Function4<R,P1,P2,P3,P4> nonFragile()

Convert this to a non-fragile function which does not throw a checked exception. This will instead throw an unchecked WrappedFragileException for any checked exception thrown during apply(Object, Object, Object, Object).

Specified by:

nonFragile in interface FragileFunction1<R,E extends java.lang.Exception,ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>

Returns:

non-fragile function

See Also:

Function4.nonFragile(FragileFunction4)

nonFragile

@NotNull
default Function4<R,P1,P2,P3,P4> nonFragile(R fallback)

Convert this to a non-fragile function which does not throw a checked exception. This will instead return the fallback value. Please note that in this case the exception is completely lost!

Specified by:

nonFragile in interface FragileFunction1<R,E extends java.lang.Exception,ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>

Parameters:

fallback - fallback value

Returns:

non-fragile function

See Also:

Function4.nonFragile(FragileFunction4, Object)

nonFragileX

@NotNull
default Function4<R,P1,P2,P3,P4> nonFragileX(@NotNull
                                                      Function5<? extends R,? super E,? super P1,? super P2,? super P3,? super P4> exceptionHandler)

Convert this to a non-fragile function which does not throw a checked exception.

Parameters:

exceptionHandler - handler which can handle the exception how it sees fit. E.g. throw an unchecked exception (compare nonFragile(), return a fallback (compare nonFragile(Object)), or do the latter but also log or collect the exception

Returns:

non-fragile function

See Also:

Function4.nonFragileX(FragileFunction4, Function5)

partial1

@NotNull
default FragileFunction3<R,E,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 FragileFunction3<R,E,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 FragileFunction3<R,E,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 FragileFunction3<R,E,P1,P2,P3> partial4(P4 argument)

Get a partially applied function.

Parameters:

argument - value applied for fourth argument

Returns:

partially evaluated function