@FunctionalInterface public interface LTriConsumer<T1,T2,T3> extends MetaConsumer, MetaInterface.NonThrowing, Codomain<aType.aVoid>, Domain3<aType.a<T1>,aType.a<T2>,aType.a<T3>>
Non-throwing functional interface (lambda) LTriConsumer for Java 8.
Type: consumer
Domain (lvl: 3): T1 a1,T2 a2,T3 a3
Co-domain: none
| Modifier and Type | Interface and Description |
|---|---|
static interface |
LTriConsumer.LBiObj1Obj0Cons<T3,T2,T1>
Permutation of LTriConsumer for method references.
|
static interface |
LTriConsumer.LObj0Obj2Obj1Cons<T1,T3,T2>
Permutation of LTriConsumer for method references.
|
static interface |
LTriConsumer.LObj1BiObj2Cons<T2,T1,T3>
Permutation of LTriConsumer for method references.
|
static interface |
LTriConsumer.LObj1Obj2Obj0Cons<T2,T3,T1>
Permutation of LTriConsumer for method references.
|
static interface |
LTriConsumer.LObj2Obj0Obj1Cons<T3,T1,T2>
Permutation of LTriConsumer for method references.
|
static class |
LTriConsumer.LTriConsumerSingle<T1,T2,T3> |
MetaInterface.NonThrowing, MetaInterface.Throwing<X>| Modifier and Type | Field and Description |
|---|---|
static String |
DESCRIPTION |
| Modifier and Type | Method and Description |
|---|---|
default void |
accept(T1 a1,
T2 a2,
T3 a3) |
default void |
accept(T1 a1,
T2 a2,
T3 a3,
ExWF<RuntimeException> exF) |
default void |
accept(T1 a1,
T2 a2,
T3 a3,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static <T1,T2,T3> LTriConsumer<T1,T2,T3> |
accept1st(LConsumer<T1> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T1,T2,T3> LTriConsumer<T1,T2,T3> |
accept2nd(LConsumer<T2> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
static <T1,T2,T3> LTriConsumer<T1,T2,T3> |
accept3rd(LConsumer<T3> func)
Captures single parameter function into this interface where only 3rd parameter will be used.
|
default void |
acceptThen(T1 a1,
T2 a2,
T3 a3,
LConsumer<Throwable> handler) |
void |
acceptX(T1 a1,
T2 a2,
T3 a3)
Implement this, but call accept(T1 a1,T2 a2,T3 a3)
|
default LTriConsumer<T1,T2,T3> |
andThen(LTriConsumer<? super T1,? super T2,? super T3> after)
Combines two LTriConsumer<T1,T2,T3> together in a order.
|
static <T3,T2,T1> LTriConsumer.LBiObj1Obj0Cons<T3,T2,T1> |
biObj1Obj0Cons(LTriConsumer.LBiObj1Obj0Cons<T3,T2,T1> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
static <T1,T2,T3> void |
call(T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> lambda) |
default LAction |
capture(T1 a1,
T2 a2,
T3 a3)
Captures arguments but delays the evaluation.
|
default <V2,V3,V4> LTriConsumer<V2,V3,V4> |
cast()
Cast that replace generics.
|
static <V2,V3,V4,T1,T2,T3> |
cast(LTriConsumer<T1,T2,T3> function)
Cast that replace generics.
|
default <V1,V2,V3> LTriConsumer<V1,V2,V3> |
compose(LFunction<? super V1,? extends T1> before1,
LFunction<? super V2,? extends T2> before2,
LFunction<? super V3,? extends T3> before3)
Allows to manipulate the domain of the function.
|
static <V1,V2,V3,T1,T2,T3> |
composed(LFunction<? super V1,? extends T1> before1,
LFunction<? super V2,? extends T2> before2,
LFunction<? super V3,? extends T3> before3,
LTriConsumer<T1,T2,T3> after) |
static <T1,T2,T3> void |
doNothing(T1 a1,
T2 a2,
T3 a3)
Does nothing (LTriConsumer)
|
static <T1,T2,T3> LTriConsumer<T1,T2,T3> |
failSafe(LTriConsumer<T1,T2,T3> func,
LTriConsumer<T1,T2,T3> failSafe) |
default void |
failSafeAccept(T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> failSafe) |
static <T1,T2,T3> void |
failSafeAccept(T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func,
LTriConsumer<T1,T2,T3> failSafe) |
static <C1,C2,C3,T1,T2,T3> |
forEach(IndexedRead<C1,aType.a<T1>> ia1,
C1 source1,
IndexedRead<C2,aType.a<T2>> ia2,
C2 source2,
IndexedRead<C3,aType.a<T3>> ia3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static <T1,T2,T3> void |
fromTill(int min_i,
int max_i,
T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func)
From-To.
|
static <T1,T2,T3> void |
fromTo(int min_i,
int max_i,
T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func)
From-To.
|
default String |
functionalInterfaceDescription()
Returns description of the functional interface.
|
default LTriConsumer<T1,T2,T3> |
handling(HandlingInstructions<Throwable,RuntimeException> handling) |
default void |
handlingAccept(T1 a1,
T2 a2,
T3 a3,
HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
|
static <T1,T2,T3> void |
handlingAccept(T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func,
HandlingInstructions<Throwable,RuntimeException> handling) |
static <C1,C2,C3,I3,T1,T2,T3> |
iterate(IndexedRead<C1,aType.a<T1>> ia1,
C1 source1,
IndexedRead<C2,aType.a<T2>> ia2,
C2 source2,
SequentialRead<C3,I3,aType.a<T3>> sa3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static <C1,C2,I2,C3,T1,T2,T3> |
iterate(IndexedRead<C1,aType.a<T1>> ia1,
C1 source1,
SequentialRead<C2,I2,aType.a<T2>> sa2,
C2 source2,
IndexedRead<C3,aType.a<T3>> ia3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static <C1,C2,I2,C3,I3,T1,T2,T3> |
iterate(IndexedRead<C1,aType.a<T1>> ia1,
C1 source1,
SequentialRead<C2,I2,aType.a<T2>> sa2,
C2 source2,
SequentialRead<C3,I3,aType.a<T3>> sa3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static <C1,I1,C2,C3,T1,T2,T3> |
iterate(SequentialRead<C1,I1,aType.a<T1>> sa1,
C1 source1,
IndexedRead<C2,aType.a<T2>> ia2,
C2 source2,
IndexedRead<C3,aType.a<T3>> ia3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static <C1,I1,C2,C3,I3,T1,T2,T3> |
iterate(SequentialRead<C1,I1,aType.a<T1>> sa1,
C1 source1,
IndexedRead<C2,aType.a<T2>> ia2,
C2 source2,
SequentialRead<C3,I3,aType.a<T3>> sa3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static <C1,I1,C2,I2,C3,T1,T2,T3> |
iterate(SequentialRead<C1,I1,aType.a<T1>> sa1,
C1 source1,
SequentialRead<C2,I2,aType.a<T2>> sa2,
C2 source2,
IndexedRead<C3,aType.a<T3>> ia3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static <C1,I1,C2,I2,C3,I3,T1,T2,T3> |
iterate(SequentialRead<C1,I1,aType.a<T1>> sa1,
C1 source1,
SequentialRead<C2,I2,aType.a<T2>> sa2,
C2 source2,
SequentialRead<C3,I3,aType.a<T3>> sa3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer.
|
default LBiConsumer<T2,T3> |
lShrink(LBiFunction<T2,T3,T1> left) |
default LBiConsumer<T2,T3> |
lShrinkc(T1 a1) |
static <T2,T3,T1> LBiConsumer<T2,T3> |
lShrinked(LBiFunction<T2,T3,T1> left,
LTriConsumer<T1,T2,T3> func) |
static <T2,T3,T1> LBiConsumer<T2,T3> |
lShrinkedc(T1 a1,
LTriConsumer<T1,T2,T3> func) |
default void |
nestingAccept(T1 a1,
T2 a2,
T3 a3)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
|
static <T1,T3,T2> LTriConsumer.LObj0Obj2Obj1Cons<T1,T3,T2> |
obj0Obj2Obj1Cons(LTriConsumer.LObj0Obj2Obj1Cons<T1,T3,T2> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
static <T2,T1,T3> LTriConsumer.LObj1BiObj2Cons<T2,T1,T3> |
obj1BiObj2Cons(LTriConsumer.LObj1BiObj2Cons<T2,T1,T3> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
static <T2,T3,T1> LTriConsumer.LObj1Obj2Obj0Cons<T2,T3,T1> |
obj1Obj2Obj0Cons(LTriConsumer.LObj1Obj2Obj0Cons<T2,T3,T1> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
static <T3,T1,T2> LTriConsumer.LObj2Obj0Obj1Cons<T3,T1,T2> |
obj2Obj0Obj1Cons(LTriConsumer.LObj2Obj0Obj1Cons<T3,T1,T2> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
static <C,T,T1,T2> |
pairForEach(T target,
IndexedRead<C,aType.a<? extends Object>> ia,
C s,
LTriConsumer<T,T1,T2> consumer) |
static <C,I,T,T1,T2> |
pairIterate(T target,
SequentialRead<C,I,aType.a<? extends Object>> sa,
C s,
LTriConsumer<T,T1,T2> consumer) |
static <T1,T2,T3> LTriConsumer<T1,T2,T3> |
recursive(LFunction<LTriConsumer<T1,T2,T3>,LTriConsumer<T1,T2,T3>> selfLambda) |
default LBiConsumer<T1,T2> |
rShrink(LBiFunction<T1,T2,T3> right) |
default LBiConsumer<T1,T2> |
rShrinkc(T3 a3) |
static <T1,T2,T3> LBiConsumer<T1,T2> |
rShrinked(LBiFunction<T1,T2,T3> right,
LTriConsumer<T1,T2,T3> func) |
static <T1,T2,T3> LBiConsumer<T1,T2> |
rShrinkedc(T3 a3,
LTriConsumer<T1,T2,T3> func) |
static <T1,T2,T3> LTriConsumer<T1,T2,T3> |
safe()
Safe instance.
|
static <T1,T2,T3> LTriConsumer<T1,T2,T3> |
safe(LTriConsumer<T1,T2,T3> other)
Safe wrapping.
|
static <T1,T2,T3> LSupplier<LTriConsumer<T1,T2,T3>> |
safeSupplier()
Safe instance supplier.
|
static <T1,T2,T3> LSupplier<LTriConsumer<T1,T2,T3>> |
safeSupplier(LSupplier<LTriConsumer<T1,T2,T3>> supplier)
Safe supplier.
|
default void |
shovingAccept(T1 a1,
T2 a2,
T3 a3)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
|
static <T1,C2,C3,T2,T3> |
targetedForEach(T1 a1,
IndexedRead<C2,aType.a<T2>> ia2,
C2 source2,
IndexedRead<C3,aType.a<T3>> ia3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static <T1,C2,C3,I3,T2,T3> |
targetedIterate(T1 a1,
IndexedRead<C2,aType.a<T2>> ia2,
C2 source2,
SequentialRead<C3,I3,aType.a<T3>> sa3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static <T1,C2,I2,C3,T2,T3> |
targetedIterate(T1 a1,
SequentialRead<C2,I2,aType.a<T2>> sa2,
C2 source2,
IndexedRead<C3,aType.a<T3>> ia3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static <T1,C2,I2,C3,I3,T2,T3> |
targetedIterate(T1 a1,
SequentialRead<C2,I2,aType.a<T2>> sa2,
C2 source2,
SequentialRead<C3,I3,aType.a<T3>> sa3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static <T1,T2,T3> void |
times(int max_i,
T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func)
From-To.
|
static <T1,T2,T3> LTriConsumer<T1,T2,T3> |
triCons(LTriConsumer<T1,T2,T3> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
static <T1,T2,T3> LTriConsumer<T1,T2,T3> |
triConsThrowing(ExF<Throwable> exF) |
static <T1,T2,T3> LTriConsumer<T1,T2,T3> |
triConsThrowing(String message,
ExMF<Throwable> exF) |
static <T1,T2,T3> void |
tryAccept(T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func) |
static <T1,T2,T3> void |
tryAccept(T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func,
ExWF<RuntimeException> exF) |
static <T1,T2,T3> void |
tryAccept(T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static <T1,T2,T3> void |
tryAcceptThen(T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func,
LConsumer<Throwable> handler) |
default LTriConsumer<T1,T2,T3> |
trying(ExWF<RuntimeException> exF) |
default LTriConsumer<T1,T2,T3> |
trying(ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
default LTriConsumer<T1,T2,T3> |
tryingThen(LConsumer<Throwable> handler) |
default LTuple.Void |
tupleAccept(LTriple<T1,T2,T3> args) |
static <T1,T2,T3> LTriConsumer<T1,T2,T3> |
uncurry(LFunction<T1,LFunction<T2,LConsumer<T3>>> func) |
default LTriConsumer |
untyped()
Cast that removes generics.
|
isConsumerformatTo, isAction, isFunction, isOperator, isPredicate, isSupplierisThrowingstatic final String DESCRIPTION
void acceptX(T1 a1, T2 a2, T3 a3) throws Throwable
Implement this, but call accept(T1 a1,T2 a2,T3 a3)
Throwabledefault LTuple.Void tupleAccept(LTriple<T1,T2,T3> args)
default void handlingAccept(T1 a1, T2 a2, T3 a3, HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
default LTriConsumer<T1,T2,T3> handling(HandlingInstructions<Throwable,RuntimeException> handling)
default void accept(T1 a1, T2 a2, T3 a3, @Nonnull ExWMF<RuntimeException> exF, @Nonnull String newMessage, @Nullable Object... messageParams)
default LTriConsumer<T1,T2,T3> trying(@Nonnull ExWMF<RuntimeException> exF, @Nonnull String newMessage, @Nullable Object... messageParams)
default LTriConsumer<T1,T2,T3> trying(@Nonnull ExWF<RuntimeException> exF)
default void nestingAccept(T1 a1, T2 a2, T3 a3)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default void shovingAccept(T1 a1, T2 a2, T3 a3)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
static <T1,T2,T3> void handlingAccept(T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func,
HandlingInstructions<Throwable,RuntimeException> handling)
static <T1,T2,T3> void tryAccept(T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func)
static <T1,T2,T3> void tryAccept(T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func,
@Nonnull
ExWMF<RuntimeException> exF,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
static <T1,T2,T3> void tryAccept(T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func,
@Nonnull
ExWF<RuntimeException> exF)
static <T1,T2,T3> void tryAcceptThen(T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func,
@Nonnull
LConsumer<Throwable> handler)
default void failSafeAccept(T1 a1, T2 a2, T3 a3, @Nonnull LTriConsumer<T1,T2,T3> failSafe)
static <T1,T2,T3> void failSafeAccept(T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func,
@Nonnull
LTriConsumer<T1,T2,T3> failSafe)
static <T1,T2,T3> LTriConsumer<T1,T2,T3> failSafe(LTriConsumer<T1,T2,T3> func, @Nonnull LTriConsumer<T1,T2,T3> failSafe)
@Nonnull default String functionalInterfaceDescription()
Returns description of the functional interface.
functionalInterfaceDescription in interface MetaFunctionalInterfacestatic <T1,T2,T3> void fromTo(int min_i,
int max_i,
T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func)
From-To. Intended to be used with non-capturing lambda.
static <T1,T2,T3> void fromTill(int min_i,
int max_i,
T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func)
From-To. Intended to be used with non-capturing lambda.
static <T1,T2,T3> void times(int max_i,
T1 a1,
T2 a2,
T3 a3,
LTriConsumer<T1,T2,T3> func)
From-To. Intended to be used with non-capturing lambda.
default LBiConsumer<T2,T3> lShrink(LBiFunction<T2,T3,T1> left)
default LBiConsumer<T2,T3> lShrinkc(T1 a1)
static <T2,T3,T1> LBiConsumer<T2,T3> lShrinked(LBiFunction<T2,T3,T1> left, LTriConsumer<T1,T2,T3> func)
static <T2,T3,T1> LBiConsumer<T2,T3> lShrinkedc(T1 a1, LTriConsumer<T1,T2,T3> func)
default LBiConsumer<T1,T2> rShrink(LBiFunction<T1,T2,T3> right)
default LBiConsumer<T1,T2> rShrinkc(T3 a3)
static <T1,T2,T3> LBiConsumer<T1,T2> rShrinked(LBiFunction<T1,T2,T3> right, LTriConsumer<T1,T2,T3> func)
static <T1,T2,T3> LBiConsumer<T1,T2> rShrinkedc(T3 a3, LTriConsumer<T1,T2,T3> func)
static <T1,T2,T3> LTriConsumer<T1,T2,T3> uncurry(LFunction<T1,LFunction<T2,LConsumer<T3>>> func)
default LTriConsumer untyped()
Cast that removes generics.
default <V2,V3,V4> LTriConsumer<V2,V3,V4> cast()
Cast that replace generics.
static <V2,V3,V4,T1,T2,T3> LTriConsumer<V2,V3,V4> cast(LTriConsumer<T1,T2,T3> function)
Cast that replace generics.
@Nonnull static <T1,T2,T3> LTriConsumer<T1,T2,T3> accept1st(@Nonnull LConsumer<T1> func)
Captures single parameter function into this interface where only 1st parameter will be used.
@Nonnull static <T1,T2,T3> LTriConsumer<T1,T2,T3> accept2nd(@Nonnull LConsumer<T2> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
@Nonnull static <T1,T2,T3> LTriConsumer<T1,T2,T3> accept3rd(@Nonnull LConsumer<T3> func)
Captures single parameter function into this interface where only 3rd parameter will be used.
@Nonnull static <T1,T2,T3> LTriConsumer<T1,T2,T3> triCons(@Nonnull LTriConsumer<T1,T2,T3> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
@Nonnull static <T1,T2,T3> LTriConsumer<T1,T2,T3> recursive(@Nonnull LFunction<LTriConsumer<T1,T2,T3>,LTriConsumer<T1,T2,T3>> selfLambda)
@Nonnull static <T1,T2,T3> LTriConsumer<T1,T2,T3> triConsThrowing(@Nonnull ExF<Throwable> exF)
@Nonnull static <T1,T2,T3> LTriConsumer<T1,T2,T3> triConsThrowing(String message, @Nonnull ExMF<Throwable> exF)
@Nonnull static <T1,T3,T2> LTriConsumer.LObj0Obj2Obj1Cons<T1,T3,T2> obj0Obj2Obj1Cons(@Nonnull LTriConsumer.LObj0Obj2Obj1Cons<T1,T3,T2> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
@Nonnull static <T2,T1,T3> LTriConsumer.LObj1BiObj2Cons<T2,T1,T3> obj1BiObj2Cons(@Nonnull LTriConsumer.LObj1BiObj2Cons<T2,T1,T3> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
@Nonnull static <T2,T3,T1> LTriConsumer.LObj1Obj2Obj0Cons<T2,T3,T1> obj1Obj2Obj0Cons(@Nonnull LTriConsumer.LObj1Obj2Obj0Cons<T2,T3,T1> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
@Nonnull static <T3,T1,T2> LTriConsumer.LObj2Obj0Obj1Cons<T3,T1,T2> obj2Obj0Obj1Cons(@Nonnull LTriConsumer.LObj2Obj0Obj1Cons<T3,T1,T2> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
@Nonnull static <T3,T2,T1> LTriConsumer.LBiObj1Obj0Cons<T3,T2,T1> biObj1Obj0Cons(@Nonnull LTriConsumer.LBiObj1Obj0Cons<T3,T2,T1> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T1,T2,T3> void call(T1 a1,
T2 a2,
T3 a3,
@Nonnull
LTriConsumer<T1,T2,T3> lambda)
@Nonnull static <T1,T2,T3> LTriConsumer<T1,T2,T3> safe()
Safe instance.
@Nonnull static <T1,T2,T3> LSupplier<LTriConsumer<T1,T2,T3>> safeSupplier()
Safe instance supplier. Returns supplier of safe() instance.
@Nonnull static <T1,T2,T3> LTriConsumer<T1,T2,T3> safe(@Nullable LTriConsumer<T1,T2,T3> other)
Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.
@Nonnull static <T1,T2,T3> LSupplier<LTriConsumer<T1,T2,T3>> safeSupplier(@Nullable LSupplier<LTriConsumer<T1,T2,T3>> supplier)
Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.
@Nonnull default <V1,V2,V3> LTriConsumer<V1,V2,V3> compose(@Nonnull LFunction<? super V1,? extends T1> before1, @Nonnull LFunction<? super V2,? extends T2> before2, @Nonnull LFunction<? super V3,? extends T3> before3)
Allows to manipulate the domain of the function.
static <V1,V2,V3,T1,T2,T3> LTriConsumer<V1,V2,V3> composed(@Nonnull LFunction<? super V1,? extends T1> before1, @Nonnull LFunction<? super V2,? extends T2> before2, @Nonnull LFunction<? super V3,? extends T3> before3, LTriConsumer<T1,T2,T3> after)
@Nonnull default LTriConsumer<T1,T2,T3> andThen(@Nonnull LTriConsumer<? super T1,? super T2,? super T3> after)
Combines two LTriConsumer<T1,T2,T3> together in a order.
static <T1,T2,T3> void doNothing(T1 a1,
T2 a2,
T3 a3)
Does nothing (LTriConsumer)
static <C1,C2,C3,T1,T2,T3> int forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
static <C1,I1,C2,C3,T1,T2,T3> int iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
static <C1,C2,I2,C3,T1,T2,T3> int iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
static <C1,I1,C2,I2,C3,T1,T2,T3> int iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
static <C1,C2,C3,I3,T1,T2,T3> int iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
static <C1,I1,C2,C3,I3,T1,T2,T3> int iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
static <C1,C2,I2,C3,I3,T1,T2,T3> int iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
static <C1,I1,C2,I2,C3,I3,T1,T2,T3> int iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.
static <T1,C2,C3,T2,T3> T1 targetedForEach(T1 a1,
IndexedRead<C2,aType.a<T2>> ia2,
C2 source2,
IndexedRead<C3,aType.a<T3>> ia3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer. First argument is designated as ‘target’ object. Thread safety, fail-fast, fail-safety of this method is not expected.
static <T1,C2,I2,C3,T2,T3> T1 targetedIterate(T1 a1,
SequentialRead<C2,I2,aType.a<T2>> sa2,
C2 source2,
IndexedRead<C3,aType.a<T3>> ia3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer. First argument is designated as ‘target’ object. Thread safety, fail-fast, fail-safety of this method is not expected.
static <T1,C2,C3,I3,T2,T3> T1 targetedIterate(T1 a1,
IndexedRead<C2,aType.a<T2>> ia2,
C2 source2,
SequentialRead<C3,I3,aType.a<T3>> sa3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer. First argument is designated as ‘target’ object. Thread safety, fail-fast, fail-safety of this method is not expected.
static <T1,C2,I2,C3,I3,T2,T3> T1 targetedIterate(T1 a1,
SequentialRead<C2,I2,aType.a<T2>> sa2,
C2 source2,
SequentialRead<C3,I3,aType.a<T3>> sa3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer. First argument is designated as ‘target’ object. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.
static <C,T,T1,T2> T pairForEach(T target,
IndexedRead<C,aType.a<? extends Object>> ia,
C s,
LTriConsumer<T,T1,T2> consumer)
static <C,I,T,T1,T2> T pairIterate(T target,
SequentialRead<C,I,aType.a<? extends Object>> sa,
C s,
LTriConsumer<T,T1,T2> consumer)
Copyright © 2019. All rights reserved.