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