eu.lunisolar.magma.func.function.conversion

Interface LFltToByteFunction

All Superinterfaces:

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

All Known Implementing Classes:

LFltToByteFunction.LFltToByteFunctionSingle

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

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

Type: function

Domain (lvl: 1): float a

Co-domain: byte

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LFltToByteFunction.LFltToByteFunctionSingle

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

applyAsByteX

byte applyAsByteX(float a)
           throws Throwable

Implement this, but call applyAsByte(float a)

Throws:

Throwable

tupleApplyAsByte

default byte tupleApplyAsByte(LFltSingle args)

handlingApplyAsByte

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

Function call that handles exceptions according to the instructions.

handling

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

applyAsByte

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

trying

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

applyAsByte

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

trying

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

applyAsByteThen

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

tryingThen

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

nestingApplyAsByte

default byte nestingApplyAsByte(float a)

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

shovingApplyAsByte

default byte shovingApplyAsByte(float a)

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

handlingApplyAsByte

static byte handlingApplyAsByte(float a,
                                LFltToByteFunction func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsByte

static byte tryApplyAsByte(float a,
                           LFltToByteFunction func)

tryApplyAsByte

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

tryApplyAsByte

static byte tryApplyAsByte(float a,
                           LFltToByteFunction func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsByteThen

static byte tryApplyAsByteThen(float a,
                               LFltToByteFunction func,
                               @Nonnull
                               LToByteFunction<Throwable> handler)

failSafeApplyAsByte

default byte failSafeApplyAsByte(float a,
                                 @Nonnull
                                 LFltToByteFunction failSafe)

failSafeApplyAsByte

static byte failSafeApplyAsByte(float a,
                                LFltToByteFunction func,
                                @Nonnull
                                LFltToByteFunction failSafe)

failSafe

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

nonNullApplyAsByte

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

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     float a,
                     LFltToByteFunction func)

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

times

static void times(int max_i,
                  float a,
                  LFltToByteFunction func)

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

capture

default LByteSupplier capture(float a)

Captures arguments but delays the evaluation.

constant

static LFltToByteFunction constant(byte r)

Creates function that always returns the same value.

fltToByteFunc

@Nonnull
static LFltToByteFunction fltToByteFunc(@Nonnull
                                                  LFltToByteFunction lambda)

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

recursive

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

fltToByteFuncThrowing

@Nonnull
static LFltToByteFunction fltToByteFuncThrowing(@Nonnull
                                                          ExF<Throwable> exF)

fltToByteFuncThrowing

@Nonnull
static LFltToByteFunction fltToByteFuncThrowing(String message,
                                                          @Nonnull
                                                          ExMF<Throwable> exF)

call

static byte call(float a,
                 @Nonnull
                 LFltToByteFunction lambda)

safe

@Nonnull
static LFltToByteFunction safe()

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

safeSupplier

@Nonnull
static LSupplier<LFltToByteFunction> safeSupplier()

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

safe

@Nonnull
static LFltToByteFunction safe(@Nullable
                                         LFltToByteFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LFltToByteFunction compose(@Nonnull
                                             LFltUnaryOperator before)

Allows to manipulate the domain of the function.

composed

static LFltToByteFunction composed(@Nonnull
                                   LFltUnaryOperator before,
                                   LFltToByteFunction after)

fltToByteFuncCompose

@Nonnull
default <V> LToByteFunction<V> fltToByteFuncCompose(@Nonnull
                                                              LToFltFunction<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LToByteFunction<V> composed(@Nonnull
                                       LToFltFunction<? super V> before,
                                       LFltToByteFunction after)

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LFltToByteFunction thenToByte(@Nonnull
                                                LByteUnaryOperator after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LFltToSrtFunction thenToSrt(@Nonnull
                                              LByteToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LFltToIntFunction thenToInt(@Nonnull
                                              LByteToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LFltToLongFunction thenToLong(@Nonnull
                                                LByteToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LFltUnaryOperator thenToFlt(@Nonnull
                                              LByteToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LFltToDblFunction thenToDbl(@Nonnull
                                              LByteToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LFltToCharFunction thenToChar(@Nonnull
                                                LByteToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LFltPredicate thenToBool(@Nonnull
                                           LBytePredicate after)

Combines two functions together in a order.

produceByte

static byte produceByte(float a)

Does nothing (LFltToByteFunction) Function

forEach

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