@FunctionalInterface public interface LBiLongFunction<R> extends MetaFunction, MetaInterface.NonThrowing, Codomain<aType.a<R>>, Domain2<aType.aLong,aType.aLong>
Non-throwing functional interface (lambda) LBiLongFunction for Java 8.
Type: function
Domain (lvl: 2): long a1,long a2
Co-domain: R
| Modifier and Type | Interface and Description |
|---|---|
static class |
LBiLongFunction.LBiLongFunctionSingle<R> |
static interface |
LBiLongFunction.LLong1Long0Func<R>
Permutation of LBiLongFunction for method references.
|
MetaInterface.NonThrowing, MetaInterface.Throwing<X>| Modifier and Type | Field and Description |
|---|---|
static String |
DESCRIPTION |
static LSupplier<String> |
NULL_VALUE_MESSAGE_SUPPLIER |
| Modifier and Type | Method and Description |
|---|---|
default LBiLongFunction<R> |
after(LConsumer<? super R> after) |
default R |
apply(long a1,
long a2) |
default R |
apply(long a1,
long a2,
ExWF<RuntimeException> exF) |
default R |
apply(long a1,
long a2,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static <R> LBiLongFunction<R> |
apply1st(LLongFunction<R> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <R> LBiLongFunction<R> |
apply2nd(LLongFunction<R> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
default R |
applyThen(long a1,
long a2,
LFunction<Throwable,R> handler) |
R |
applyX(long a1,
long a2)
Implement this, but call apply(long a1,long a2)
|
default LBiLongFunction<R> |
before(LBiLongConsumer before) |
static <R> LBiLongFunction<R> |
biLongFunc(LBiLongFunction<R> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
default <V1,V2> LBiFunction<V1,V2,R> |
biLongFuncCompose(LToLongFunction<? super V1> before1,
LToLongFunction<? super V2> before2)
Allows to manipulate the domain of the function.
|
static <R> LBiLongFunction<R> |
biLongFuncThrowing(ExF<Throwable> exF) |
static <R> LBiLongFunction<R> |
biLongFuncThrowing(String message,
ExMF<Throwable> exF) |
static <R> R |
call(long a1,
long a2,
LBiLongFunction<R> lambda) |
default LSupplier<R> |
capture(long a1,
long a2)
Captures arguments but delays the evaluation.
|
default <V2> LBiLongFunction<V2> |
cast()
Cast that replace generics.
|
static <V2,R> LBiLongFunction<V2> |
cast(LBiLongFunction<R> function)
Cast that replace generics.
|
default LBiLongFunction<R> |
compose(LLongUnaryOperator before1,
LLongUnaryOperator before2)
Allows to manipulate the domain of the function.
|
static <R> LBiLongFunction<R> |
composed(LLongUnaryOperator before1,
LLongUnaryOperator before2,
LBiLongFunction<R> after) |
static <V1,V2,R> LBiFunction<V1,V2,R> |
composed(LToLongFunction<? super V1> before1,
LToLongFunction<? super V2> before2,
LBiLongFunction<R> after) |
static <R> LBiLongFunction<R> |
constant(R r)
Creates function that always returns the same value.
|
static <R> LBiLongFunction<R> |
failSafe(LBiLongFunction<R> func,
LBiLongFunction<R> failSafe) |
default R |
failSafeApply(long a1,
long a2,
LBiLongFunction<R> failSafe) |
static <R> R |
failSafeApply(long a1,
long a2,
LBiLongFunction<R> func,
LBiLongFunction<R> failSafe) |
default <C1,C2> void |
forEach(IndexedRead<C1,aType.aLong> ia1,
C1 source1,
IndexedRead<C2,aType.aLong> ia2,
C2 source2,
LConsumer<? super R> consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer.
|
static <R> void |
fromTill(int min_i,
int max_i,
long a1,
long a2,
LBiLongFunction<R> func)
From-To.
|
static <R> void |
fromTo(int min_i,
int max_i,
long a1,
long a2,
LBiLongFunction<R> func)
From-To.
|
default String |
functionalInterfaceDescription()
Returns description of the functional interface.
|
default LBiLongFunction<R> |
handling(HandlingInstructions<Throwable,RuntimeException> handling) |
default R |
handlingApply(long a1,
long a2,
HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
|
static <R> R |
handlingApply(long a1,
long a2,
LBiLongFunction<R> func,
HandlingInstructions<Throwable,RuntimeException> handling) |
default <C1,C2,I2> void |
iterate(IndexedRead<C1,aType.aLong> ia1,
C1 source1,
SequentialRead<C2,I2,aType.aLong> sa2,
C2 source2,
LConsumer<? super R> 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.aLong> sa1,
C1 source1,
IndexedRead<C2,aType.aLong> ia2,
C2 source2,
LConsumer<? super R> 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.aLong> sa1,
C1 source1,
SequentialRead<C2,I2,aType.aLong> sa2,
C2 source2,
LConsumer<? super R> consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer.
|
static <R> LBiLongFunction.LLong1Long0Func<R> |
long1Long0Func(LBiLongFunction.LLong1Long0Func<R> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
default LLongFunction<R> |
lShrink(LLongUnaryOperator left) |
default LLongFunction<R> |
lShrinkc(long a1) |
static <R> LLongFunction<R> |
lShrinked(LLongUnaryOperator left,
LBiLongFunction<R> func) |
static <R> LLongFunction<R> |
lShrinkedc(long a1,
LBiLongFunction<R> func) |
default R |
nestingApply(long a1,
long a2)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
|
default LBiLongFunction<R> |
nonNullable()
Converts to function that makes sure that the result is not null.
|
default R |
nonNullApply(long a1,
long a2)
Function call that ensures the result is not null
|
static <R> R |
produce(long a1,
long a2)
Does nothing (LBiLongFunction) Function
|
static <R> LBiLongFunction<R> |
recursive(LFunction<LBiLongFunction<R>,LBiLongFunction<R>> selfLambda) |
default LLongFunction<R> |
rShrink(LLongUnaryOperator right) |
default LLongFunction<R> |
rShrinkc(long a2) |
static <R> LLongFunction<R> |
rShrinked(LLongUnaryOperator right,
LBiLongFunction<R> func) |
static <R> LLongFunction<R> |
rShrinkedc(long a2,
LBiLongFunction<R> func) |
static <R> LBiLongFunction<R> |
safe()
Safe instance.
|
static <R> LBiLongFunction<R> |
safe(LBiLongFunction<R> other)
Safe wrapping.
|
static <R> LSupplier<LBiLongFunction<R>> |
safeSupplier()
Safe instance supplier.
|
static <R> LSupplier<LBiLongFunction<R>> |
safeSupplier(LSupplier<LBiLongFunction<R>> supplier)
Safe supplier.
|
default R |
shovingApply(long a1,
long a2)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
|
default <V> LBiLongFunction<V> |
then(LFunction<? super R,? extends V> after)
Combines two functions together in a order.
|
default LBiLongConsumer |
thenConsume(LConsumer<? super R> after)
Combines two functions together in a order.
|
default LBiLongPredicate |
thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LLongBinaryOperator |
thenToLong(LToLongFunction<? super R> after)
Combines two functions together in a order.
|
static <R> void |
times(int max_i,
long a1,
long a2,
LBiLongFunction<R> func)
From-To.
|
static <R> R |
tryApply(long a1,
long a2,
LBiLongFunction<R> func) |
static <R> R |
tryApply(long a1,
long a2,
LBiLongFunction<R> func,
ExWF<RuntimeException> exF) |
static <R> R |
tryApply(long a1,
long a2,
LBiLongFunction<R> func,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static <R> R |
tryApplyThen(long a1,
long a2,
LBiLongFunction<R> func,
LFunction<Throwable,R> handler) |
default LBiLongFunction<R> |
trying(ExWF<RuntimeException> exF) |
default LBiLongFunction<R> |
trying(ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
default LBiLongFunction<R> |
tryingThen(LFunction<Throwable,R> handler) |
default R |
tupleApply(LLongPair args) |
static <R> LBiLongFunction<R> |
uncurry(LLongFunction<LLongFunction<R>> func) |
default LBiLongFunction |
untyped()
Cast that removes generics.
|
isFunctionformatTo, isAction, isConsumer, isOperator, isPredicate, isSupplierisThrowingstatic final String DESCRIPTION
R applyX(long a1, long a2) throws Throwable
Implement this, but call apply(long a1,long a2)
Throwabledefault R handlingApply(long a1, long a2, HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
default LBiLongFunction<R> handling(HandlingInstructions<Throwable,RuntimeException> handling)
default R apply(long a1, long a2, @Nonnull ExWMF<RuntimeException> exF, @Nonnull String newMessage, @Nullable Object... messageParams)
default LBiLongFunction<R> trying(@Nonnull ExWMF<RuntimeException> exF, @Nonnull String newMessage, @Nullable Object... messageParams)
default R apply(long a1, long a2, @Nonnull ExWF<RuntimeException> exF)
default LBiLongFunction<R> trying(@Nonnull ExWF<RuntimeException> exF)
default R nestingApply(long a1, long a2)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default R shovingApply(long a1, long a2)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
static <R> R handlingApply(long a1,
long a2,
LBiLongFunction<R> func,
HandlingInstructions<Throwable,RuntimeException> handling)
static <R> R tryApply(long a1,
long a2,
LBiLongFunction<R> func)
static <R> R tryApply(long a1,
long a2,
LBiLongFunction<R> func,
@Nonnull
ExWMF<RuntimeException> exF,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
static <R> R tryApply(long a1,
long a2,
LBiLongFunction<R> func,
@Nonnull
ExWF<RuntimeException> exF)
static <R> R tryApplyThen(long a1,
long a2,
LBiLongFunction<R> func,
@Nonnull
LFunction<Throwable,R> handler)
default R failSafeApply(long a1, long a2, @Nonnull LBiLongFunction<R> failSafe)
static <R> R failSafeApply(long a1,
long a2,
LBiLongFunction<R> func,
@Nonnull
LBiLongFunction<R> failSafe)
static <R> LBiLongFunction<R> failSafe(LBiLongFunction<R> func, @Nonnull LBiLongFunction<R> failSafe)
@Nonnull default R nonNullApply(long a1, long a2)
Function call that ensures the result is not null
@Nonnull default String functionalInterfaceDescription()
Returns description of the functional interface.
functionalInterfaceDescription in interface MetaFunctionalInterfacestatic <R> void fromTo(int min_i,
int max_i,
long a1,
long a2,
LBiLongFunction<R> func)
From-To. Intended to be used with non-capturing lambda.
static <R> void fromTill(int min_i,
int max_i,
long a1,
long a2,
LBiLongFunction<R> func)
From-To. Intended to be used with non-capturing lambda.
static <R> void times(int max_i,
long a1,
long a2,
LBiLongFunction<R> func)
From-To. Intended to be used with non-capturing lambda.
default LLongFunction<R> lShrink(LLongUnaryOperator left)
default LLongFunction<R> lShrinkc(long a1)
static <R> LLongFunction<R> lShrinked(LLongUnaryOperator left, LBiLongFunction<R> func)
static <R> LLongFunction<R> lShrinkedc(long a1, LBiLongFunction<R> func)
default LLongFunction<R> rShrink(LLongUnaryOperator right)
default LLongFunction<R> rShrinkc(long a2)
static <R> LLongFunction<R> rShrinked(LLongUnaryOperator right, LBiLongFunction<R> func)
static <R> LLongFunction<R> rShrinkedc(long a2, LBiLongFunction<R> func)
static <R> LBiLongFunction<R> uncurry(LLongFunction<LLongFunction<R>> func)
default LBiLongFunction untyped()
Cast that removes generics.
default <V2> LBiLongFunction<V2> cast()
Cast that replace generics.
static <V2,R> LBiLongFunction<V2> cast(LBiLongFunction<R> function)
Cast that replace generics.
default LSupplier<R> capture(long a1, long a2)
Captures arguments but delays the evaluation.
static <R> LBiLongFunction<R> constant(R r)
Creates function that always returns the same value.
@Nonnull static <R> LBiLongFunction<R> apply1st(@Nonnull LLongFunction<R> func)
Captures single parameter function into this interface where only 1st parameter will be used.
@Nonnull static <R> LBiLongFunction<R> apply2nd(@Nonnull LLongFunction<R> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
@Nonnull static <R> LBiLongFunction<R> biLongFunc(@Nonnull LBiLongFunction<R> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
@Nonnull static <R> LBiLongFunction<R> recursive(@Nonnull LFunction<LBiLongFunction<R>,LBiLongFunction<R>> selfLambda)
@Nonnull static <R> LBiLongFunction<R> biLongFuncThrowing(@Nonnull ExF<Throwable> exF)
@Nonnull static <R> LBiLongFunction<R> biLongFuncThrowing(String message, @Nonnull ExMF<Throwable> exF)
@Nonnull static <R> LBiLongFunction.LLong1Long0Func<R> long1Long0Func(@Nonnull LBiLongFunction.LLong1Long0Func<R> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <R> R call(long a1,
long a2,
@Nonnull
LBiLongFunction<R> lambda)
@Nonnull static <R> LBiLongFunction<R> safe()
Safe instance. That always returns the same value (as produce).
@Nonnull static <R> LSupplier<LBiLongFunction<R>> safeSupplier()
Safe instance supplier. Returns supplier of safe() instance.
@Nonnull static <R> LBiLongFunction<R> safe(@Nullable LBiLongFunction<R> other)
Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.
@Nonnull static <R> LSupplier<LBiLongFunction<R>> safeSupplier(@Nullable LSupplier<LBiLongFunction<R>> supplier)
Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.
@Nonnull default LBiLongFunction<R> compose(@Nonnull LLongUnaryOperator before1, @Nonnull LLongUnaryOperator before2)
Allows to manipulate the domain of the function.
static <R> LBiLongFunction<R> composed(@Nonnull LLongUnaryOperator before1, @Nonnull LLongUnaryOperator before2, LBiLongFunction<R> after)
@Nonnull default <V1,V2> LBiFunction<V1,V2,R> biLongFuncCompose(@Nonnull LToLongFunction<? super V1> before1, @Nonnull LToLongFunction<? super V2> before2)
Allows to manipulate the domain of the function.
static <V1,V2,R> LBiFunction<V1,V2,R> composed(@Nonnull LToLongFunction<? super V1> before1, @Nonnull LToLongFunction<? super V2> before2, LBiLongFunction<R> after)
@Nonnull default <V> LBiLongFunction<V> then(@Nonnull LFunction<? super R,? extends V> after)
Combines two functions together in a order.
@Nonnull default LBiLongConsumer thenConsume(@Nonnull LConsumer<? super R> after)
Combines two functions together in a order.
@Nonnull default LBiLongFunction<R> before(@Nonnull LBiLongConsumer before)
@Nonnull default LLongBinaryOperator thenToLong(@Nonnull LToLongFunction<? super R> after)
Combines two functions together in a order.
@Nonnull default LBiLongPredicate thenToBool(@Nonnull LPredicate<? super R> after)
Combines two functions together in a order.
@Nonnull default LBiLongFunction<R> nonNullable()
Converts to function that makes sure that the result is not null.
static <R> R produce(long a1,
long a2)
Does nothing (LBiLongFunction) Function
default <C1,C2> void forEach(IndexedRead<C1,aType.aLong> ia1, C1 source1, IndexedRead<C2,aType.aLong> ia2, C2 source2, LConsumer<? super R> 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.aLong> sa1, C1 source1, IndexedRead<C2,aType.aLong> ia2, C2 source2, LConsumer<? super R> 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.aLong> ia1, C1 source1, SequentialRead<C2,I2,aType.aLong> sa2, C2 source2, LConsumer<? super R> 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.aLong> sa1, C1 source1, SequentialRead<C2,I2,aType.aLong> sa2, C2 source2, LConsumer<? super R> 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.