eu.lunisolar.magma.func.function.conversion

Interface LSrtToByteFunction

All Superinterfaces:

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

All Known Implementing Classes:

LSrtToByteFunction.LSrtToByteFunctionSingle

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

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

Type: function

Domain (lvl: 1): short a

Co-domain: byte

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LSrtToByteFunction.LSrtToByteFunctionSingle

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(short a)
default byte	applyAsByte(short a, ExWF<RuntimeException> exF)
default byte	applyAsByte(short a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default byte	applyAsByteThen(short a, LToByteFunction<Throwable> handler)
byte	applyAsByteX(short a) Implement this, but call applyAsByte(short a)
static byte	call(short a, LSrtToByteFunction lambda)
default LByteSupplier	capture(short a) Captures arguments but delays the evaluation.
default LSrtToByteFunction	compose(LSrtUnaryOperator before) Allows to manipulate the domain of the function.
static LSrtToByteFunction	composed(LSrtUnaryOperator before, LSrtToByteFunction after)
static <V> LToByteFunction<V>	composed(LToSrtFunction<? super V> before, LSrtToByteFunction after)
static LSrtToByteFunction	constant(byte r) Creates function that always returns the same value.
static LSrtToByteFunction	failSafe(LSrtToByteFunction func, LSrtToByteFunction failSafe)
default byte	failSafeApplyAsByte(short a, LSrtToByteFunction failSafe)
static byte	failSafeApplyAsByte(short a, LSrtToByteFunction func, LSrtToByteFunction failSafe)
default <C0> void	forEach(IndexedRead<C0,aType.aShort> 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_i, int max_i, short a, LSrtToByteFunction func) From-To.
static void	fromTo(int min_i, int max_i, short a, LSrtToByteFunction func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LSrtToByteFunction	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default byte	handlingApplyAsByte(short a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static byte	handlingApplyAsByte(short a, LSrtToByteFunction func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aShort> sa, C0 source, LByteConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default byte	nestingApplyAsByte(short a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default byte	nonNullApplyAsByte(short a) Just to mirror the method: Ensures the result is not null
static byte	produceByte(short a) Does nothing (LSrtToByteFunction) Function
static LSrtToByteFunction	recursive(LFunction<LSrtToByteFunction,LSrtToByteFunction> selfLambda)
static LSrtToByteFunction	safe() Safe instance.
static LSrtToByteFunction	safe(LSrtToByteFunction other) Safe wrapping.
static LSupplier<LSrtToByteFunction>	safeSupplier() Safe instance supplier.
static LSupplier<LSrtToByteFunction>	safeSupplier(LSupplier<LSrtToByteFunction> supplier) Safe supplier.
default byte	shovingApplyAsByte(short a) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
static LSrtToByteFunction	srtToByteFunc(LSrtToByteFunction 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>	srtToByteFuncCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.
static LSrtToByteFunction	srtToByteFuncThrowing(ExF<Throwable> exF)
static LSrtToByteFunction	srtToByteFuncThrowing(String message, ExMF<Throwable> exF)
default <V> LSrtFunction<V>	then(LByteFunction<? extends V> after) Combines two functions together in a order.
default LSrtPredicate	thenToBool(LBytePredicate after) Combines two functions together in a order.
default LSrtToByteFunction	thenToByte(LByteUnaryOperator after) Combines two functions together in a order.
default LSrtToCharFunction	thenToChar(LByteToCharFunction after) Combines two functions together in a order.
default LSrtToDblFunction	thenToDbl(LByteToDblFunction after) Combines two functions together in a order.
default LSrtToFltFunction	thenToFlt(LByteToFltFunction after) Combines two functions together in a order.
default LSrtToIntFunction	thenToInt(LByteToIntFunction after) Combines two functions together in a order.
default LSrtToLongFunction	thenToLong(LByteToLongFunction after) Combines two functions together in a order.
default LSrtUnaryOperator	thenToSrt(LByteToSrtFunction after) Combines two functions together in a order.
static void	times(int max_i, short a, LSrtToByteFunction func) From-To.
static byte	tryApplyAsByte(short a, LSrtToByteFunction func)
static byte	tryApplyAsByte(short a, LSrtToByteFunction func, ExWF<RuntimeException> exF)
static byte	tryApplyAsByte(short a, LSrtToByteFunction func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static byte	tryApplyAsByteThen(short a, LSrtToByteFunction func, LToByteFunction<Throwable> handler)
default LSrtToByteFunction	trying(ExWF<RuntimeException> exF)
default LSrtToByteFunction	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LSrtToByteFunction	tryingThen(LToByteFunction<Throwable> handler)
default byte	tupleApplyAsByte(LSrtSingle 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(short a)

applyAsByteX

byte applyAsByteX(short a)
           throws Throwable

Implement this, but call applyAsByte(short a)

Throws:

Throwable

tupleApplyAsByte

default byte tupleApplyAsByte(LSrtSingle args)

handlingApplyAsByte

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

Function call that handles exceptions according to the instructions.

handling

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

applyAsByte

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

trying

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

applyAsByte

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

trying

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

applyAsByteThen

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

tryingThen

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

nestingApplyAsByte

default byte nestingApplyAsByte(short a)

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

shovingApplyAsByte

default byte shovingApplyAsByte(short a)

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

handlingApplyAsByte

static byte handlingApplyAsByte(short a,
                                LSrtToByteFunction func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsByte

static byte tryApplyAsByte(short a,
                           LSrtToByteFunction func)

tryApplyAsByte

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

tryApplyAsByte

static byte tryApplyAsByte(short a,
                           LSrtToByteFunction func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsByteThen

static byte tryApplyAsByteThen(short a,
                               LSrtToByteFunction func,
                               @Nonnull
                               LToByteFunction<Throwable> handler)

failSafeApplyAsByte

default byte failSafeApplyAsByte(short a,
                                 @Nonnull
                                 LSrtToByteFunction failSafe)

failSafeApplyAsByte

static byte failSafeApplyAsByte(short a,
                                LSrtToByteFunction func,
                                @Nonnull
                                LSrtToByteFunction failSafe)

failSafe

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

nonNullApplyAsByte

default byte nonNullApplyAsByte(short 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,
                   short a,
                   LSrtToByteFunction func)

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     short a,
                     LSrtToByteFunction func)

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

times

static void times(int max_i,
                  short a,
                  LSrtToByteFunction func)

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

capture

default LByteSupplier capture(short a)

Captures arguments but delays the evaluation.

constant

static LSrtToByteFunction constant(byte r)

Creates function that always returns the same value.

srtToByteFunc

@Nonnull
static LSrtToByteFunction srtToByteFunc(@Nonnull
                                                  LSrtToByteFunction lambda)

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

recursive

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

srtToByteFuncThrowing

@Nonnull
static LSrtToByteFunction srtToByteFuncThrowing(@Nonnull
                                                          ExF<Throwable> exF)

srtToByteFuncThrowing

@Nonnull
static LSrtToByteFunction srtToByteFuncThrowing(String message,
                                                          @Nonnull
                                                          ExMF<Throwable> exF)

call

static byte call(short a,
                 @Nonnull
                 LSrtToByteFunction lambda)

safe

@Nonnull
static LSrtToByteFunction safe()

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

safeSupplier

@Nonnull
static LSupplier<LSrtToByteFunction> safeSupplier()

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

safe

@Nonnull
static LSrtToByteFunction safe(@Nullable
                                         LSrtToByteFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LSrtToByteFunction compose(@Nonnull
                                             LSrtUnaryOperator before)

Allows to manipulate the domain of the function.

composed

static LSrtToByteFunction composed(@Nonnull
                                   LSrtUnaryOperator before,
                                   LSrtToByteFunction after)

srtToByteFuncCompose

@Nonnull
default <V> LToByteFunction<V> srtToByteFuncCompose(@Nonnull
                                                              LToSrtFunction<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LToByteFunction<V> composed(@Nonnull
                                       LToSrtFunction<? super V> before,
                                       LSrtToByteFunction after)

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LSrtToByteFunction thenToByte(@Nonnull
                                                LByteUnaryOperator after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LSrtUnaryOperator thenToSrt(@Nonnull
                                              LByteToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LSrtToIntFunction thenToInt(@Nonnull
                                              LByteToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LSrtToLongFunction thenToLong(@Nonnull
                                                LByteToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LSrtToFltFunction thenToFlt(@Nonnull
                                              LByteToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LSrtToDblFunction thenToDbl(@Nonnull
                                              LByteToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LSrtToCharFunction thenToChar(@Nonnull
                                                LByteToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LSrtPredicate thenToBool(@Nonnull
                                           LBytePredicate after)

Combines two functions together in a order.

produceByte

static byte produceByte(short a)

Does nothing (LSrtToByteFunction) Function

forEach

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