eu.lunisolar.magma.func.function.conversion

Interface LLongToIntFunction

All Superinterfaces:

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

All Known Implementing Classes:

LLongToIntFunction.LLongToIntFunctionSingle

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

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

Type: function

Domain (lvl: 1): long a

Co-domain: int

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LLongToIntFunction.LLongToIntFunctionSingle

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 int	applyAsInt(long a)
default int	applyAsInt(long a, ExWF<RuntimeException> exF)
default int	applyAsInt(long a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default int	applyAsIntThen(long a, LToIntFunction<Throwable> handler)
int	applyAsIntX(long a) Implement this, but call applyAsInt(long a)
static int	call(long a, LLongToIntFunction lambda)
default LIntSupplier	capture(long a) Captures arguments but delays the evaluation.
default LLongToIntFunction	compose(LLongUnaryOperator before) Allows to manipulate the domain of the function.
static LLongToIntFunction	composed(LLongUnaryOperator before, LLongToIntFunction after)
static <V> LToIntFunction<V>	composed(LToLongFunction<? super V> before, LLongToIntFunction after)
static LLongToIntFunction	constant(int r) Creates function that always returns the same value.
static LLongToIntFunction	failSafe(LLongToIntFunction func, LLongToIntFunction failSafe)
default int	failSafeApplyAsInt(long a, LLongToIntFunction failSafe)
static int	failSafeApplyAsInt(long a, LLongToIntFunction func, LLongToIntFunction failSafe)
default <C0> void	forEach(IndexedRead<C0,aType.aLong> ia, C0 source, LIntConsumer 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, LLongToIntFunction func) From-To.
static void	fromTo(long min_a, long max_a, LLongToIntFunction func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LLongToIntFunction	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default int	handlingApplyAsInt(long a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static int	handlingApplyAsInt(long a, LLongToIntFunction func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aLong> sa, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static LLongToIntFunction	longToIntFunc(LLongToIntFunction lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V> LToIntFunction<V>	longToIntFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
static LLongToIntFunction	longToIntFuncThrowing(ExF<Throwable> exF)
static LLongToIntFunction	longToIntFuncThrowing(String message, ExMF<Throwable> exF)
default int	nestingApplyAsInt(long a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default int	nonNullApplyAsInt(long a) Just to mirror the method: Ensures the result is not null
static int	produceInt(long a) Does nothing (LLongToIntFunction) Function
static LLongToIntFunction	recursive(LFunction<LLongToIntFunction,LLongToIntFunction> selfLambda)
static LLongToIntFunction	safe() Safe instance.
static LLongToIntFunction	safe(LLongToIntFunction other) Safe wrapping.
static LSupplier<LLongToIntFunction>	safeSupplier() Safe instance supplier.
static LSupplier<LLongToIntFunction>	safeSupplier(LSupplier<LLongToIntFunction> supplier) Safe supplier.
default int	shovingApplyAsInt(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(LIntFunction<? extends V> after) Combines two functions together in a order.
default LLongPredicate	thenToBool(LIntPredicate after) Combines two functions together in a order.
default LLongToByteFunction	thenToByte(LIntToByteFunction after) Combines two functions together in a order.
default LLongToCharFunction	thenToChar(LIntToCharFunction after) Combines two functions together in a order.
default LLongToDblFunction	thenToDbl(LIntToDblFunction after) Combines two functions together in a order.
default LLongToFltFunction	thenToFlt(LIntToFltFunction after) Combines two functions together in a order.
default LLongToIntFunction	thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LLongUnaryOperator	thenToLong(LIntToLongFunction after) Combines two functions together in a order.
default LLongToSrtFunction	thenToSrt(LIntToSrtFunction after) Combines two functions together in a order.
static void	times(long max_a, LLongToIntFunction func) From-To.
static int	tryApplyAsInt(long a, LLongToIntFunction func)
static int	tryApplyAsInt(long a, LLongToIntFunction func, ExWF<RuntimeException> exF)
static int	tryApplyAsInt(long a, LLongToIntFunction func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static int	tryApplyAsIntThen(long a, LLongToIntFunction func, LToIntFunction<Throwable> handler)
default LLongToIntFunction	trying(ExWF<RuntimeException> exF)
default LLongToIntFunction	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LLongToIntFunction	tryingThen(LToIntFunction<Throwable> handler)
default int	tupleApplyAsInt(LLongSingle args)
static LLongToIntFunction	wrap(java.util.function.LongToIntFunction 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

applyAsInt

default int applyAsInt(long a)

Specified by:

applyAsInt in interface java.util.function.LongToIntFunction

applyAsIntX

int applyAsIntX(long a)
         throws Throwable

Implement this, but call applyAsInt(long a)

Throws:

Throwable

tupleApplyAsInt

default int tupleApplyAsInt(LLongSingle args)

handlingApplyAsInt

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

Function call that handles exceptions according to the instructions.

handling

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

applyAsInt

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

trying

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

applyAsInt

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

trying

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

applyAsIntThen

default int applyAsIntThen(long a,
                           @Nonnull
                           LToIntFunction<Throwable> handler)

tryingThen

default LLongToIntFunction tryingThen(@Nonnull
                                      LToIntFunction<Throwable> handler)

nestingApplyAsInt

default int nestingApplyAsInt(long a)

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

shovingApplyAsInt

default int shovingApplyAsInt(long a)

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

handlingApplyAsInt

static int handlingApplyAsInt(long a,
                              LLongToIntFunction func,
                              HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsInt

static int tryApplyAsInt(long a,
                         LLongToIntFunction func)

tryApplyAsInt

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

tryApplyAsInt

static int tryApplyAsInt(long a,
                         LLongToIntFunction func,
                         @Nonnull
                         ExWF<RuntimeException> exF)

tryApplyAsIntThen

static int tryApplyAsIntThen(long a,
                             LLongToIntFunction func,
                             @Nonnull
                             LToIntFunction<Throwable> handler)

failSafeApplyAsInt

default int failSafeApplyAsInt(long a,
                               @Nonnull
                               LLongToIntFunction failSafe)

failSafeApplyAsInt

static int failSafeApplyAsInt(long a,
                              LLongToIntFunction func,
                              @Nonnull
                              LLongToIntFunction failSafe)

failSafe

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

nonNullApplyAsInt

default int nonNullApplyAsInt(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,
                   LLongToIntFunction func)

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

fromTill

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

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

times

static void times(long max_a,
                  LLongToIntFunction func)

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

capture

default LIntSupplier capture(long a)

Captures arguments but delays the evaluation.

constant

static LLongToIntFunction constant(int r)

Creates function that always returns the same value.

longToIntFunc

@Nonnull
static LLongToIntFunction longToIntFunc(@Nonnull
                                                  LLongToIntFunction lambda)

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

recursive

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

longToIntFuncThrowing

@Nonnull
static LLongToIntFunction longToIntFuncThrowing(@Nonnull
                                                          ExF<Throwable> exF)

longToIntFuncThrowing

@Nonnull
static LLongToIntFunction longToIntFuncThrowing(String message,
                                                          @Nonnull
                                                          ExMF<Throwable> exF)

call

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

wrap

@Nonnull
static LLongToIntFunction wrap(java.util.function.LongToIntFunction other)

Wraps JRE instance.

safe

@Nonnull
static LLongToIntFunction safe()

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

safeSupplier

@Nonnull
static LSupplier<LLongToIntFunction> safeSupplier()

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

safe

@Nonnull
static LLongToIntFunction safe(@Nullable
                                         LLongToIntFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LLongToIntFunction compose(@Nonnull
                                             LLongUnaryOperator before)

Allows to manipulate the domain of the function.

composed

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

longToIntFuncCompose

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

Allows to manipulate the domain of the function.

composed

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

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LLongToByteFunction thenToByte(@Nonnull
                                                 LIntToByteFunction after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LLongToSrtFunction thenToSrt(@Nonnull
                                               LIntToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LLongToIntFunction thenToInt(@Nonnull
                                               LIntUnaryOperator after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LLongUnaryOperator thenToLong(@Nonnull
                                                LIntToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LLongToFltFunction thenToFlt(@Nonnull
                                               LIntToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LLongToDblFunction thenToDbl(@Nonnull
                                               LIntToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LLongToCharFunction thenToChar(@Nonnull
                                                 LIntToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LLongPredicate thenToBool(@Nonnull
                                            LIntPredicate after)

Combines two functions together in a order.

produceInt

static int produceInt(long a)

Does nothing (LLongToIntFunction) Function

forEach

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