eu.lunisolar.magma.func.function.conversion

Interface LLongToSrtFunction

All Superinterfaces:

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

All Known Implementing Classes:

LLongToSrtFunction.LLongToSrtFunctionSingle

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

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

Type: function

Domain (lvl: 1): long a

Co-domain: short

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LLongToSrtFunction.LLongToSrtFunctionSingle

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 short	applyAsSrt(long a)
default short	applyAsSrt(long a, ExWF<RuntimeException> exF)
default short	applyAsSrt(long a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default short	applyAsSrtThen(long a, LToSrtFunction<Throwable> handler)
short	applyAsSrtX(long a) Implement this, but call applyAsSrt(long a)
static short	call(long a, LLongToSrtFunction lambda)
default LSrtSupplier	capture(long a) Captures arguments but delays the evaluation.
default LLongToSrtFunction	compose(LLongUnaryOperator before) Allows to manipulate the domain of the function.
static LLongToSrtFunction	composed(LLongUnaryOperator before, LLongToSrtFunction after)
static <V> LToSrtFunction<V>	composed(LToLongFunction<? super V> before, LLongToSrtFunction after)
static LLongToSrtFunction	constant(short r) Creates function that always returns the same value.
static LLongToSrtFunction	failSafe(LLongToSrtFunction func, LLongToSrtFunction failSafe)
default short	failSafeApplyAsSrt(long a, LLongToSrtFunction failSafe)
static short	failSafeApplyAsSrt(long a, LLongToSrtFunction func, LLongToSrtFunction failSafe)
default <C0> void	forEach(IndexedRead<C0,aType.aLong> ia, C0 source, LSrtConsumer 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, LLongToSrtFunction func) From-To.
static void	fromTo(long min_a, long max_a, LLongToSrtFunction func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LLongToSrtFunction	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default short	handlingApplyAsSrt(long a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static short	handlingApplyAsSrt(long a, LLongToSrtFunction func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aLong> sa, C0 source, LSrtConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static LLongToSrtFunction	longToSrtFunc(LLongToSrtFunction lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V> LToSrtFunction<V>	longToSrtFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
static LLongToSrtFunction	longToSrtFuncThrowing(ExF<Throwable> exF)
static LLongToSrtFunction	longToSrtFuncThrowing(String message, ExMF<Throwable> exF)
default short	nestingApplyAsSrt(long a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default short	nonNullApplyAsSrt(long a) Just to mirror the method: Ensures the result is not null
static short	produceShort(long a) Does nothing (LLongToSrtFunction) Function
static LLongToSrtFunction	recursive(LFunction<LLongToSrtFunction,LLongToSrtFunction> selfLambda)
static LLongToSrtFunction	safe() Safe instance.
static LLongToSrtFunction	safe(LLongToSrtFunction other) Safe wrapping.
static LSupplier<LLongToSrtFunction>	safeSupplier() Safe instance supplier.
static LSupplier<LLongToSrtFunction>	safeSupplier(LSupplier<LLongToSrtFunction> supplier) Safe supplier.
default short	shovingApplyAsSrt(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(LSrtFunction<? extends V> after) Combines two functions together in a order.
default LLongPredicate	thenToBool(LSrtPredicate after) Combines two functions together in a order.
default LLongToByteFunction	thenToByte(LSrtToByteFunction after) Combines two functions together in a order.
default LLongToCharFunction	thenToChar(LSrtToCharFunction after) Combines two functions together in a order.
default LLongToDblFunction	thenToDbl(LSrtToDblFunction after) Combines two functions together in a order.
default LLongToFltFunction	thenToFlt(LSrtToFltFunction after) Combines two functions together in a order.
default LLongToIntFunction	thenToInt(LSrtToIntFunction after) Combines two functions together in a order.
default LLongUnaryOperator	thenToLong(LSrtToLongFunction after) Combines two functions together in a order.
default LLongToSrtFunction	thenToSrt(LSrtUnaryOperator after) Combines two functions together in a order.
static void	times(long max_a, LLongToSrtFunction func) From-To.
static short	tryApplyAsSrt(long a, LLongToSrtFunction func)
static short	tryApplyAsSrt(long a, LLongToSrtFunction func, ExWF<RuntimeException> exF)
static short	tryApplyAsSrt(long a, LLongToSrtFunction func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static short	tryApplyAsSrtThen(long a, LLongToSrtFunction func, LToSrtFunction<Throwable> handler)
default LLongToSrtFunction	trying(ExWF<RuntimeException> exF)
default LLongToSrtFunction	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LLongToSrtFunction	tryingThen(LToSrtFunction<Throwable> handler)
default short	tupleApplyAsSrt(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

applyAsSrt

default short applyAsSrt(long a)

applyAsSrtX

short applyAsSrtX(long a)
           throws Throwable

Implement this, but call applyAsSrt(long a)

Throws:

Throwable

tupleApplyAsSrt

default short tupleApplyAsSrt(LLongSingle args)

handlingApplyAsSrt

default short handlingApplyAsSrt(long a,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

applyAsSrt

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

trying

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

applyAsSrt

default short applyAsSrt(long a,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

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

applyAsSrtThen

default short applyAsSrtThen(long a,
                             @Nonnull
                             LToSrtFunction<Throwable> handler)

tryingThen

default LLongToSrtFunction tryingThen(@Nonnull
                                      LToSrtFunction<Throwable> handler)

nestingApplyAsSrt

default short nestingApplyAsSrt(long a)

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

shovingApplyAsSrt

default short shovingApplyAsSrt(long a)

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

handlingApplyAsSrt

static short handlingApplyAsSrt(long a,
                                LLongToSrtFunction func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsSrt

static short tryApplyAsSrt(long a,
                           LLongToSrtFunction func)

tryApplyAsSrt

static short tryApplyAsSrt(long a,
                           LLongToSrtFunction func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryApplyAsSrt

static short tryApplyAsSrt(long a,
                           LLongToSrtFunction func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsSrtThen

static short tryApplyAsSrtThen(long a,
                               LLongToSrtFunction func,
                               @Nonnull
                               LToSrtFunction<Throwable> handler)

failSafeApplyAsSrt

default short failSafeApplyAsSrt(long a,
                                 @Nonnull
                                 LLongToSrtFunction failSafe)

failSafeApplyAsSrt

static short failSafeApplyAsSrt(long a,
                                LLongToSrtFunction func,
                                @Nonnull
                                LLongToSrtFunction failSafe)

failSafe

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

nonNullApplyAsSrt

default short nonNullApplyAsSrt(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,
                   LLongToSrtFunction func)

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

fromTill

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

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

times

static void times(long max_a,
                  LLongToSrtFunction func)

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

capture

default LSrtSupplier capture(long a)

Captures arguments but delays the evaluation.

constant

static LLongToSrtFunction constant(short r)

Creates function that always returns the same value.

longToSrtFunc

@Nonnull
static LLongToSrtFunction longToSrtFunc(@Nonnull
                                                  LLongToSrtFunction lambda)

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

recursive

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

longToSrtFuncThrowing

@Nonnull
static LLongToSrtFunction longToSrtFuncThrowing(@Nonnull
                                                          ExF<Throwable> exF)

longToSrtFuncThrowing

@Nonnull
static LLongToSrtFunction longToSrtFuncThrowing(String message,
                                                          @Nonnull
                                                          ExMF<Throwable> exF)

call

static short call(long a,
                  @Nonnull
                  LLongToSrtFunction lambda)

safe

@Nonnull
static LLongToSrtFunction safe()

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

safeSupplier

@Nonnull
static LSupplier<LLongToSrtFunction> safeSupplier()

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

safe

@Nonnull
static LLongToSrtFunction safe(@Nullable
                                         LLongToSrtFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LLongToSrtFunction compose(@Nonnull
                                             LLongUnaryOperator before)

Allows to manipulate the domain of the function.

composed

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

longToSrtFuncCompose

@Nonnull
default <V> LToSrtFunction<V> longToSrtFuncCompose(@Nonnull
                                                             LToLongFunction<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LToSrtFunction<V> composed(@Nonnull
                                      LToLongFunction<? super V> before,
                                      LLongToSrtFunction after)

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LLongToByteFunction thenToByte(@Nonnull
                                                 LSrtToByteFunction after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LLongToSrtFunction thenToSrt(@Nonnull
                                               LSrtUnaryOperator after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LLongToIntFunction thenToInt(@Nonnull
                                               LSrtToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LLongUnaryOperator thenToLong(@Nonnull
                                                LSrtToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LLongToFltFunction thenToFlt(@Nonnull
                                               LSrtToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LLongToDblFunction thenToDbl(@Nonnull
                                               LSrtToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LLongToCharFunction thenToChar(@Nonnull
                                                 LSrtToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LLongPredicate thenToBool(@Nonnull
                                            LSrtPredicate after)

Combines two functions together in a order.

produceShort

static short produceShort(long a)

Does nothing (LLongToSrtFunction) Function

forEach

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