@FunctionalInterface public interface LIntBinaryOperator extends java.util.function.IntBinaryOperator, MetaOperator, MetaInterface.NonThrowing, Codomain<aType.aInt>, Domain2<aType.aInt,aType.aInt>
Non-throwing functional interface (lambda) LIntBinaryOperator for Java 8.
Type: operator
Domain (lvl: 2): int a1,int a2
Co-domain: int
| Modifier and Type | Interface and Description |
|---|---|
static class |
LIntBinaryOperator.LIntBinaryOperatorSingle |
MetaInterface.NonThrowing, MetaInterface.Throwing<X>| Modifier and Type | Field and Description |
|---|---|
static String |
DESCRIPTION |
| Modifier and Type | Method and Description |
|---|---|
static LIntBinaryOperator |
apply1stAsInt(LIntUnaryOperator func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static LIntBinaryOperator |
apply2ndAsInt(LIntUnaryOperator func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
default int |
applyAsInt(int a1,
int a2) |
default int |
applyAsInt(int a1,
int a2,
ExWF<RuntimeException> exF) |
default int |
applyAsInt(int a1,
int a2,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
default int |
applyAsIntThen(int a1,
int a2,
LToIntFunction<Throwable> handler) |
int |
applyAsIntX(int a1,
int a2)
Implement this, but call applyAsInt(int a1,int a2)
|
static int |
call(int a1,
int a2,
LIntBinaryOperator lambda) |
default LIntSupplier |
capture(int a1,
int a2)
Captures arguments but delays the evaluation.
|
default LIntBinaryOperator |
compose(LIntUnaryOperator before1,
LIntUnaryOperator before2)
Allows to manipulate the domain of the function.
|
static LIntBinaryOperator |
composed(LIntUnaryOperator before1,
LIntUnaryOperator before2,
LIntBinaryOperator after) |
static <V1,V2> LToIntBiFunction<V1,V2> |
composed(LToIntFunction<? super V1> before1,
LToIntFunction<? super V2> before2,
LIntBinaryOperator after) |
static LIntBinaryOperator |
constant(int r)
Creates function that always returns the same value.
|
static LIntBinaryOperator |
failSafe(LIntBinaryOperator func,
LIntBinaryOperator failSafe) |
default int |
failSafeApplyAsInt(int a1,
int a2,
LIntBinaryOperator failSafe) |
static int |
failSafeApplyAsInt(int a1,
int a2,
LIntBinaryOperator func,
LIntBinaryOperator failSafe) |
default <C1,C2> void |
forEach(IndexedRead<C1,aType.aInt> ia1,
C1 source1,
IndexedRead<C2,aType.aInt> ia2,
C2 source2,
LIntConsumer consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer.
|
static void |
fromTill(int min_i,
int max_i,
int a1,
int a2,
LIntBinaryOperator func)
From-To.
|
static void |
fromTo(int min_i,
int max_i,
int a1,
int a2,
LIntBinaryOperator func)
From-To.
|
default String |
functionalInterfaceDescription()
Returns description of the functional interface.
|
default LIntBinaryOperator |
handling(HandlingInstructions<Throwable,RuntimeException> handling) |
default int |
handlingApplyAsInt(int a1,
int a2,
HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
|
static int |
handlingApplyAsInt(int a1,
int a2,
LIntBinaryOperator func,
HandlingInstructions<Throwable,RuntimeException> handling) |
static LIntBinaryOperator |
intBinaryOp(LIntBinaryOperator lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
default <V1,V2> LToIntBiFunction<V1,V2> |
intBinaryOpCompose(LToIntFunction<? super V1> before1,
LToIntFunction<? super V2> before2)
Allows to manipulate the domain of the function.
|
static LIntBinaryOperator |
intBinaryOpThrowing(ExF<Throwable> exF) |
static LIntBinaryOperator |
intBinaryOpThrowing(String message,
ExMF<Throwable> exF) |
default <C1,C2,I2> void |
iterate(IndexedRead<C1,aType.aInt> ia1,
C1 source1,
SequentialRead<C2,I2,aType.aInt> sa2,
C2 source2,
LIntConsumer consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer.
|
default <C1,I1,C2> void |
iterate(SequentialRead<C1,I1,aType.aInt> sa1,
C1 source1,
IndexedRead<C2,aType.aInt> ia2,
C2 source2,
LIntConsumer consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer.
|
default <C1,I1,C2,I2> |
iterate(SequentialRead<C1,I1,aType.aInt> sa1,
C1 source1,
SequentialRead<C2,I2,aType.aInt> sa2,
C2 source2,
LIntConsumer consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer.
|
default LIntUnaryOperator |
lShrink(LIntUnaryOperator left) |
default LIntUnaryOperator |
lShrinkc(int a1) |
static LIntUnaryOperator |
lShrinked(LIntUnaryOperator left,
LIntBinaryOperator func) |
static LIntUnaryOperator |
lShrinkedc(int a1,
LIntBinaryOperator func) |
static LIntBinaryOperator |
max()
Returns function that returns the higher value.
|
static LIntBinaryOperator |
maxBy(Comparator<Integer> comparator)
Creates function that returns the lesser value according to the comparator.
|
static LIntBinaryOperator |
min()
Returns function that returns the lower value.
|
static LIntBinaryOperator |
minBy(Comparator<Integer> comparator)
Creates function that returns the lesser value according to the comparator.
|
default int |
nestingApplyAsInt(int a1,
int a2)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
|
default int |
nonNullApplyAsInt(int a1,
int a2)
Just to mirror the method: Ensures the result is not null
|
static int |
produceInt(int a1,
int a2)
Does nothing (LIntBinaryOperator) Operator
|
static LIntBinaryOperator |
recursive(LFunction<LIntBinaryOperator,LIntBinaryOperator> selfLambda) |
default LIntUnaryOperator |
rShrink(LIntUnaryOperator right) |
default LIntUnaryOperator |
rShrinkc(int a2) |
static LIntUnaryOperator |
rShrinked(LIntUnaryOperator right,
LIntBinaryOperator func) |
static LIntUnaryOperator |
rShrinkedc(int a2,
LIntBinaryOperator func) |
static LIntBinaryOperator |
safe()
Safe instance.
|
static LIntBinaryOperator |
safe(LIntBinaryOperator other)
Safe wrapping.
|
static LSupplier<LIntBinaryOperator> |
safeSupplier()
Safe instance supplier.
|
static LSupplier<LIntBinaryOperator> |
safeSupplier(LSupplier<LIntBinaryOperator> supplier)
Safe supplier.
|
default int |
shovingApplyAsInt(int a1,
int a2)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
|
default <V> LBiIntFunction<V> |
then(LIntFunction<? extends V> after)
Combines two functions together in a order.
|
default LBiIntPredicate |
thenToBool(LIntPredicate after)
Combines two functions together in a order.
|
default LIntBinaryOperator |
thenToInt(LIntUnaryOperator after)
Combines two functions together in a order.
|
static void |
times(int max_i,
int a1,
int a2,
LIntBinaryOperator func)
From-To.
|
static int |
tryApplyAsInt(int a1,
int a2,
LIntBinaryOperator func) |
static int |
tryApplyAsInt(int a1,
int a2,
LIntBinaryOperator func,
ExWF<RuntimeException> exF) |
static int |
tryApplyAsInt(int a1,
int a2,
LIntBinaryOperator func,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static int |
tryApplyAsIntThen(int a1,
int a2,
LIntBinaryOperator func,
LToIntFunction<Throwable> handler) |
default LIntBinaryOperator |
trying(ExWF<RuntimeException> exF) |
default LIntBinaryOperator |
trying(ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
default LIntBinaryOperator |
tryingThen(LToIntFunction<Throwable> handler) |
default int |
tupleApplyAsInt(LIntPair args) |
static LIntBinaryOperator |
uncurry(LIntFunction<LIntUnaryOperator> func) |
static LIntBinaryOperator |
wrap(java.util.function.IntBinaryOperator other)
Wraps JRE instance.
|
isOperatorisFunctionformatTo, isAction, isConsumer, isPredicate, isSupplierisThrowingisThrowingstatic final String DESCRIPTION
default int applyAsInt(int a1,
int a2)
applyAsInt in interface java.util.function.IntBinaryOperatorint applyAsIntX(int a1,
int a2)
throws Throwable
Implement this, but call applyAsInt(int a1,int a2)
Throwabledefault int tupleApplyAsInt(LIntPair args)
default int handlingApplyAsInt(int a1,
int a2,
HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
default LIntBinaryOperator handling(HandlingInstructions<Throwable,RuntimeException> handling)
default int applyAsInt(int a1,
int a2,
@Nonnull
ExWMF<RuntimeException> exF,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
default LIntBinaryOperator trying(@Nonnull ExWMF<RuntimeException> exF, @Nonnull String newMessage, @Nullable Object... messageParams)
default int applyAsInt(int a1,
int a2,
@Nonnull
ExWF<RuntimeException> exF)
default LIntBinaryOperator trying(@Nonnull ExWF<RuntimeException> exF)
default int applyAsIntThen(int a1,
int a2,
@Nonnull
LToIntFunction<Throwable> handler)
default LIntBinaryOperator tryingThen(@Nonnull LToIntFunction<Throwable> handler)
default int nestingApplyAsInt(int a1,
int a2)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default int shovingApplyAsInt(int a1,
int a2)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
static int handlingApplyAsInt(int a1,
int a2,
LIntBinaryOperator func,
HandlingInstructions<Throwable,RuntimeException> handling)
static int tryApplyAsInt(int a1,
int a2,
LIntBinaryOperator func)
static int tryApplyAsInt(int a1,
int a2,
LIntBinaryOperator func,
@Nonnull
ExWMF<RuntimeException> exF,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
static int tryApplyAsInt(int a1,
int a2,
LIntBinaryOperator func,
@Nonnull
ExWF<RuntimeException> exF)
static int tryApplyAsIntThen(int a1,
int a2,
LIntBinaryOperator func,
@Nonnull
LToIntFunction<Throwable> handler)
default int failSafeApplyAsInt(int a1,
int a2,
@Nonnull
LIntBinaryOperator failSafe)
static int failSafeApplyAsInt(int a1,
int a2,
LIntBinaryOperator func,
@Nonnull
LIntBinaryOperator failSafe)
static LIntBinaryOperator failSafe(LIntBinaryOperator func, @Nonnull LIntBinaryOperator failSafe)
default int nonNullApplyAsInt(int a1,
int a2)
Just to mirror the method: Ensures the result is not null
@Nonnull default String functionalInterfaceDescription()
Returns description of the functional interface.
functionalInterfaceDescription in interface MetaFunctionalInterfacestatic void fromTo(int min_i,
int max_i,
int a1,
int a2,
LIntBinaryOperator func)
From-To. Intended to be used with non-capturing lambda.
static void fromTill(int min_i,
int max_i,
int a1,
int a2,
LIntBinaryOperator func)
From-To. Intended to be used with non-capturing lambda.
static void times(int max_i,
int a1,
int a2,
LIntBinaryOperator func)
From-To. Intended to be used with non-capturing lambda.
default LIntUnaryOperator lShrink(LIntUnaryOperator left)
default LIntUnaryOperator lShrinkc(int a1)
static LIntUnaryOperator lShrinked(LIntUnaryOperator left, LIntBinaryOperator func)
static LIntUnaryOperator lShrinkedc(int a1, LIntBinaryOperator func)
default LIntUnaryOperator rShrink(LIntUnaryOperator right)
default LIntUnaryOperator rShrinkc(int a2)
static LIntUnaryOperator rShrinked(LIntUnaryOperator right, LIntBinaryOperator func)
static LIntUnaryOperator rShrinkedc(int a2, LIntBinaryOperator func)
static LIntBinaryOperator uncurry(LIntFunction<LIntUnaryOperator> func)
default LIntSupplier capture(int a1, int a2)
Captures arguments but delays the evaluation.
static LIntBinaryOperator constant(int r)
Creates function that always returns the same value.
@Nonnull static LIntBinaryOperator apply1stAsInt(@Nonnull LIntUnaryOperator func)
Captures single parameter function into this interface where only 1st parameter will be used.
@Nonnull static LIntBinaryOperator apply2ndAsInt(@Nonnull LIntUnaryOperator func)
Captures single parameter function into this interface where only 2nd parameter will be used.
@Nonnull static LIntBinaryOperator intBinaryOp(@Nonnull LIntBinaryOperator lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
@Nonnull static LIntBinaryOperator recursive(@Nonnull LFunction<LIntBinaryOperator,LIntBinaryOperator> selfLambda)
@Nonnull static LIntBinaryOperator intBinaryOpThrowing(@Nonnull ExF<Throwable> exF)
@Nonnull static LIntBinaryOperator intBinaryOpThrowing(String message, @Nonnull ExMF<Throwable> exF)
static int call(int a1,
int a2,
@Nonnull
LIntBinaryOperator lambda)
@Nonnull static LIntBinaryOperator wrap(java.util.function.IntBinaryOperator other)
Wraps JRE instance.
@Nonnull static LIntBinaryOperator safe()
Safe instance. That always returns the same value (as produceInt).
@Nonnull static LSupplier<LIntBinaryOperator> safeSupplier()
Safe instance supplier. Returns supplier of safe() instance.
@Nonnull static LIntBinaryOperator safe(@Nullable LIntBinaryOperator other)
Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.
@Nonnull static LSupplier<LIntBinaryOperator> safeSupplier(@Nullable LSupplier<LIntBinaryOperator> supplier)
Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.
@Nonnull static LIntBinaryOperator minBy(@Nonnull Comparator<Integer> comparator)
Creates function that returns the lesser value according to the comparator.
java.util.function.BinaryOperator#minBy}@Nonnull static LIntBinaryOperator maxBy(@Nonnull Comparator<Integer> comparator)
Creates function that returns the lesser value according to the comparator.
java.util.function.BinaryOperator#maxBy}@Nonnull static LIntBinaryOperator min()
Returns function that returns the lower value.
java.util.function.BinaryOperator#minBy}@Nonnull static LIntBinaryOperator max()
Returns function that returns the higher value.
java.util.function.BinaryOperator#maxBy}@Nonnull default LIntBinaryOperator compose(@Nonnull LIntUnaryOperator before1, @Nonnull LIntUnaryOperator before2)
Allows to manipulate the domain of the function.
static LIntBinaryOperator composed(@Nonnull LIntUnaryOperator before1, @Nonnull LIntUnaryOperator before2, LIntBinaryOperator after)
@Nonnull default <V1,V2> LToIntBiFunction<V1,V2> intBinaryOpCompose(@Nonnull LToIntFunction<? super V1> before1, @Nonnull LToIntFunction<? super V2> before2)
Allows to manipulate the domain of the function.
static <V1,V2> LToIntBiFunction<V1,V2> composed(@Nonnull LToIntFunction<? super V1> before1, @Nonnull LToIntFunction<? super V2> before2, LIntBinaryOperator after)
@Nonnull default <V> LBiIntFunction<V> then(@Nonnull LIntFunction<? extends V> after)
Combines two functions together in a order.
@Nonnull default LIntBinaryOperator thenToInt(@Nonnull LIntUnaryOperator after)
Combines two functions together in a order.
@Nonnull default LBiIntPredicate thenToBool(@Nonnull LIntPredicate after)
Combines two functions together in a order.
static int produceInt(int a1,
int a2)
Does nothing (LIntBinaryOperator) Operator
default <C1,C2> void forEach(IndexedRead<C1,aType.aInt> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LIntConsumer consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
default <C1,I1,C2> void iterate(SequentialRead<C1,I1,aType.aInt> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LIntConsumer consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
default <C1,C2,I2> void iterate(IndexedRead<C1,aType.aInt> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LIntConsumer consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
default <C1,I1,C2,I2> void iterate(SequentialRead<C1,I1,aType.aInt> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LIntConsumer consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.
Copyright © 2019. All rights reserved.