eu.lunisolar.magma.func.function.conversion

Interface LLongToByteFunction

All Superinterfaces:

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

All Known Implementing Classes:

LLongToByteFunction.LLongToByteFunctionSingle

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

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

Type: function

Domain (lvl: 1): long a

Co-domain: byte

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LLongToByteFunction.LLongToByteFunctionSingle

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 byte	applyAsByte(long a)
default byte	applyAsByte(long a, ExWF<RuntimeException> exF)
default byte	applyAsByte(long a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default byte	applyAsByteThen(long a, LToByteFunction<Throwable> handler)
byte	applyAsByteX(long a) Implement this, but call applyAsByte(long a)
static byte	call(long a, LLongToByteFunction lambda)
default LByteSupplier	capture(long a) Captures arguments but delays the evaluation.
default LLongToByteFunction	compose(LLongUnaryOperator before) Allows to manipulate the domain of the function.
static LLongToByteFunction	composed(LLongUnaryOperator before, LLongToByteFunction after)
static <V> LToByteFunction<V>	composed(LToLongFunction<? super V> before, LLongToByteFunction after)
static LLongToByteFunction	constant(byte r) Creates function that always returns the same value.
static LLongToByteFunction	failSafe(LLongToByteFunction func, LLongToByteFunction failSafe)
default byte	failSafeApplyAsByte(long a, LLongToByteFunction failSafe)
static byte	failSafeApplyAsByte(long a, LLongToByteFunction func, LLongToByteFunction failSafe)
default <C0> void	forEach(IndexedRead<C0,aType.aLong> ia, C0 source, LByteConsumer 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, LLongToByteFunction func) From-To.
static void	fromTo(long min_a, long max_a, LLongToByteFunction func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LLongToByteFunction	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default byte	handlingApplyAsByte(long a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static byte	handlingApplyAsByte(long a, LLongToByteFunction func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aLong> sa, C0 source, LByteConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static LLongToByteFunction	longToByteFunc(LLongToByteFunction lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V> LToByteFunction<V>	longToByteFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
static LLongToByteFunction	longToByteFuncThrowing(ExF<Throwable> exF)
static LLongToByteFunction	longToByteFuncThrowing(String message, ExMF<Throwable> exF)
default byte	nestingApplyAsByte(long a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default byte	nonNullApplyAsByte(long a) Just to mirror the method: Ensures the result is not null
static byte	produceByte(long a) Does nothing (LLongToByteFunction) Function
static LLongToByteFunction	recursive(LFunction<LLongToByteFunction,LLongToByteFunction> selfLambda)
static LLongToByteFunction	safe() Safe instance.
static LLongToByteFunction	safe(LLongToByteFunction other) Safe wrapping.
static LSupplier<LLongToByteFunction>	safeSupplier() Safe instance supplier.
static LSupplier<LLongToByteFunction>	safeSupplier(LSupplier<LLongToByteFunction> supplier) Safe supplier.
default byte	shovingApplyAsByte(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(LByteFunction<? extends V> after) Combines two functions together in a order.
default LLongPredicate	thenToBool(LBytePredicate after) Combines two functions together in a order.
default LLongToByteFunction	thenToByte(LByteUnaryOperator after) Combines two functions together in a order.
default LLongToCharFunction	thenToChar(LByteToCharFunction after) Combines two functions together in a order.
default LLongToDblFunction	thenToDbl(LByteToDblFunction after) Combines two functions together in a order.
default LLongToFltFunction	thenToFlt(LByteToFltFunction after) Combines two functions together in a order.
default LLongToIntFunction	thenToInt(LByteToIntFunction after) Combines two functions together in a order.
default LLongUnaryOperator	thenToLong(LByteToLongFunction after) Combines two functions together in a order.
default LLongToSrtFunction	thenToSrt(LByteToSrtFunction after) Combines two functions together in a order.
static void	times(long max_a, LLongToByteFunction func) From-To.
static byte	tryApplyAsByte(long a, LLongToByteFunction func)
static byte	tryApplyAsByte(long a, LLongToByteFunction func, ExWF<RuntimeException> exF)
static byte	tryApplyAsByte(long a, LLongToByteFunction func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static byte	tryApplyAsByteThen(long a, LLongToByteFunction func, LToByteFunction<Throwable> handler)
default LLongToByteFunction	trying(ExWF<RuntimeException> exF)
default LLongToByteFunction	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LLongToByteFunction	tryingThen(LToByteFunction<Throwable> handler)
default byte	tupleApplyAsByte(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

applyAsByte

default byte applyAsByte(long a)

applyAsByteX

byte applyAsByteX(long a)
           throws Throwable

Implement this, but call applyAsByte(long a)

Throws:

Throwable

tupleApplyAsByte

default byte tupleApplyAsByte(LLongSingle args)

handlingApplyAsByte

default byte handlingApplyAsByte(long a,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

applyAsByte

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

trying

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

applyAsByte

default byte applyAsByte(long a,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

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

applyAsByteThen

default byte applyAsByteThen(long a,
                             @Nonnull
                             LToByteFunction<Throwable> handler)

tryingThen

default LLongToByteFunction tryingThen(@Nonnull
                                       LToByteFunction<Throwable> handler)

nestingApplyAsByte

default byte nestingApplyAsByte(long a)

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

shovingApplyAsByte

default byte shovingApplyAsByte(long a)

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

handlingApplyAsByte

static byte handlingApplyAsByte(long a,
                                LLongToByteFunction func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsByte

static byte tryApplyAsByte(long a,
                           LLongToByteFunction func)

tryApplyAsByte

static byte tryApplyAsByte(long a,
                           LLongToByteFunction func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryApplyAsByte

static byte tryApplyAsByte(long a,
                           LLongToByteFunction func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsByteThen

static byte tryApplyAsByteThen(long a,
                               LLongToByteFunction func,
                               @Nonnull
                               LToByteFunction<Throwable> handler)

failSafeApplyAsByte

default byte failSafeApplyAsByte(long a,
                                 @Nonnull
                                 LLongToByteFunction failSafe)

failSafeApplyAsByte

static byte failSafeApplyAsByte(long a,
                                LLongToByteFunction func,
                                @Nonnull
                                LLongToByteFunction failSafe)

failSafe

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

nonNullApplyAsByte

default byte nonNullApplyAsByte(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,
                   LLongToByteFunction func)

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

fromTill

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

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

times

static void times(long max_a,
                  LLongToByteFunction func)

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

capture

default LByteSupplier capture(long a)

Captures arguments but delays the evaluation.

constant

static LLongToByteFunction constant(byte r)

Creates function that always returns the same value.

longToByteFunc

@Nonnull
static LLongToByteFunction longToByteFunc(@Nonnull
                                                    LLongToByteFunction lambda)

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

recursive

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

longToByteFuncThrowing

@Nonnull
static LLongToByteFunction longToByteFuncThrowing(@Nonnull
                                                            ExF<Throwable> exF)

longToByteFuncThrowing

@Nonnull
static LLongToByteFunction longToByteFuncThrowing(String message,
                                                            @Nonnull
                                                            ExMF<Throwable> exF)

call

static byte call(long a,
                 @Nonnull
                 LLongToByteFunction lambda)

safe

@Nonnull
static LLongToByteFunction safe()

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

safeSupplier

@Nonnull
static LSupplier<LLongToByteFunction> safeSupplier()

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

safe

@Nonnull
static LLongToByteFunction safe(@Nullable
                                          LLongToByteFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LLongToByteFunction compose(@Nonnull
                                              LLongUnaryOperator before)

Allows to manipulate the domain of the function.

composed

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

longToByteFuncCompose

@Nonnull
default <V> LToByteFunction<V> longToByteFuncCompose(@Nonnull
                                                               LToLongFunction<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LToByteFunction<V> composed(@Nonnull
                                       LToLongFunction<? super V> before,
                                       LLongToByteFunction after)

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LLongToByteFunction thenToByte(@Nonnull
                                                 LByteUnaryOperator after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LLongToSrtFunction thenToSrt(@Nonnull
                                               LByteToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LLongToIntFunction thenToInt(@Nonnull
                                               LByteToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LLongUnaryOperator thenToLong(@Nonnull
                                                LByteToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LLongToFltFunction thenToFlt(@Nonnull
                                               LByteToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LLongToDblFunction thenToDbl(@Nonnull
                                               LByteToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LLongToCharFunction thenToChar(@Nonnull
                                                 LByteToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LLongPredicate thenToBool(@Nonnull
                                            LBytePredicate after)

Combines two functions together in a order.

produceByte

static byte produceByte(long a)

Does nothing (LLongToByteFunction) Function

forEach

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