eu.lunisolar.magma.func.operator.unary

Interface LByteUnaryOperator

All Superinterfaces:

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

All Known Implementing Classes:

LByteUnaryOperator.LByteUnaryOperatorSingle

@FunctionalInterface
public interface LByteUnaryOperator
extends MetaOperator, MetaInterface.NonThrowing, Codomain<aType.aByte>, Domain1<aType.aByte>

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

Type: operator

Domain (lvl: 1): byte a

Co-domain: byte

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LByteUnaryOperator.LByteUnaryOperatorSingle

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

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaOperator

isOperator

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, isPredicate, isSupplier

Methods inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface

isThrowing

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(byte a)

applyAsByteX

byte applyAsByteX(byte a)
           throws Throwable

Implement this, but call applyAsByte(byte a)

Throws:

Throwable

tupleApplyAsByte

default byte tupleApplyAsByte(LByteSingle args)

handlingApplyAsByte

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

Function call that handles exceptions according to the instructions.

handling

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

applyAsByte

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

trying

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

applyAsByte

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

trying

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

applyAsByteThen

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

tryingThen

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

nestingApplyAsByte

default byte nestingApplyAsByte(byte a)

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

shovingApplyAsByte

default byte shovingApplyAsByte(byte a)

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

handlingApplyAsByte

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

tryApplyAsByte

static byte tryApplyAsByte(byte a,
                           LByteUnaryOperator func)

tryApplyAsByte

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

tryApplyAsByte

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

tryApplyAsByteThen

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

failSafeApplyAsByte

default byte failSafeApplyAsByte(byte a,
                                 @Nonnull
                                 LByteUnaryOperator failSafe)

failSafeApplyAsByte

static byte failSafeApplyAsByte(byte a,
                                LByteUnaryOperator func,
                                @Nonnull
                                LByteUnaryOperator failSafe)

failSafe

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

nonNullApplyAsByte

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

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

fromTill

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

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

times

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

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

capture

default LByteSupplier capture(byte a)

Captures arguments but delays the evaluation.

constant

static LByteUnaryOperator constant(byte r)

Creates function that always returns the same value.

byteUnaryOp

@Nonnull
static LByteUnaryOperator byteUnaryOp(@Nonnull
                                                LByteUnaryOperator lambda)

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

recursive

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

byteUnaryOpThrowing

@Nonnull
static LByteUnaryOperator byteUnaryOpThrowing(@Nonnull
                                                        ExF<Throwable> exF)

byteUnaryOpThrowing

@Nonnull
static LByteUnaryOperator byteUnaryOpThrowing(String message,
                                                        @Nonnull
                                                        ExMF<Throwable> exF)

call

static byte call(byte a,
                 @Nonnull
                 LByteUnaryOperator lambda)

safe

@Nonnull
static LByteUnaryOperator safe()

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

safeSupplier

@Nonnull
static LSupplier<LByteUnaryOperator> safeSupplier()

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

safe

@Nonnull
static LByteUnaryOperator safe(@Nullable
                                         LByteUnaryOperator other)

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

safeSupplier

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

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

compose

@Nonnull
default LByteUnaryOperator compose(@Nonnull
                                             LByteUnaryOperator before)

Allows to manipulate the domain of the function.

composed

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

byteUnaryOpCompose

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

Allows to manipulate the domain of the function.

composed

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

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LByteUnaryOperator thenToByte(@Nonnull
                                                LByteUnaryOperator after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LByteToSrtFunction thenToSrt(@Nonnull
                                               LByteToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LByteToIntFunction thenToInt(@Nonnull
                                               LByteToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LByteToLongFunction thenToLong(@Nonnull
                                                 LByteToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LByteToFltFunction thenToFlt(@Nonnull
                                               LByteToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LByteToDblFunction thenToDbl(@Nonnull
                                               LByteToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LByteToCharFunction thenToChar(@Nonnull
                                                 LByteToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LBytePredicate thenToBool(@Nonnull
                                            LBytePredicate after)

Combines two functions together in a order.

identity

@Nonnull
static LByteUnaryOperator identity()

Returns a function that always returns its input argument.

produceByte

static byte produceByte(byte a)

Does nothing (LByteUnaryOperator) Operator

forEach

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