eu.lunisolar.magma.func.function.conversion

Interface LLongToCharFunction

All Superinterfaces:

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

All Known Implementing Classes:

LLongToCharFunction.LLongToCharFunctionSingle

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

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

Type: function

Domain (lvl: 1): long a

Co-domain: char

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LLongToCharFunction.LLongToCharFunctionSingle

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 char	applyAsChar(long a)
default char	applyAsChar(long a, ExWF<RuntimeException> exF)
default char	applyAsChar(long a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default char	applyAsCharThen(long a, LToCharFunction<Throwable> handler)
char	applyAsCharX(long a) Implement this, but call applyAsChar(long a)
static char	call(long a, LLongToCharFunction lambda)
default LCharSupplier	capture(long a) Captures arguments but delays the evaluation.
default LLongToCharFunction	compose(LLongUnaryOperator before) Allows to manipulate the domain of the function.
static LLongToCharFunction	composed(LLongUnaryOperator before, LLongToCharFunction after)
static <V> LToCharFunction<V>	composed(LToLongFunction<? super V> before, LLongToCharFunction after)
static LLongToCharFunction	constant(char r) Creates function that always returns the same value.
static LLongToCharFunction	failSafe(LLongToCharFunction func, LLongToCharFunction failSafe)
default char	failSafeApplyAsChar(long a, LLongToCharFunction failSafe)
static char	failSafeApplyAsChar(long a, LLongToCharFunction func, LLongToCharFunction failSafe)
default <C0> void	forEach(IndexedRead<C0,aType.aLong> ia, C0 source, LCharConsumer 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, LLongToCharFunction func) From-To.
static void	fromTo(long min_a, long max_a, LLongToCharFunction func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LLongToCharFunction	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default char	handlingApplyAsChar(long a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static char	handlingApplyAsChar(long a, LLongToCharFunction func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aLong> sa, C0 source, LCharConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static LLongToCharFunction	longToCharFunc(LLongToCharFunction lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V> LToCharFunction<V>	longToCharFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
static LLongToCharFunction	longToCharFuncThrowing(ExF<Throwable> exF)
static LLongToCharFunction	longToCharFuncThrowing(String message, ExMF<Throwable> exF)
default char	nestingApplyAsChar(long a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default char	nonNullApplyAsChar(long a) Just to mirror the method: Ensures the result is not null
static char	produceChar(long a) Does nothing (LLongToCharFunction) Function
static LLongToCharFunction	recursive(LFunction<LLongToCharFunction,LLongToCharFunction> selfLambda)
static LLongToCharFunction	safe() Safe instance.
static LLongToCharFunction	safe(LLongToCharFunction other) Safe wrapping.
static LSupplier<LLongToCharFunction>	safeSupplier() Safe instance supplier.
static LSupplier<LLongToCharFunction>	safeSupplier(LSupplier<LLongToCharFunction> supplier) Safe supplier.
default char	shovingApplyAsChar(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(LCharFunction<? extends V> after) Combines two functions together in a order.
default LLongPredicate	thenToBool(LCharPredicate after) Combines two functions together in a order.
default LLongToByteFunction	thenToByte(LCharToByteFunction after) Combines two functions together in a order.
default LLongToCharFunction	thenToChar(LCharUnaryOperator after) Combines two functions together in a order.
default LLongToDblFunction	thenToDbl(LCharToDblFunction after) Combines two functions together in a order.
default LLongToFltFunction	thenToFlt(LCharToFltFunction after) Combines two functions together in a order.
default LLongToIntFunction	thenToInt(LCharToIntFunction after) Combines two functions together in a order.
default LLongUnaryOperator	thenToLong(LCharToLongFunction after) Combines two functions together in a order.
default LLongToSrtFunction	thenToSrt(LCharToSrtFunction after) Combines two functions together in a order.
static void	times(long max_a, LLongToCharFunction func) From-To.
static char	tryApplyAsChar(long a, LLongToCharFunction func)
static char	tryApplyAsChar(long a, LLongToCharFunction func, ExWF<RuntimeException> exF)
static char	tryApplyAsChar(long a, LLongToCharFunction func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static char	tryApplyAsCharThen(long a, LLongToCharFunction func, LToCharFunction<Throwable> handler)
default LLongToCharFunction	trying(ExWF<RuntimeException> exF)
default LLongToCharFunction	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LLongToCharFunction	tryingThen(LToCharFunction<Throwable> handler)
default char	tupleApplyAsChar(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

applyAsChar

default char applyAsChar(long a)

applyAsCharX

char applyAsCharX(long a)
           throws Throwable

Implement this, but call applyAsChar(long a)

Throws:

Throwable

tupleApplyAsChar

default char tupleApplyAsChar(LLongSingle args)

handlingApplyAsChar

default char handlingApplyAsChar(long a,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

applyAsChar

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

trying

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

applyAsChar

default char applyAsChar(long a,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

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

applyAsCharThen

default char applyAsCharThen(long a,
                             @Nonnull
                             LToCharFunction<Throwable> handler)

tryingThen

default LLongToCharFunction tryingThen(@Nonnull
                                       LToCharFunction<Throwable> handler)

nestingApplyAsChar

default char nestingApplyAsChar(long a)

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

shovingApplyAsChar

default char shovingApplyAsChar(long a)

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

handlingApplyAsChar

static char handlingApplyAsChar(long a,
                                LLongToCharFunction func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsChar

static char tryApplyAsChar(long a,
                           LLongToCharFunction func)

tryApplyAsChar

static char tryApplyAsChar(long a,
                           LLongToCharFunction func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryApplyAsChar

static char tryApplyAsChar(long a,
                           LLongToCharFunction func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsCharThen

static char tryApplyAsCharThen(long a,
                               LLongToCharFunction func,
                               @Nonnull
                               LToCharFunction<Throwable> handler)

failSafeApplyAsChar

default char failSafeApplyAsChar(long a,
                                 @Nonnull
                                 LLongToCharFunction failSafe)

failSafeApplyAsChar

static char failSafeApplyAsChar(long a,
                                LLongToCharFunction func,
                                @Nonnull
                                LLongToCharFunction failSafe)

failSafe

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

nonNullApplyAsChar

default char nonNullApplyAsChar(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,
                   LLongToCharFunction func)

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

fromTill

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

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

times

static void times(long max_a,
                  LLongToCharFunction func)

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

capture

default LCharSupplier capture(long a)

Captures arguments but delays the evaluation.

constant

static LLongToCharFunction constant(char r)

Creates function that always returns the same value.

longToCharFunc

@Nonnull
static LLongToCharFunction longToCharFunc(@Nonnull
                                                    LLongToCharFunction lambda)

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

recursive

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

longToCharFuncThrowing

@Nonnull
static LLongToCharFunction longToCharFuncThrowing(@Nonnull
                                                            ExF<Throwable> exF)

longToCharFuncThrowing

@Nonnull
static LLongToCharFunction longToCharFuncThrowing(String message,
                                                            @Nonnull
                                                            ExMF<Throwable> exF)

call

static char call(long a,
                 @Nonnull
                 LLongToCharFunction lambda)

safe

@Nonnull
static LLongToCharFunction safe()

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

safeSupplier

@Nonnull
static LSupplier<LLongToCharFunction> safeSupplier()

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

safe

@Nonnull
static LLongToCharFunction safe(@Nullable
                                          LLongToCharFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LLongToCharFunction compose(@Nonnull
                                              LLongUnaryOperator before)

Allows to manipulate the domain of the function.

composed

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

longToCharFuncCompose

@Nonnull
default <V> LToCharFunction<V> longToCharFuncCompose(@Nonnull
                                                               LToLongFunction<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LToCharFunction<V> composed(@Nonnull
                                       LToLongFunction<? super V> before,
                                       LLongToCharFunction after)

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LLongToByteFunction thenToByte(@Nonnull
                                                 LCharToByteFunction after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LLongToSrtFunction thenToSrt(@Nonnull
                                               LCharToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LLongToIntFunction thenToInt(@Nonnull
                                               LCharToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LLongUnaryOperator thenToLong(@Nonnull
                                                LCharToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LLongToFltFunction thenToFlt(@Nonnull
                                               LCharToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LLongToDblFunction thenToDbl(@Nonnull
                                               LCharToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LLongToCharFunction thenToChar(@Nonnull
                                                 LCharUnaryOperator after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LLongPredicate thenToBool(@Nonnull
                                            LCharPredicate after)

Combines two functions together in a order.

produceChar

static char produceChar(long a)

Does nothing (LLongToCharFunction) Function

forEach

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