eu.lunisolar.magma.func.function.conversion

Interface LByteToIntFunction

All Superinterfaces:

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

All Known Implementing Classes:

LByteToIntFunction.LByteToIntFunctionSingle

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

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

Type: function

Domain (lvl: 1): byte a

Co-domain: int

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LByteToIntFunction.LByteToIntFunctionSingle

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(byte a)
default int	applyAsInt(byte a, ExWF<RuntimeException> exF)
default int	applyAsInt(byte a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default int	applyAsIntThen(byte a, LToIntFunction<Throwable> handler)
int	applyAsIntX(byte a) Implement this, but call applyAsInt(byte a)
static LByteToIntFunction	byteToIntFunc(LByteToIntFunction 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>	byteToIntFuncCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
static LByteToIntFunction	byteToIntFuncThrowing(ExF<Throwable> exF)
static LByteToIntFunction	byteToIntFuncThrowing(String message, ExMF<Throwable> exF)
static int	call(byte a, LByteToIntFunction lambda)
default LIntSupplier	capture(byte a) Captures arguments but delays the evaluation.
default LByteToIntFunction	compose(LByteUnaryOperator before) Allows to manipulate the domain of the function.
static LByteToIntFunction	composed(LByteUnaryOperator before, LByteToIntFunction after)
static <V> LToIntFunction<V>	composed(LToByteFunction<? super V> before, LByteToIntFunction after)
static LByteToIntFunction	constant(int r) Creates function that always returns the same value.
static LByteToIntFunction	failSafe(LByteToIntFunction func, LByteToIntFunction failSafe)
default int	failSafeApplyAsInt(byte a, LByteToIntFunction failSafe)
static int	failSafeApplyAsInt(byte a, LByteToIntFunction func, LByteToIntFunction failSafe)
default <C0> void	forEach(IndexedRead<C0,aType.aByte> ia, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static void	fromTill(int min_i, int max_i, byte a, LByteToIntFunction func) From-To.
static void	fromTo(int min_i, int max_i, byte a, LByteToIntFunction func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LByteToIntFunction	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default int	handlingApplyAsInt(byte a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static int	handlingApplyAsInt(byte a, LByteToIntFunction func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aByte> sa, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default int	nestingApplyAsInt(byte a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default int	nonNullApplyAsInt(byte a) Just to mirror the method: Ensures the result is not null
static int	produceInt(byte a) Does nothing (LByteToIntFunction) Function
static LByteToIntFunction	recursive(LFunction<LByteToIntFunction,LByteToIntFunction> selfLambda)
static LByteToIntFunction	safe() Safe instance.
static LByteToIntFunction	safe(LByteToIntFunction other) Safe wrapping.
static LSupplier<LByteToIntFunction>	safeSupplier() Safe instance supplier.
static LSupplier<LByteToIntFunction>	safeSupplier(LSupplier<LByteToIntFunction> supplier) Safe supplier.
default int	shovingApplyAsInt(byte a) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default <V> LByteFunction<V>	then(LIntFunction<? extends V> after) Combines two functions together in a order.
default LBytePredicate	thenToBool(LIntPredicate after) Combines two functions together in a order.
default LByteUnaryOperator	thenToByte(LIntToByteFunction after) Combines two functions together in a order.
default LByteToCharFunction	thenToChar(LIntToCharFunction after) Combines two functions together in a order.
default LByteToDblFunction	thenToDbl(LIntToDblFunction after) Combines two functions together in a order.
default LByteToFltFunction	thenToFlt(LIntToFltFunction after) Combines two functions together in a order.
default LByteToIntFunction	thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LByteToLongFunction	thenToLong(LIntToLongFunction after) Combines two functions together in a order.
default LByteToSrtFunction	thenToSrt(LIntToSrtFunction after) Combines two functions together in a order.
static void	times(int max_i, byte a, LByteToIntFunction func) From-To.
static int	tryApplyAsInt(byte a, LByteToIntFunction func)
static int	tryApplyAsInt(byte a, LByteToIntFunction func, ExWF<RuntimeException> exF)
static int	tryApplyAsInt(byte a, LByteToIntFunction func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static int	tryApplyAsIntThen(byte a, LByteToIntFunction func, LToIntFunction<Throwable> handler)
default LByteToIntFunction	trying(ExWF<RuntimeException> exF)
default LByteToIntFunction	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LByteToIntFunction	tryingThen(LToIntFunction<Throwable> handler)
default int	tupleApplyAsInt(LByteSingle 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

applyAsInt

default int applyAsInt(byte a)

applyAsIntX

int applyAsIntX(byte a)
         throws Throwable

Implement this, but call applyAsInt(byte a)

Throws:

Throwable

tupleApplyAsInt

default int tupleApplyAsInt(LByteSingle args)

handlingApplyAsInt

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

Function call that handles exceptions according to the instructions.

handling

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

applyAsInt

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

trying

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

applyAsInt

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

trying

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

applyAsIntThen

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

tryingThen

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

nestingApplyAsInt

default int nestingApplyAsInt(byte a)

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

shovingApplyAsInt

default int shovingApplyAsInt(byte a)

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

handlingApplyAsInt

static int handlingApplyAsInt(byte a,
                              LByteToIntFunction func,
                              HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsInt

static int tryApplyAsInt(byte a,
                         LByteToIntFunction func)

tryApplyAsInt

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

tryApplyAsInt

static int tryApplyAsInt(byte a,
                         LByteToIntFunction func,
                         @Nonnull
                         ExWF<RuntimeException> exF)

tryApplyAsIntThen

static int tryApplyAsIntThen(byte a,
                             LByteToIntFunction func,
                             @Nonnull
                             LToIntFunction<Throwable> handler)

failSafeApplyAsInt

default int failSafeApplyAsInt(byte a,
                               @Nonnull
                               LByteToIntFunction failSafe)

failSafeApplyAsInt

static int failSafeApplyAsInt(byte a,
                              LByteToIntFunction func,
                              @Nonnull
                              LByteToIntFunction failSafe)

failSafe

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

nonNullApplyAsInt

default int nonNullApplyAsInt(byte 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_i,
                   int max_i,
                   byte a,
                   LByteToIntFunction func)

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     byte a,
                     LByteToIntFunction func)

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

times

static void times(int max_i,
                  byte a,
                  LByteToIntFunction func)

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

capture

default LIntSupplier capture(byte a)

Captures arguments but delays the evaluation.

constant

static LByteToIntFunction constant(int r)

Creates function that always returns the same value.

byteToIntFunc

@Nonnull
static LByteToIntFunction byteToIntFunc(@Nonnull
                                                  LByteToIntFunction lambda)

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

recursive

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

byteToIntFuncThrowing

@Nonnull
static LByteToIntFunction byteToIntFuncThrowing(@Nonnull
                                                          ExF<Throwable> exF)

byteToIntFuncThrowing

@Nonnull
static LByteToIntFunction byteToIntFuncThrowing(String message,
                                                          @Nonnull
                                                          ExMF<Throwable> exF)

call

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

safe

@Nonnull
static LByteToIntFunction safe()

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

safeSupplier

@Nonnull
static LSupplier<LByteToIntFunction> safeSupplier()

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

safe

@Nonnull
static LByteToIntFunction safe(@Nullable
                                         LByteToIntFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LByteToIntFunction compose(@Nonnull
                                             LByteUnaryOperator before)

Allows to manipulate the domain of the function.

composed

static LByteToIntFunction composed(@Nonnull
                                   LByteUnaryOperator before,
                                   LByteToIntFunction after)

byteToIntFuncCompose

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

Allows to manipulate the domain of the function.

composed

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

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LByteUnaryOperator thenToByte(@Nonnull
                                                LIntToByteFunction after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LByteToSrtFunction thenToSrt(@Nonnull
                                               LIntToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LByteToIntFunction thenToInt(@Nonnull
                                               LIntUnaryOperator after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LByteToLongFunction thenToLong(@Nonnull
                                                 LIntToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LByteToFltFunction thenToFlt(@Nonnull
                                               LIntToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LByteToDblFunction thenToDbl(@Nonnull
                                               LIntToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LByteToCharFunction thenToChar(@Nonnull
                                                 LIntToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LBytePredicate thenToBool(@Nonnull
                                            LIntPredicate after)

Combines two functions together in a order.

produceInt

static int produceInt(byte a)

Does nothing (LByteToIntFunction) Function

forEach

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