eu.lunisolar.magma.func.function.conversion

Interface LLongToFltFunction

All Superinterfaces:

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

All Known Implementing Classes:

LLongToFltFunction.LLongToFltFunctionSingle

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

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

Type: function

Domain (lvl: 1): long a

Co-domain: float

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LLongToFltFunction.LLongToFltFunctionSingle

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 float	applyAsFlt(long a)
default float	applyAsFlt(long a, ExWF<RuntimeException> exF)
default float	applyAsFlt(long a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default float	applyAsFltThen(long a, LToFltFunction<Throwable> handler)
float	applyAsFltX(long a) Implement this, but call applyAsFlt(long a)
static float	call(long a, LLongToFltFunction lambda)
default LFltSupplier	capture(long a) Captures arguments but delays the evaluation.
default LLongToFltFunction	compose(LLongUnaryOperator before) Allows to manipulate the domain of the function.
static LLongToFltFunction	composed(LLongUnaryOperator before, LLongToFltFunction after)
static <V> LToFltFunction<V>	composed(LToLongFunction<? super V> before, LLongToFltFunction after)
static LLongToFltFunction	constant(float r) Creates function that always returns the same value.
static LLongToFltFunction	failSafe(LLongToFltFunction func, LLongToFltFunction failSafe)
default float	failSafeApplyAsFlt(long a, LLongToFltFunction failSafe)
static float	failSafeApplyAsFlt(long a, LLongToFltFunction func, LLongToFltFunction failSafe)
default <C0> void	forEach(IndexedRead<C0,aType.aLong> ia, C0 source, LFltConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static void	fromTill(long min_a, long max_a, LLongToFltFunction func) From-To.
static void	fromTo(long min_a, long max_a, LLongToFltFunction func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LLongToFltFunction	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default float	handlingApplyAsFlt(long a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static float	handlingApplyAsFlt(long a, LLongToFltFunction func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aLong> sa, C0 source, LFltConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static LLongToFltFunction	longToFltFunc(LLongToFltFunction lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V> LToFltFunction<V>	longToFltFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
static LLongToFltFunction	longToFltFuncThrowing(ExF<Throwable> exF)
static LLongToFltFunction	longToFltFuncThrowing(String message, ExMF<Throwable> exF)
default float	nestingApplyAsFlt(long a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default float	nonNullApplyAsFlt(long a) Just to mirror the method: Ensures the result is not null
static float	produceFloat(long a) Does nothing (LLongToFltFunction) Function
static LLongToFltFunction	recursive(LFunction<LLongToFltFunction,LLongToFltFunction> selfLambda)
static LLongToFltFunction	safe() Safe instance.
static LLongToFltFunction	safe(LLongToFltFunction other) Safe wrapping.
static LSupplier<LLongToFltFunction>	safeSupplier() Safe instance supplier.
static LSupplier<LLongToFltFunction>	safeSupplier(LSupplier<LLongToFltFunction> supplier) Safe supplier.
default float	shovingApplyAsFlt(long a) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default <V> LLongFunction<V>	then(LFltFunction<? extends V> after) Combines two functions together in a order.
default LLongPredicate	thenToBool(LFltPredicate after) Combines two functions together in a order.
default LLongToByteFunction	thenToByte(LFltToByteFunction after) Combines two functions together in a order.
default LLongToCharFunction	thenToChar(LFltToCharFunction after) Combines two functions together in a order.
default LLongToDblFunction	thenToDbl(LFltToDblFunction after) Combines two functions together in a order.
default LLongToFltFunction	thenToFlt(LFltUnaryOperator after) Combines two functions together in a order.
default LLongToIntFunction	thenToInt(LFltToIntFunction after) Combines two functions together in a order.
default LLongUnaryOperator	thenToLong(LFltToLongFunction after) Combines two functions together in a order.
default LLongToSrtFunction	thenToSrt(LFltToSrtFunction after) Combines two functions together in a order.
static void	times(long max_a, LLongToFltFunction func) From-To.
static float	tryApplyAsFlt(long a, LLongToFltFunction func)
static float	tryApplyAsFlt(long a, LLongToFltFunction func, ExWF<RuntimeException> exF)
static float	tryApplyAsFlt(long a, LLongToFltFunction func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static float	tryApplyAsFltThen(long a, LLongToFltFunction func, LToFltFunction<Throwable> handler)
default LLongToFltFunction	trying(ExWF<RuntimeException> exF)
default LLongToFltFunction	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LLongToFltFunction	tryingThen(LToFltFunction<Throwable> handler)
default float	tupleApplyAsFlt(LLongSingle 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

applyAsFlt

default float applyAsFlt(long a)

applyAsFltX

float applyAsFltX(long a)
           throws Throwable

Implement this, but call applyAsFlt(long a)

Throws:

Throwable

tupleApplyAsFlt

default float tupleApplyAsFlt(LLongSingle args)

handlingApplyAsFlt

default float handlingApplyAsFlt(long a,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

applyAsFlt

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

trying

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

applyAsFlt

default float applyAsFlt(long a,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

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

applyAsFltThen

default float applyAsFltThen(long a,
                             @Nonnull
                             LToFltFunction<Throwable> handler)

tryingThen

default LLongToFltFunction tryingThen(@Nonnull
                                      LToFltFunction<Throwable> handler)

nestingApplyAsFlt

default float nestingApplyAsFlt(long a)

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

shovingApplyAsFlt

default float shovingApplyAsFlt(long a)

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

handlingApplyAsFlt

static float handlingApplyAsFlt(long a,
                                LLongToFltFunction func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsFlt

static float tryApplyAsFlt(long a,
                           LLongToFltFunction func)

tryApplyAsFlt

static float tryApplyAsFlt(long a,
                           LLongToFltFunction func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryApplyAsFlt

static float tryApplyAsFlt(long a,
                           LLongToFltFunction func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsFltThen

static float tryApplyAsFltThen(long a,
                               LLongToFltFunction func,
                               @Nonnull
                               LToFltFunction<Throwable> handler)

failSafeApplyAsFlt

default float failSafeApplyAsFlt(long a,
                                 @Nonnull
                                 LLongToFltFunction failSafe)

failSafeApplyAsFlt

static float failSafeApplyAsFlt(long a,
                                LLongToFltFunction func,
                                @Nonnull
                                LLongToFltFunction failSafe)

failSafe

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

nonNullApplyAsFlt

default float nonNullApplyAsFlt(long 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(long min_a,
                   long max_a,
                   LLongToFltFunction func)

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

fromTill

static void fromTill(long min_a,
                     long max_a,
                     LLongToFltFunction func)

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

times

static void times(long max_a,
                  LLongToFltFunction func)

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

capture

default LFltSupplier capture(long a)

Captures arguments but delays the evaluation.

constant

static LLongToFltFunction constant(float r)

Creates function that always returns the same value.

longToFltFunc

@Nonnull
static LLongToFltFunction longToFltFunc(@Nonnull
                                                  LLongToFltFunction lambda)

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

recursive

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

longToFltFuncThrowing

@Nonnull
static LLongToFltFunction longToFltFuncThrowing(@Nonnull
                                                          ExF<Throwable> exF)

longToFltFuncThrowing

@Nonnull
static LLongToFltFunction longToFltFuncThrowing(String message,
                                                          @Nonnull
                                                          ExMF<Throwable> exF)

call

static float call(long a,
                  @Nonnull
                  LLongToFltFunction lambda)

safe

@Nonnull
static LLongToFltFunction safe()

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

safeSupplier

@Nonnull
static LSupplier<LLongToFltFunction> safeSupplier()

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

safe

@Nonnull
static LLongToFltFunction safe(@Nullable
                                         LLongToFltFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LLongToFltFunction compose(@Nonnull
                                             LLongUnaryOperator before)

Allows to manipulate the domain of the function.

composed

static LLongToFltFunction composed(@Nonnull
                                   LLongUnaryOperator before,
                                   LLongToFltFunction after)

longToFltFuncCompose

@Nonnull
default <V> LToFltFunction<V> longToFltFuncCompose(@Nonnull
                                                             LToLongFunction<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LToFltFunction<V> composed(@Nonnull
                                      LToLongFunction<? super V> before,
                                      LLongToFltFunction after)

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LLongToByteFunction thenToByte(@Nonnull
                                                 LFltToByteFunction after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LLongToSrtFunction thenToSrt(@Nonnull
                                               LFltToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LLongToIntFunction thenToInt(@Nonnull
                                               LFltToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LLongUnaryOperator thenToLong(@Nonnull
                                                LFltToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LLongToFltFunction thenToFlt(@Nonnull
                                               LFltUnaryOperator after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LLongToDblFunction thenToDbl(@Nonnull
                                               LFltToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LLongToCharFunction thenToChar(@Nonnull
                                                 LFltToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LLongPredicate thenToBool(@Nonnull
                                            LFltPredicate after)

Combines two functions together in a order.

produceFloat

static float produceFloat(long a)

Does nothing (LLongToFltFunction) Function

forEach

default <C0> void forEach(IndexedRead<C0,aType.aLong> ia,
                          C0 source,
                          LFltConsumer 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.aLong> sa,
                             C0 source,
                             LFltConsumer 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.