eu.lunisolar.magma.func.function.conversion

Interface LLongToDblFunction

All Superinterfaces:

Codomain<aType.aDouble>, Domain, Domain1<aType.aLong>, Formattable, java.util.function.LongToDoubleFunction, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>

All Known Implementing Classes:

LLongToDblFunction.LLongToDblFunctionSingle

@FunctionalInterface
public interface LLongToDblFunction
extends java.util.function.LongToDoubleFunction, MetaFunction, MetaInterface.NonThrowing, Codomain<aType.aDouble>, Domain1<aType.aLong>

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

Type: function

Domain (lvl: 1): long a

Co-domain: double

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LLongToDblFunction.LLongToDblFunctionSingle

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 double	applyAsDbl(long a)
default double	applyAsDbl(long a, ExWF<RuntimeException> exF)
default double	applyAsDbl(long a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default double	applyAsDblThen(long a, LToDblFunction<Throwable> handler)
double	applyAsDblX(long a) Implement this, but call applyAsDbl(long a)
default double	applyAsDouble(long a) Deprecated. Calling this method via LLongToDblFunction interface should be discouraged.
static double	call(long a, LLongToDblFunction lambda)
default LDblSupplier	capture(long a) Captures arguments but delays the evaluation.
default LLongToDblFunction	compose(LLongUnaryOperator before) Allows to manipulate the domain of the function.
static LLongToDblFunction	composed(LLongUnaryOperator before, LLongToDblFunction after)
static <V> LToDblFunction<V>	composed(LToLongFunction<? super V> before, LLongToDblFunction after)
static LLongToDblFunction	constant(double r) Creates function that always returns the same value.
static LLongToDblFunction	failSafe(LLongToDblFunction func, LLongToDblFunction failSafe)
default double	failSafeApplyAsDbl(long a, LLongToDblFunction failSafe)
static double	failSafeApplyAsDbl(long a, LLongToDblFunction func, LLongToDblFunction failSafe)
default <C0> void	forEach(IndexedRead<C0,aType.aLong> ia, C0 source, LDblConsumer 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, LLongToDblFunction func) From-To.
static void	fromTo(long min_a, long max_a, LLongToDblFunction func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LLongToDblFunction	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default double	handlingApplyAsDbl(long a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static double	handlingApplyAsDbl(long a, LLongToDblFunction func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aLong> sa, C0 source, LDblConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static LLongToDblFunction	longToDblFunc(LLongToDblFunction lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V> LToDblFunction<V>	longToDblFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
static LLongToDblFunction	longToDblFuncThrowing(ExF<Throwable> exF)
static LLongToDblFunction	longToDblFuncThrowing(String message, ExMF<Throwable> exF)
default double	nestingApplyAsDbl(long a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default double	nonNullApplyAsDbl(long a) Just to mirror the method: Ensures the result is not null
static double	produceDouble(long a) Does nothing (LLongToDblFunction) Function
static LLongToDblFunction	recursive(LFunction<LLongToDblFunction,LLongToDblFunction> selfLambda)
static LLongToDblFunction	safe() Safe instance.
static LLongToDblFunction	safe(LLongToDblFunction other) Safe wrapping.
static LSupplier<LLongToDblFunction>	safeSupplier() Safe instance supplier.
static LSupplier<LLongToDblFunction>	safeSupplier(LSupplier<LLongToDblFunction> supplier) Safe supplier.
default double	shovingApplyAsDbl(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(LDblFunction<? extends V> after) Combines two functions together in a order.
default LLongPredicate	thenToBool(LDblPredicate after) Combines two functions together in a order.
default LLongToByteFunction	thenToByte(LDblToByteFunction after) Combines two functions together in a order.
default LLongToCharFunction	thenToChar(LDblToCharFunction after) Combines two functions together in a order.
default LLongToDblFunction	thenToDbl(LDblUnaryOperator after) Combines two functions together in a order.
default LLongToFltFunction	thenToFlt(LDblToFltFunction after) Combines two functions together in a order.
default LLongToIntFunction	thenToInt(LDblToIntFunction after) Combines two functions together in a order.
default LLongUnaryOperator	thenToLong(LDblToLongFunction after) Combines two functions together in a order.
default LLongToSrtFunction	thenToSrt(LDblToSrtFunction after) Combines two functions together in a order.
static void	times(long max_a, LLongToDblFunction func) From-To.
static double	tryApplyAsDbl(long a, LLongToDblFunction func)
static double	tryApplyAsDbl(long a, LLongToDblFunction func, ExWF<RuntimeException> exF)
static double	tryApplyAsDbl(long a, LLongToDblFunction func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static double	tryApplyAsDblThen(long a, LLongToDblFunction func, LToDblFunction<Throwable> handler)
default LLongToDblFunction	trying(ExWF<RuntimeException> exF)
default LLongToDblFunction	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LLongToDblFunction	tryingThen(LToDblFunction<Throwable> handler)
default double	tupleApplyAsDbl(LLongSingle args)
static LLongToDblFunction	wrap(java.util.function.LongToDoubleFunction other) Wraps JRE instance.

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

applyAsDouble

@Deprecated
default double applyAsDouble(long a)

Deprecated. Calling this method via LLongToDblFunction interface should be discouraged.

Default implementation for JRE method that calls exception nesting method.

Specified by:

applyAsDouble in interface java.util.function.LongToDoubleFunction

applyAsDbl

default double applyAsDbl(long a)

applyAsDblX

double applyAsDblX(long a)
            throws Throwable

Implement this, but call applyAsDbl(long a)

Throws:

Throwable

tupleApplyAsDbl

default double tupleApplyAsDbl(LLongSingle args)

handlingApplyAsDbl

default double handlingApplyAsDbl(long a,
                                  HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

applyAsDbl

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

trying

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

applyAsDbl

default double applyAsDbl(long a,
                          @Nonnull
                          ExWF<RuntimeException> exF)

trying

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

applyAsDblThen

default double applyAsDblThen(long a,
                              @Nonnull
                              LToDblFunction<Throwable> handler)

tryingThen

default LLongToDblFunction tryingThen(@Nonnull
                                      LToDblFunction<Throwable> handler)

nestingApplyAsDbl

default double nestingApplyAsDbl(long a)

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

shovingApplyAsDbl

default double shovingApplyAsDbl(long a)

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

handlingApplyAsDbl

static double handlingApplyAsDbl(long a,
                                 LLongToDblFunction func,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsDbl

static double tryApplyAsDbl(long a,
                            LLongToDblFunction func)

tryApplyAsDbl

static double tryApplyAsDbl(long a,
                            LLongToDblFunction func,
                            @Nonnull
                            ExWMF<RuntimeException> exF,
                            @Nonnull
                            String newMessage,
                            @Nullable
                            Object... messageParams)

tryApplyAsDbl

static double tryApplyAsDbl(long a,
                            LLongToDblFunction func,
                            @Nonnull
                            ExWF<RuntimeException> exF)

tryApplyAsDblThen

static double tryApplyAsDblThen(long a,
                                LLongToDblFunction func,
                                @Nonnull
                                LToDblFunction<Throwable> handler)

failSafeApplyAsDbl

default double failSafeApplyAsDbl(long a,
                                  @Nonnull
                                  LLongToDblFunction failSafe)

failSafeApplyAsDbl

static double failSafeApplyAsDbl(long a,
                                 LLongToDblFunction func,
                                 @Nonnull
                                 LLongToDblFunction failSafe)

failSafe

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

nonNullApplyAsDbl

default double nonNullApplyAsDbl(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,
                   LLongToDblFunction func)

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

fromTill

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

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

times

static void times(long max_a,
                  LLongToDblFunction func)

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

capture

default LDblSupplier capture(long a)

Captures arguments but delays the evaluation.

constant

static LLongToDblFunction constant(double r)

Creates function that always returns the same value.

longToDblFunc

@Nonnull
static LLongToDblFunction longToDblFunc(@Nonnull
                                                  LLongToDblFunction lambda)

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

recursive

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

longToDblFuncThrowing

@Nonnull
static LLongToDblFunction longToDblFuncThrowing(@Nonnull
                                                          ExF<Throwable> exF)

longToDblFuncThrowing

@Nonnull
static LLongToDblFunction longToDblFuncThrowing(String message,
                                                          @Nonnull
                                                          ExMF<Throwable> exF)

call

static double call(long a,
                   @Nonnull
                   LLongToDblFunction lambda)

wrap

@Nonnull
static LLongToDblFunction wrap(java.util.function.LongToDoubleFunction other)

Wraps JRE instance.

safe

@Nonnull
static LLongToDblFunction safe()

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

safeSupplier

@Nonnull
static LSupplier<LLongToDblFunction> safeSupplier()

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

safe

@Nonnull
static LLongToDblFunction safe(@Nullable
                                         LLongToDblFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LLongToDblFunction compose(@Nonnull
                                             LLongUnaryOperator before)

Allows to manipulate the domain of the function.

composed

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

longToDblFuncCompose

@Nonnull
default <V> LToDblFunction<V> longToDblFuncCompose(@Nonnull
                                                             LToLongFunction<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LToDblFunction<V> composed(@Nonnull
                                      LToLongFunction<? super V> before,
                                      LLongToDblFunction after)

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LLongToByteFunction thenToByte(@Nonnull
                                                 LDblToByteFunction after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LLongToSrtFunction thenToSrt(@Nonnull
                                               LDblToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LLongToIntFunction thenToInt(@Nonnull
                                               LDblToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LLongUnaryOperator thenToLong(@Nonnull
                                                LDblToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LLongToFltFunction thenToFlt(@Nonnull
                                               LDblToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LLongToDblFunction thenToDbl(@Nonnull
                                               LDblUnaryOperator after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LLongToCharFunction thenToChar(@Nonnull
                                                 LDblToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LLongPredicate thenToBool(@Nonnull
                                            LDblPredicate after)

Combines two functions together in a order.

produceDouble

static double produceDouble(long a)

Does nothing (LLongToDblFunction) Function

forEach

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