eu.lunisolar.magma.func.function.conversion

Interface LIntToByteFunction

All Superinterfaces:

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

All Known Implementing Classes:

LIntToByteFunction.LIntToByteFunctionSingle

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

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

Type: function

Domain (lvl: 1): int a

Co-domain: byte

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LIntToByteFunction.LIntToByteFunctionSingle

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

applyAsByteX

byte applyAsByteX(int a)
           throws Throwable

Implement this, but call applyAsByte(int a)

Throws:

Throwable

tupleApplyAsByte

default byte tupleApplyAsByte(LIntSingle args)

handlingApplyAsByte

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

Function call that handles exceptions according to the instructions.

handling

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

applyAsByte

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

trying

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

applyAsByte

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

trying

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

applyAsByteThen

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

tryingThen

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

nestingApplyAsByte

default byte nestingApplyAsByte(int a)

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

shovingApplyAsByte

default byte shovingApplyAsByte(int a)

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

handlingApplyAsByte

static byte handlingApplyAsByte(int a,
                                LIntToByteFunction func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsByte

static byte tryApplyAsByte(int a,
                           LIntToByteFunction func)

tryApplyAsByte

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

tryApplyAsByte

static byte tryApplyAsByte(int a,
                           LIntToByteFunction func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsByteThen

static byte tryApplyAsByteThen(int a,
                               LIntToByteFunction func,
                               @Nonnull
                               LToByteFunction<Throwable> handler)

failSafeApplyAsByte

default byte failSafeApplyAsByte(int a,
                                 @Nonnull
                                 LIntToByteFunction failSafe)

failSafeApplyAsByte

static byte failSafeApplyAsByte(int a,
                                LIntToByteFunction func,
                                @Nonnull
                                LIntToByteFunction failSafe)

failSafe

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

nonNullApplyAsByte

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

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

fromTill

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

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

times

static void times(int max_a,
                  LIntToByteFunction func)

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

capture

default LByteSupplier capture(int a)

Captures arguments but delays the evaluation.

constant

static LIntToByteFunction constant(byte r)

Creates function that always returns the same value.

intToByteFunc

@Nonnull
static LIntToByteFunction intToByteFunc(@Nonnull
                                                  LIntToByteFunction lambda)

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

recursive

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

intToByteFuncThrowing

@Nonnull
static LIntToByteFunction intToByteFuncThrowing(@Nonnull
                                                          ExF<Throwable> exF)

intToByteFuncThrowing

@Nonnull
static LIntToByteFunction intToByteFuncThrowing(String message,
                                                          @Nonnull
                                                          ExMF<Throwable> exF)

call

static byte call(int a,
                 @Nonnull
                 LIntToByteFunction lambda)

safe

@Nonnull
static LIntToByteFunction safe()

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

safeSupplier

@Nonnull
static LSupplier<LIntToByteFunction> safeSupplier()

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

safe

@Nonnull
static LIntToByteFunction safe(@Nullable
                                         LIntToByteFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LIntToByteFunction compose(@Nonnull
                                             LIntUnaryOperator before)

Allows to manipulate the domain of the function.

composed

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

intToByteFuncCompose

@Nonnull
default <V> LToByteFunction<V> intToByteFuncCompose(@Nonnull
                                                              LToIntFunction<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LToByteFunction<V> composed(@Nonnull
                                       LToIntFunction<? super V> before,
                                       LIntToByteFunction after)

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LIntToByteFunction thenToByte(@Nonnull
                                                LByteUnaryOperator after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LIntToSrtFunction thenToSrt(@Nonnull
                                              LByteToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LIntUnaryOperator thenToInt(@Nonnull
                                              LByteToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LIntToLongFunction thenToLong(@Nonnull
                                                LByteToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LIntToFltFunction thenToFlt(@Nonnull
                                              LByteToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LIntToDblFunction thenToDbl(@Nonnull
                                              LByteToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LIntToCharFunction thenToChar(@Nonnull
                                                LByteToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LIntPredicate thenToBool(@Nonnull
                                           LBytePredicate after)

Combines two functions together in a order.

produceByte

static byte produceByte(int a)

Does nothing (LIntToByteFunction) Function

forEach

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