eu.lunisolar.magma.func.function.conversion

Interface LBoolToByteFunction

All Superinterfaces:

Codomain<aType.aByte>, Domain, Domain1<aType.aBool>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>

All Known Implementing Classes:

LBoolToByteFunction.LBoolToByteFunctionSingle

@FunctionalInterface
public interface LBoolToByteFunction
extends MetaFunction, MetaInterface.NonThrowing, Codomain<aType.aByte>, Domain1<aType.aBool>

Non-throwing functional interface (lambda) LBoolToByteFunction for Java 8.

Type: function

Domain (lvl: 1): boolean a

Co-domain: byte

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LBoolToByteFunction.LBoolToByteFunctionSingle

Nested classes/interfaces inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface

MetaInterface.NonThrowing, MetaInterface.Throwing<X>

Field Summary

Fields

Modifier and Type	Field and Description
static String	DESCRIPTION

Method Summary

Modifier and Type	Method and Description
default byte	applyAsByte(boolean a)
default byte	applyAsByte(boolean a, ExWF<RuntimeException> exF)
default byte	applyAsByte(boolean a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default byte	applyAsByteThen(boolean a, LToByteFunction<Throwable> handler)
byte	applyAsByteX(boolean a) Implement this, but call applyAsByte(boolean a)
static LBoolToByteFunction	boolToByteFunc(LBoolToByteFunction lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V> LToByteFunction<V>	boolToByteFuncCompose(LPredicate<? super V> before) Allows to manipulate the domain of the function.
static LBoolToByteFunction	boolToByteFuncThrowing(ExF<Throwable> exF)
static LBoolToByteFunction	boolToByteFuncThrowing(String message, ExMF<Throwable> exF)
static byte	call(boolean a, LBoolToByteFunction lambda)
default LByteSupplier	capture(boolean a) Captures arguments but delays the evaluation.
default LBoolToByteFunction	compose(LLogicalOperator before) Allows to manipulate the domain of the function.
static LBoolToByteFunction	composed(LLogicalOperator before, LBoolToByteFunction after)
static <V> LToByteFunction<V>	composed(LPredicate<? super V> before, LBoolToByteFunction after)
static LBoolToByteFunction	constant(byte r) Creates function that always returns the same value.
static LBoolToByteFunction	failSafe(LBoolToByteFunction func, LBoolToByteFunction failSafe)
default byte	failSafeApplyAsByte(boolean a, LBoolToByteFunction failSafe)
static byte	failSafeApplyAsByte(boolean a, LBoolToByteFunction func, LBoolToByteFunction failSafe)
default <C0> void	forEach(IndexedRead<C0,aType.aBool> ia, C0 source, LByteConsumer 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, boolean a, LBoolToByteFunction func) From-To.
static void	fromTo(int min_i, int max_i, boolean a, LBoolToByteFunction func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LBoolToByteFunction	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default byte	handlingApplyAsByte(boolean a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static byte	handlingApplyAsByte(boolean a, LBoolToByteFunction func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aBool> sa, C0 source, LByteConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default byte	nestingApplyAsByte(boolean a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default byte	nonNullApplyAsByte(boolean a) Just to mirror the method: Ensures the result is not null
static byte	produceByte(boolean a) Does nothing (LBoolToByteFunction) Function
static LBoolToByteFunction	recursive(LFunction<LBoolToByteFunction,LBoolToByteFunction> selfLambda)
static LBoolToByteFunction	safe() Safe instance.
static LBoolToByteFunction	safe(LBoolToByteFunction other) Safe wrapping.
static LSupplier<LBoolToByteFunction>	safeSupplier() Safe instance supplier.
static LSupplier<LBoolToByteFunction>	safeSupplier(LSupplier<LBoolToByteFunction> supplier) Safe supplier.
default byte	shovingApplyAsByte(boolean a) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default <V> LBoolFunction<V>	then(LByteFunction<? extends V> after) Combines two functions together in a order.
default LLogicalOperator	thenToBool(LBytePredicate after) Combines two functions together in a order.
default LBoolToByteFunction	thenToByte(LByteUnaryOperator after) Combines two functions together in a order.
default LBoolToCharFunction	thenToChar(LByteToCharFunction after) Combines two functions together in a order.
default LBoolToDblFunction	thenToDbl(LByteToDblFunction after) Combines two functions together in a order.
default LBoolToFltFunction	thenToFlt(LByteToFltFunction after) Combines two functions together in a order.
default LBoolToIntFunction	thenToInt(LByteToIntFunction after) Combines two functions together in a order.
default LBoolToLongFunction	thenToLong(LByteToLongFunction after) Combines two functions together in a order.
default LBoolToSrtFunction	thenToSrt(LByteToSrtFunction after) Combines two functions together in a order.
static void	times(int max_i, boolean a, LBoolToByteFunction func) From-To.
static byte	tryApplyAsByte(boolean a, LBoolToByteFunction func)
static byte	tryApplyAsByte(boolean a, LBoolToByteFunction func, ExWF<RuntimeException> exF)
static byte	tryApplyAsByte(boolean a, LBoolToByteFunction func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static byte	tryApplyAsByteThen(boolean a, LBoolToByteFunction func, LToByteFunction<Throwable> handler)
default LBoolToByteFunction	trying(ExWF<RuntimeException> exF)
default LBoolToByteFunction	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LBoolToByteFunction	tryingThen(LToByteFunction<Throwable> handler)
default byte	tupleApplyAsByte(LBoolSingle args)

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaFunction

isFunction

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.MetaFunctionalInterface

formatTo, isAction, isConsumer, isOperator, isPredicate, isSupplier

Methods inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface.NonThrowing

isThrowing

Field Detail

DESCRIPTION

static final String DESCRIPTION

See Also:

Constant Field Values

Method Detail

applyAsByte

default byte applyAsByte(boolean a)

applyAsByteX

byte applyAsByteX(boolean a)
           throws Throwable

Implement this, but call applyAsByte(boolean a)

Throws:

Throwable

tupleApplyAsByte

default byte tupleApplyAsByte(LBoolSingle args)

handlingApplyAsByte

default byte handlingApplyAsByte(boolean a,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

default LBoolToByteFunction handling(HandlingInstructions<Throwable,RuntimeException> handling)

applyAsByte

default byte applyAsByte(boolean a,
                         @Nonnull
                         ExWMF<RuntimeException> exF,
                         @Nonnull
                         String newMessage,
                         @Nullable
                         Object... messageParams)

trying

default LBoolToByteFunction trying(@Nonnull
                                   ExWMF<RuntimeException> exF,
                                   @Nonnull
                                   String newMessage,
                                   @Nullable
                                   Object... messageParams)

applyAsByte

default byte applyAsByte(boolean a,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

default LBoolToByteFunction trying(@Nonnull
                                   ExWF<RuntimeException> exF)

applyAsByteThen

default byte applyAsByteThen(boolean a,
                             @Nonnull
                             LToByteFunction<Throwable> handler)

tryingThen

default LBoolToByteFunction tryingThen(@Nonnull
                                       LToByteFunction<Throwable> handler)

nestingApplyAsByte

default byte nestingApplyAsByte(boolean a)

Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

shovingApplyAsByte

default byte shovingApplyAsByte(boolean a)

Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.

handlingApplyAsByte

static byte handlingApplyAsByte(boolean a,
                                LBoolToByteFunction func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsByte

static byte tryApplyAsByte(boolean a,
                           LBoolToByteFunction func)

tryApplyAsByte

static byte tryApplyAsByte(boolean a,
                           LBoolToByteFunction func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryApplyAsByte

static byte tryApplyAsByte(boolean a,
                           LBoolToByteFunction func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsByteThen

static byte tryApplyAsByteThen(boolean a,
                               LBoolToByteFunction func,
                               @Nonnull
                               LToByteFunction<Throwable> handler)

failSafeApplyAsByte

default byte failSafeApplyAsByte(boolean a,
                                 @Nonnull
                                 LBoolToByteFunction failSafe)

failSafeApplyAsByte

static byte failSafeApplyAsByte(boolean a,
                                LBoolToByteFunction func,
                                @Nonnull
                                LBoolToByteFunction failSafe)

failSafe

static LBoolToByteFunction failSafe(LBoolToByteFunction func,
                                    @Nonnull
                                    LBoolToByteFunction failSafe)

nonNullApplyAsByte

default byte nonNullApplyAsByte(boolean a)

Just to mirror the method: Ensures the result is not null

functionalInterfaceDescription

@Nonnull
default String functionalInterfaceDescription()

Returns description of the functional interface.

Specified by:

functionalInterfaceDescription in interface MetaFunctionalInterface

fromTo

static void fromTo(int min_i,
                   int max_i,
                   boolean a,
                   LBoolToByteFunction func)

From-To. Intended to be used with non-capturing lambda.

fromTill

static void fromTill(int min_i,
                     int max_i,
                     boolean a,
                     LBoolToByteFunction func)

From-To. Intended to be used with non-capturing lambda.

times

static void times(int max_i,
                  boolean a,
                  LBoolToByteFunction func)

From-To. Intended to be used with non-capturing lambda.

capture

default LByteSupplier capture(boolean a)

Captures arguments but delays the evaluation.

constant

static LBoolToByteFunction constant(byte r)

Creates function that always returns the same value.

boolToByteFunc

@Nonnull
static LBoolToByteFunction boolToByteFunc(@Nonnull
                                                    LBoolToByteFunction lambda)

Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

recursive

@Nonnull
static LBoolToByteFunction recursive(@Nonnull
                                               LFunction<LBoolToByteFunction,LBoolToByteFunction> selfLambda)

boolToByteFuncThrowing

@Nonnull
static LBoolToByteFunction boolToByteFuncThrowing(@Nonnull
                                                            ExF<Throwable> exF)

boolToByteFuncThrowing

@Nonnull
static LBoolToByteFunction boolToByteFuncThrowing(String message,
                                                            @Nonnull
                                                            ExMF<Throwable> exF)

call

static byte call(boolean a,
                 @Nonnull
                 LBoolToByteFunction lambda)

safe

@Nonnull
static LBoolToByteFunction safe()

Safe instance. That always returns the same value (as produceByte).

safeSupplier

@Nonnull
static LSupplier<LBoolToByteFunction> safeSupplier()

Safe instance supplier. Returns supplier of safe() instance.

safe

@Nonnull
static LBoolToByteFunction safe(@Nullable
                                          LBoolToByteFunction other)

Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.

safeSupplier

@Nonnull
static LSupplier<LBoolToByteFunction> safeSupplier(@Nullable
                                                             LSupplier<LBoolToByteFunction> supplier)

Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.

compose

@Nonnull
default LBoolToByteFunction compose(@Nonnull
                                              LLogicalOperator before)

Allows to manipulate the domain of the function.

composed

static LBoolToByteFunction composed(@Nonnull
                                    LLogicalOperator before,
                                    LBoolToByteFunction after)

boolToByteFuncCompose

@Nonnull
default <V> LToByteFunction<V> boolToByteFuncCompose(@Nonnull
                                                               LPredicate<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LToByteFunction<V> composed(@Nonnull
                                       LPredicate<? super V> before,
                                       LBoolToByteFunction after)

then

@Nonnull
default <V> LBoolFunction<V> then(@Nonnull
                                            LByteFunction<? extends V> after)

Combines two functions together in a order.

thenToByte

@Nonnull
default LBoolToByteFunction thenToByte(@Nonnull
                                                 LByteUnaryOperator after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LBoolToSrtFunction thenToSrt(@Nonnull
                                               LByteToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LBoolToIntFunction thenToInt(@Nonnull
                                               LByteToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LBoolToLongFunction thenToLong(@Nonnull
                                                 LByteToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LBoolToFltFunction thenToFlt(@Nonnull
                                               LByteToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LBoolToDblFunction thenToDbl(@Nonnull
                                               LByteToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LBoolToCharFunction thenToChar(@Nonnull
                                                 LByteToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LLogicalOperator thenToBool(@Nonnull
                                              LBytePredicate after)

Combines two functions together in a order.

produceByte

static byte produceByte(boolean a)

Does nothing (LBoolToByteFunction) Function

forEach

default <C0> void forEach(IndexedRead<C0,aType.aBool> ia,
                          C0 source,
                          LByteConsumer 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.

iterate

default <C0,I0> void iterate(SequentialRead<C0,I0,aType.aBool> sa,
                             C0 source,
                             LByteConsumer 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.