eu.lunisolar.magma.func.function.conversion

Interface LBoolToLongFunction

All Superinterfaces:

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

All Known Implementing Classes:

LBoolToLongFunction.LBoolToLongFunctionSingle

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

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

Type: function

Domain (lvl: 1): boolean a

Co-domain: long

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LBoolToLongFunction.LBoolToLongFunctionSingle

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 long	applyAsLong(boolean a)
default long	applyAsLong(boolean a, ExWF<RuntimeException> exF)
default long	applyAsLong(boolean a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default long	applyAsLongThen(boolean a, LToLongFunction<Throwable> handler)
long	applyAsLongX(boolean a) Implement this, but call applyAsLong(boolean a)
static LBoolToLongFunction	boolToLongFunc(LBoolToLongFunction lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V> LToLongFunction<V>	boolToLongFuncCompose(LPredicate<? super V> before) Allows to manipulate the domain of the function.
static LBoolToLongFunction	boolToLongFuncThrowing(ExF<Throwable> exF)
static LBoolToLongFunction	boolToLongFuncThrowing(String message, ExMF<Throwable> exF)
static long	call(boolean a, LBoolToLongFunction lambda)
default LLongSupplier	capture(boolean a) Captures arguments but delays the evaluation.
default LBoolToLongFunction	compose(LLogicalOperator before) Allows to manipulate the domain of the function.
static LBoolToLongFunction	composed(LLogicalOperator before, LBoolToLongFunction after)
static <V> LToLongFunction<V>	composed(LPredicate<? super V> before, LBoolToLongFunction after)
static LBoolToLongFunction	constant(long r) Creates function that always returns the same value.
static LBoolToLongFunction	failSafe(LBoolToLongFunction func, LBoolToLongFunction failSafe)
default long	failSafeApplyAsLong(boolean a, LBoolToLongFunction failSafe)
static long	failSafeApplyAsLong(boolean a, LBoolToLongFunction func, LBoolToLongFunction failSafe)
default <C0> void	forEach(IndexedRead<C0,aType.aBool> ia, C0 source, LLongConsumer 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, LBoolToLongFunction func) From-To.
static void	fromTo(int min_i, int max_i, boolean a, LBoolToLongFunction func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LBoolToLongFunction	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default long	handlingApplyAsLong(boolean a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static long	handlingApplyAsLong(boolean a, LBoolToLongFunction func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aBool> sa, C0 source, LLongConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default long	nestingApplyAsLong(boolean a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default long	nonNullApplyAsLong(boolean a) Just to mirror the method: Ensures the result is not null
static long	produceLong(boolean a) Does nothing (LBoolToLongFunction) Function
static LBoolToLongFunction	recursive(LFunction<LBoolToLongFunction,LBoolToLongFunction> selfLambda)
static LBoolToLongFunction	safe() Safe instance.
static LBoolToLongFunction	safe(LBoolToLongFunction other) Safe wrapping.
static LSupplier<LBoolToLongFunction>	safeSupplier() Safe instance supplier.
static LSupplier<LBoolToLongFunction>	safeSupplier(LSupplier<LBoolToLongFunction> supplier) Safe supplier.
default long	shovingApplyAsLong(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(LLongFunction<? extends V> after) Combines two functions together in a order.
default LLogicalOperator	thenToBool(LLongPredicate after) Combines two functions together in a order.
default LBoolToByteFunction	thenToByte(LLongToByteFunction after) Combines two functions together in a order.
default LBoolToCharFunction	thenToChar(LLongToCharFunction after) Combines two functions together in a order.
default LBoolToDblFunction	thenToDbl(LLongToDblFunction after) Combines two functions together in a order.
default LBoolToFltFunction	thenToFlt(LLongToFltFunction after) Combines two functions together in a order.
default LBoolToIntFunction	thenToInt(LLongToIntFunction after) Combines two functions together in a order.
default LBoolToLongFunction	thenToLong(LLongUnaryOperator after) Combines two functions together in a order.
default LBoolToSrtFunction	thenToSrt(LLongToSrtFunction after) Combines two functions together in a order.
static void	times(int max_i, boolean a, LBoolToLongFunction func) From-To.
static long	tryApplyAsLong(boolean a, LBoolToLongFunction func)
static long	tryApplyAsLong(boolean a, LBoolToLongFunction func, ExWF<RuntimeException> exF)
static long	tryApplyAsLong(boolean a, LBoolToLongFunction func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static long	tryApplyAsLongThen(boolean a, LBoolToLongFunction func, LToLongFunction<Throwable> handler)
default LBoolToLongFunction	trying(ExWF<RuntimeException> exF)
default LBoolToLongFunction	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LBoolToLongFunction	tryingThen(LToLongFunction<Throwable> handler)
default long	tupleApplyAsLong(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

applyAsLong

default long applyAsLong(boolean a)

applyAsLongX

long applyAsLongX(boolean a)
           throws Throwable

Implement this, but call applyAsLong(boolean a)

Throws:

Throwable

tupleApplyAsLong

default long tupleApplyAsLong(LBoolSingle args)

handlingApplyAsLong

default long handlingApplyAsLong(boolean a,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

applyAsLong

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

trying

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

applyAsLong

default long applyAsLong(boolean a,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

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

applyAsLongThen

default long applyAsLongThen(boolean a,
                             @Nonnull
                             LToLongFunction<Throwable> handler)

tryingThen

default LBoolToLongFunction tryingThen(@Nonnull
                                       LToLongFunction<Throwable> handler)

nestingApplyAsLong

default long nestingApplyAsLong(boolean a)

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

shovingApplyAsLong

default long shovingApplyAsLong(boolean a)

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

handlingApplyAsLong

static long handlingApplyAsLong(boolean a,
                                LBoolToLongFunction func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsLong

static long tryApplyAsLong(boolean a,
                           LBoolToLongFunction func)

tryApplyAsLong

static long tryApplyAsLong(boolean a,
                           LBoolToLongFunction func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryApplyAsLong

static long tryApplyAsLong(boolean a,
                           LBoolToLongFunction func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsLongThen

static long tryApplyAsLongThen(boolean a,
                               LBoolToLongFunction func,
                               @Nonnull
                               LToLongFunction<Throwable> handler)

failSafeApplyAsLong

default long failSafeApplyAsLong(boolean a,
                                 @Nonnull
                                 LBoolToLongFunction failSafe)

failSafeApplyAsLong

static long failSafeApplyAsLong(boolean a,
                                LBoolToLongFunction func,
                                @Nonnull
                                LBoolToLongFunction failSafe)

failSafe

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

nonNullApplyAsLong

default long nonNullApplyAsLong(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,
                   LBoolToLongFunction func)

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

fromTill

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

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

times

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

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

capture

default LLongSupplier capture(boolean a)

Captures arguments but delays the evaluation.

constant

static LBoolToLongFunction constant(long r)

Creates function that always returns the same value.

boolToLongFunc

@Nonnull
static LBoolToLongFunction boolToLongFunc(@Nonnull
                                                    LBoolToLongFunction lambda)

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

recursive

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

boolToLongFuncThrowing

@Nonnull
static LBoolToLongFunction boolToLongFuncThrowing(@Nonnull
                                                            ExF<Throwable> exF)

boolToLongFuncThrowing

@Nonnull
static LBoolToLongFunction boolToLongFuncThrowing(String message,
                                                            @Nonnull
                                                            ExMF<Throwable> exF)

call

static long call(boolean a,
                 @Nonnull
                 LBoolToLongFunction lambda)

safe

@Nonnull
static LBoolToLongFunction safe()

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

safeSupplier

@Nonnull
static LSupplier<LBoolToLongFunction> safeSupplier()

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

safe

@Nonnull
static LBoolToLongFunction safe(@Nullable
                                          LBoolToLongFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LBoolToLongFunction compose(@Nonnull
                                              LLogicalOperator before)

Allows to manipulate the domain of the function.

composed

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

boolToLongFuncCompose

@Nonnull
default <V> LToLongFunction<V> boolToLongFuncCompose(@Nonnull
                                                               LPredicate<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LToLongFunction<V> composed(@Nonnull
                                       LPredicate<? super V> before,
                                       LBoolToLongFunction after)

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LBoolToByteFunction thenToByte(@Nonnull
                                                 LLongToByteFunction after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LBoolToSrtFunction thenToSrt(@Nonnull
                                               LLongToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LBoolToIntFunction thenToInt(@Nonnull
                                               LLongToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LBoolToLongFunction thenToLong(@Nonnull
                                                 LLongUnaryOperator after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LBoolToFltFunction thenToFlt(@Nonnull
                                               LLongToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LBoolToDblFunction thenToDbl(@Nonnull
                                               LLongToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LBoolToCharFunction thenToChar(@Nonnull
                                                 LLongToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LLogicalOperator thenToBool(@Nonnull
                                              LLongPredicate after)

Combines two functions together in a order.

produceLong

static long produceLong(boolean a)

Does nothing (LBoolToLongFunction) Function

forEach

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