eu.lunisolar.magma.func.function.conversion

Interface LIntToLongFunction

All Superinterfaces:

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

All Known Implementing Classes:

LIntToLongFunction.LIntToLongFunctionSingle

@FunctionalInterface
public interface LIntToLongFunction
extends java.util.function.IntToLongFunction, MetaFunction, MetaInterface.NonThrowing, Codomain<aType.aLong>, Domain1<aType.aInt>

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

Type: function

Domain (lvl: 1): int a

Co-domain: long

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LIntToLongFunction.LIntToLongFunctionSingle

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(int a)
default long	applyAsLong(int a, ExWF<RuntimeException> exF)
default long	applyAsLong(int a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default long	applyAsLongThen(int a, LToLongFunction<Throwable> handler)
long	applyAsLongX(int a) Implement this, but call applyAsLong(int a)
static long	call(int a, LIntToLongFunction lambda)
default LLongSupplier	capture(int a) Captures arguments but delays the evaluation.
default LIntToLongFunction	compose(LIntUnaryOperator before) Allows to manipulate the domain of the function.
static LIntToLongFunction	composed(LIntUnaryOperator before, LIntToLongFunction after)
static <V> LToLongFunction<V>	composed(LToIntFunction<? super V> before, LIntToLongFunction after)
static LIntToLongFunction	constant(long r) Creates function that always returns the same value.
static LIntToLongFunction	failSafe(LIntToLongFunction func, LIntToLongFunction failSafe)
default long	failSafeApplyAsLong(int a, LIntToLongFunction failSafe)
static long	failSafeApplyAsLong(int a, LIntToLongFunction func, LIntToLongFunction failSafe)
default <C0> void	forEach(IndexedRead<C0,aType.aInt> 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_a, int max_a, LIntToLongFunction func) From-To.
static void	fromTo(int min_a, int max_a, LIntToLongFunction func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LIntToLongFunction	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default long	handlingApplyAsLong(int a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static long	handlingApplyAsLong(int a, LIntToLongFunction func, HandlingInstructions<Throwable,RuntimeException> handling)
static LIntToLongFunction	intToLongFunc(LIntToLongFunction 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>	intToLongFuncCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
static LIntToLongFunction	intToLongFuncThrowing(ExF<Throwable> exF)
static LIntToLongFunction	intToLongFuncThrowing(String message, ExMF<Throwable> exF)
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aInt> sa, C0 source, LLongConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default long	nestingApplyAsLong(int a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default long	nonNullApplyAsLong(int a) Just to mirror the method: Ensures the result is not null
static long	produceLong(int a) Does nothing (LIntToLongFunction) Function
static LIntToLongFunction	recursive(LFunction<LIntToLongFunction,LIntToLongFunction> selfLambda)
static LIntToLongFunction	safe() Safe instance.
static LIntToLongFunction	safe(LIntToLongFunction other) Safe wrapping.
static LSupplier<LIntToLongFunction>	safeSupplier() Safe instance supplier.
static LSupplier<LIntToLongFunction>	safeSupplier(LSupplier<LIntToLongFunction> supplier) Safe supplier.
default long	shovingApplyAsLong(int a) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default <V> LIntFunction<V>	then(LLongFunction<? extends V> after) Combines two functions together in a order.
default LIntPredicate	thenToBool(LLongPredicate after) Combines two functions together in a order.
default LIntToByteFunction	thenToByte(LLongToByteFunction after) Combines two functions together in a order.
default LIntToCharFunction	thenToChar(LLongToCharFunction after) Combines two functions together in a order.
default LIntToDblFunction	thenToDbl(LLongToDblFunction after) Combines two functions together in a order.
default LIntToFltFunction	thenToFlt(LLongToFltFunction after) Combines two functions together in a order.
default LIntUnaryOperator	thenToInt(LLongToIntFunction after) Combines two functions together in a order.
default LIntToLongFunction	thenToLong(LLongUnaryOperator after) Combines two functions together in a order.
default LIntToSrtFunction	thenToSrt(LLongToSrtFunction after) Combines two functions together in a order.
static void	times(int max_a, LIntToLongFunction func) From-To.
static long	tryApplyAsLong(int a, LIntToLongFunction func)
static long	tryApplyAsLong(int a, LIntToLongFunction func, ExWF<RuntimeException> exF)
static long	tryApplyAsLong(int a, LIntToLongFunction func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static long	tryApplyAsLongThen(int a, LIntToLongFunction func, LToLongFunction<Throwable> handler)
default LIntToLongFunction	trying(ExWF<RuntimeException> exF)
default LIntToLongFunction	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LIntToLongFunction	tryingThen(LToLongFunction<Throwable> handler)
default long	tupleApplyAsLong(LIntSingle args)
static LIntToLongFunction	wrap(java.util.function.IntToLongFunction 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

applyAsLong

default long applyAsLong(int a)

Specified by:

applyAsLong in interface java.util.function.IntToLongFunction

applyAsLongX

long applyAsLongX(int a)
           throws Throwable

Implement this, but call applyAsLong(int a)

Throws:

Throwable

tupleApplyAsLong

default long tupleApplyAsLong(LIntSingle args)

handlingApplyAsLong

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

Function call that handles exceptions according to the instructions.

handling

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

applyAsLong

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

trying

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

applyAsLong

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

trying

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

applyAsLongThen

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

tryingThen

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

nestingApplyAsLong

default long nestingApplyAsLong(int a)

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

shovingApplyAsLong

default long shovingApplyAsLong(int a)

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

handlingApplyAsLong

static long handlingApplyAsLong(int a,
                                LIntToLongFunction func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsLong

static long tryApplyAsLong(int a,
                           LIntToLongFunction func)

tryApplyAsLong

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

tryApplyAsLong

static long tryApplyAsLong(int a,
                           LIntToLongFunction func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsLongThen

static long tryApplyAsLongThen(int a,
                               LIntToLongFunction func,
                               @Nonnull
                               LToLongFunction<Throwable> handler)

failSafeApplyAsLong

default long failSafeApplyAsLong(int a,
                                 @Nonnull
                                 LIntToLongFunction failSafe)

failSafeApplyAsLong

static long failSafeApplyAsLong(int a,
                                LIntToLongFunction func,
                                @Nonnull
                                LIntToLongFunction failSafe)

failSafe

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

nonNullApplyAsLong

default long nonNullApplyAsLong(int 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_a,
                   int max_a,
                   LIntToLongFunction func)

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

fromTill

static void fromTill(int min_a,
                     int max_a,
                     LIntToLongFunction func)

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

times

static void times(int max_a,
                  LIntToLongFunction func)

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

capture

default LLongSupplier capture(int a)

Captures arguments but delays the evaluation.

constant

static LIntToLongFunction constant(long r)

Creates function that always returns the same value.

intToLongFunc

@Nonnull
static LIntToLongFunction intToLongFunc(@Nonnull
                                                  LIntToLongFunction lambda)

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

recursive

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

intToLongFuncThrowing

@Nonnull
static LIntToLongFunction intToLongFuncThrowing(@Nonnull
                                                          ExF<Throwable> exF)

intToLongFuncThrowing

@Nonnull
static LIntToLongFunction intToLongFuncThrowing(String message,
                                                          @Nonnull
                                                          ExMF<Throwable> exF)

call

static long call(int a,
                 @Nonnull
                 LIntToLongFunction lambda)

wrap

@Nonnull
static LIntToLongFunction wrap(java.util.function.IntToLongFunction other)

Wraps JRE instance.

safe

@Nonnull
static LIntToLongFunction safe()

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

safeSupplier

@Nonnull
static LSupplier<LIntToLongFunction> safeSupplier()

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

safe

@Nonnull
static LIntToLongFunction safe(@Nullable
                                         LIntToLongFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LIntToLongFunction compose(@Nonnull
                                             LIntUnaryOperator before)

Allows to manipulate the domain of the function.

composed

static LIntToLongFunction composed(@Nonnull
                                   LIntUnaryOperator before,
                                   LIntToLongFunction after)

intToLongFuncCompose

@Nonnull
default <V> LToLongFunction<V> intToLongFuncCompose(@Nonnull
                                                              LToIntFunction<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LToLongFunction<V> composed(@Nonnull
                                       LToIntFunction<? super V> before,
                                       LIntToLongFunction after)

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LIntToByteFunction thenToByte(@Nonnull
                                                LLongToByteFunction after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LIntToSrtFunction thenToSrt(@Nonnull
                                              LLongToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LIntUnaryOperator thenToInt(@Nonnull
                                              LLongToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LIntToLongFunction thenToLong(@Nonnull
                                                LLongUnaryOperator after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LIntToFltFunction thenToFlt(@Nonnull
                                              LLongToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LIntToDblFunction thenToDbl(@Nonnull
                                              LLongToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LIntToCharFunction thenToChar(@Nonnull
                                                LLongToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LIntPredicate thenToBool(@Nonnull
                                           LLongPredicate after)

Combines two functions together in a order.

produceLong

static long produceLong(int a)

Does nothing (LIntToLongFunction) Function

forEach

default <C0> void forEach(IndexedRead<C0,aType.aInt> 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.aInt> 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.