P1
- first parameter typeP2
- second parameter typeP3
- third parameter typeP4
- fourth parameter type@FunctionalInterface public interface Procedure4<P1,P2,P3,P4> extends Procedure1<ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>
Procedure0
,
Procedure1
,
Procedure2
,
Procedure3
,
Procedure5
,
Procedure6
,
Procedure7
,
Procedure8
,
Procedure9
Modifier and Type | Field and Description |
---|---|
static Procedure4<?,?,?,?> |
NULL
Procedure with four arguments which does nothing.
|
Modifier and Type | Method and Description |
---|---|
default void |
accept(ITuple4<? extends P1,? extends P2,? extends P3,? extends P4> tuple4)
Expand a tuple into the arguments of this procedure.
|
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP> |
after1(java.util.function.Function<FP,FR> before)
Get a chained procedure which first applies the given function, then this procedure.
|
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2> |
after2(java.util.function.BiFunction<FP1,FP2,FR> before)
Get a chained procedure which first applies the given 2-parameter function, then this procedure.
|
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3> |
after3(Function3<FR,FP1,FP2,FP3> before)
Get a chained procedure which first applies the given 3-parameter function, then this procedure.
|
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5> |
after5(Function5<FR,FP1,FP2,FP3,FP4,FP5> before)
Get a chained procedure which first applies the given 5-parameter function, then this procedure.
|
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6> |
after6(Function6<FR,FP1,FP2,FP3,FP4,FP5,FP6> before)
Get a chained procedure which first applies the given 6-parameter function, then this procedure.
|
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7> |
after7(Function7<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7> before)
Get a chained procedure 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> |
after8(Function8<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> before)
Get a chained procedure 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> |
after9(Function9<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> before)
Get a chained procedure which first applies the given 9-parameter function, then this one.
|
void |
apply(P1 arg1,
P2 arg2,
P3 arg3,
P4 arg4)
Run the procedure.
|
static <T1,T2,T3,T4> |
empty()
Return a procedure which does nothing.
|
static <E extends java.lang.Exception,PP1,PP2,PP3,PP4> |
nonFragile(FragileProcedure4<E,? super PP1,? super PP2,? super PP3,? super PP4> fragileProc)
Convert a 4-argument procedure which might throw a checked exception into
one which does throw an unchecked exception.
|
static <E extends java.lang.Exception,PP1,PP2,PP3,PP4> |
nonFragileX(FragileProcedure4<E,? super PP1,? super PP2,? super PP3,? super PP4> fragileProc,
Procedure5<? super E,? super PP1,? super PP2,? super PP3,? super PP4> exceptionHandler)
Convert a 4-argument procedure which might throw a checked exception into
one for which you can decide what happens with the exception.
|
default Procedure3<P2,P3,P4> |
partial1(P1 argument)
Get a partially applied procedure.
|
default Procedure3<P1,P3,P4> |
partial2(P2 argument)
Get a partially applied procedure.
|
default Procedure3<P1,P2,P4> |
partial3(P3 argument)
Get a partially applied procedure.
|
default Procedure3<P1,P2,P3> |
partial4(P4 argument)
Get a partially applied procedure.
|
apply, applyNonNull, from, nonFragile, nonFragileX, partial
@NotNull static final Procedure4<?,?,?,?> NULL
empty()
instead.void apply(P1 arg1, P2 arg2, P3 arg3, P4 arg4)
arg1
- first procedure argumentarg2
- second procedure argumentarg3
- third procedure argumentarg4
- fourth procedure argumentdefault void accept(@NotNull ITuple4<? extends P1,? extends P2,? extends P3,? extends P4> tuple4)
@NotNull default Procedure3<P2,P3,P4> partial1(P1 argument)
argument
- value applied for first argument@NotNull default Procedure3<P1,P3,P4> partial2(P2 argument)
argument
- value applied for second argument@NotNull default Procedure3<P1,P2,P4> partial3(P3 argument)
argument
- value applied for third argument@NotNull default Procedure3<P1,P2,P3> partial4(P4 argument)
argument
- value applied for fourth argument@NotNull default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP> Procedure1<FP> after1(@NotNull java.util.function.Function<FP,FR> before)
ITuple4
with matching parametric types
which are applied in their order to this procedure.FR
- function before
's return type, has to be a 4-tuple with matching typesFP
- function before
's parameter type, same for returned procedurebefore
- function to apply first, has to return a non-null
result so unpacking the parameters
from the tuple is possible@NotNull default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2> Procedure2<FP1,FP2> after2(@NotNull java.util.function.BiFunction<FP1,FP2,FR> before)
ITuple4
with matching parametric types
which are applied in their order to this procedure.FR
- function before
's return type, has to be a 4-tuple with matching typesFP1
- function before
's first parameter type, sane for returned procedureFP2
- function before
's second parameter type, same for returned procedurebefore
- function to apply first, has to return a non-null
result so unpacking the parameters
from the tuple is possible@NotNull default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3> Procedure3<FP1,FP2,FP3> after3(@NotNull Function3<FR,FP1,FP2,FP3> before)
ITuple4
with matching parametric types
which are applied in their order to this procedure.FR
- function before
's return type, has to be a 4-tuple with matching typesFP1
- function before
's first parameter type, sane for returned procedureFP2
- function before
's second parameter type, sane for returned procedureFP3
- function before
's third parameter type, sane for returned procedurebefore
- function to apply first, has to return a non-null
result so unpacking the parameters
from the tuple is possible@NotNull default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5> Procedure5<FP1,FP2,FP3,FP4,FP5> after5(@NotNull Function5<FR,FP1,FP2,FP3,FP4,FP5> before)
ITuple4
with matching parametric types
which are applied in their order to this function.FR
- function before
's return type, has to be a 4-tuple with matching typesFP1
- function before
's first parameter type, sane for returned procedureFP2
- function before
's second parameter type, sane for returned procedureFP3
- function before
's third parameter type, sane for returned procedureFP4
- function before
's fourth parameter type, sane for returned procedureFP5
- function before
's fifth parameter type, sane for returned procedurebefore
- function to apply first, has to return a non-null
result so unpacking the parameters
from the tuple is possible@NotNull default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6> Procedure6<FP1,FP2,FP3,FP4,FP5,FP6> after6(@NotNull Function6<FR,FP1,FP2,FP3,FP4,FP5,FP6> before)
ITuple4
with matching parametric types
which are applied in their order to this function.FR
- function before
's return type, has to be a 4-tuple with matching typesFP1
- function before
's first parameter type, sane for returned procedureFP2
- function before
's second parameter type, sane for returned procedureFP3
- function before
's third parameter type, sane for returned procedureFP4
- function before
's fourth parameter type, sane for returned procedureFP5
- function before
's fifth parameter type, sane for returned procedureFP6
- function before
's sixth parameter type, sane for returned procedurebefore
- function to apply first, has to return a non-null
result so unpacking the parameters
from the tuple is possible@NotNull default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7> Procedure7<FP1,FP2,FP3,FP4,FP5,FP6,FP7> after7(@NotNull Function7<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7> before)
ITuple4
with matching parametric types
which are applied in their order to this procedure.FR
- function before
's return type, has to be a 4-tuple with matching typesFP1
- function before
's first parameter type, sane for returned procedureFP2
- function before
's second parameter type, sane for returned procedureFP3
- function before
's third parameter type, sane for returned procedureFP4
- function before
's fourth parameter type, sane for returned procedureFP5
- function before
's fifth parameter type, sane for returned procedureFP6
- function before
's sixth parameter type, sane for returned procedureFP7
- function before
's seventh parameter type, sane for returned procedurebefore
- function to apply first, has to return a non-null
result so unpacking the parameters
from the tuple is possible@NotNull default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> Procedure8<FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> after8(@NotNull Function8<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> before)
ITuple4
with matching parametric types
which are applied in their order to this procedure.FR
- function before
's return type, has to be a 4-tuple with matching typesFP1
- function before
's first parameter type, sane for returned procedureFP2
- function before
's second parameter type, sane for returned procedureFP3
- function before
's third parameter type, sane for returned procedureFP4
- function before
's fourth parameter type, sane for returned procedureFP5
- function before
's fifth parameter type, sane for returned procedureFP6
- function before
's sixth parameter type, sane for returned procedureFP7
- function before
's seventh parameter type, sane for returned procedureFP8
- function before
's seventh parameter type, sane for returned procedurebefore
- function to apply first, has to return a non-null
result so unpacking the parameters
from the tuple is possible@NotNull default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> Procedure9<FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> after9(@NotNull Function9<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> before)
ITuple4
with matching parametric types
which are applied in their order to this procedure.FR
- function before
's return type, has to be a 4-tuple with matching typesFP1
- function before
's first parameter type, sane for returned procedureFP2
- function before
's second parameter type, sane for returned procedureFP3
- function before
's third parameter type, sane for returned procedureFP4
- function before
's fourth parameter type, sane for returned procedureFP5
- function before
's fifth parameter type, sane for returned procedureFP6
- function before
's sixth parameter type, sane for returned procedureFP7
- function before
's seventh parameter type, sane for returned procedureFP8
- function before
's seventh parameter type, sane for returned procedureFP9
- function before
's ninth parameter type, sane for returned procedurebefore
- function to apply first, has to return a non-null
result so unpacking the parameters
from the tuple is possible@NotNull static <T1,T2,T3,T4> Procedure4<T1,T2,T3,T4> empty()
NULL
, but the compiler will accept it smoothly.@NotNull static <E extends java.lang.Exception,PP1,PP2,PP3,PP4> Procedure4<PP1,PP2,PP3,PP4> nonFragile(@NotNull FragileProcedure4<E,? super PP1,? super PP2,? super PP3,? super PP4> fragileProc)
WrappedFragileException
for any
checked exception thrown during Procedure1.apply(Object)
.E
- exception typePP1
- type of first parameterPP2
- type of second parameterPP3
- type of third parameterPP4
- type of fourth parameterfragileProc
- procedure throwing a checked exception@NotNull static <E extends java.lang.Exception,PP1,PP2,PP3,PP4> Procedure4<PP1,PP2,PP3,PP4> nonFragileX(@NotNull FragileProcedure4<E,? super PP1,? super PP2,? super PP3,? super PP4> fragileProc, @NotNull Procedure5<? super E,? super PP1,? super PP2,? super PP3,? super PP4> exceptionHandler)
nonFragile(FragileProcedure4)
)E
- exception typePP1
- type of first parameterPP2
- type of second parameterPP3
- type of third parameterPP4
- type of fourth parameterfragileProc
- procedure throwing a checked exceptionexceptionHandler
- exception handler. Its return value will be used as return value of the returned function.