eu.lunisolar.magma.func.operator.unary

Interface LIntUnaryOperator

All Superinterfaces:

Codomain<aType.aInt>, Domain, Domain1<aType.aInt>, Formattable, java.util.function.IntUnaryOperator, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaOperator

All Known Implementing Classes:

LIntUnaryOperator.LIntUnaryOperatorSingle

@FunctionalInterface
public interface LIntUnaryOperator
extends java.util.function.IntUnaryOperator, MetaOperator, MetaInterface.NonThrowing, Codomain<aType.aInt>, Domain1<aType.aInt>

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

Type: operator

Domain (lvl: 1): int a

Co-domain: int

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LIntUnaryOperator.LIntUnaryOperatorSingle

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(int a)
default int	applyAsInt(int a, ExWF<RuntimeException> exF)
default int	applyAsInt(int a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default int	applyAsIntThen(int a, LToIntFunction<Throwable> handler)
int	applyAsIntX(int a) Implement this, but call applyAsInt(int a)
static int	call(int a, LIntUnaryOperator lambda)
default LIntSupplier	capture(int a) Captures arguments but delays the evaluation.
default LIntUnaryOperator	compose(LIntUnaryOperator before) Allows to manipulate the domain of the function.
static LIntUnaryOperator	composed(LIntUnaryOperator before, LIntUnaryOperator after)
static <V> LToIntFunction<V>	composed(LToIntFunction<? super V> before, LIntUnaryOperator after)
static LIntUnaryOperator	constant(int r) Creates function that always returns the same value.
static LIntUnaryOperator	failSafe(LIntUnaryOperator func, LIntUnaryOperator failSafe)
default int	failSafeApplyAsInt(int a, LIntUnaryOperator failSafe)
static int	failSafeApplyAsInt(int a, LIntUnaryOperator func, LIntUnaryOperator failSafe)
default <C0> void	forEach(IndexedRead<C0,aType.aInt> 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_a, int max_a, LIntUnaryOperator func) From-To.
static void	fromTo(int min_a, int max_a, LIntUnaryOperator func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LIntUnaryOperator	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default int	handlingApplyAsInt(int a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static int	handlingApplyAsInt(int a, LIntUnaryOperator func, HandlingInstructions<Throwable,RuntimeException> handling)
static LIntUnaryOperator	identity() Returns a function that always returns its input argument.
static LIntUnaryOperator	intUnaryOp(LIntUnaryOperator 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>	intUnaryOpCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
static LIntUnaryOperator	intUnaryOpThrowing(ExF<Throwable> exF)
static LIntUnaryOperator	intUnaryOpThrowing(String message, ExMF<Throwable> exF)
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aInt> sa, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default int	nestingApplyAsInt(int a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default int	nonNullApplyAsInt(int a) Just to mirror the method: Ensures the result is not null
static int	produceInt(int a) Does nothing (LIntUnaryOperator) Operator
static LIntUnaryOperator	recursive(LFunction<LIntUnaryOperator,LIntUnaryOperator> selfLambda)
static LIntUnaryOperator	safe() Safe instance.
static LIntUnaryOperator	safe(LIntUnaryOperator other) Safe wrapping.
static LSupplier<LIntUnaryOperator>	safeSupplier() Safe instance supplier.
static LSupplier<LIntUnaryOperator>	safeSupplier(LSupplier<LIntUnaryOperator> supplier) Safe supplier.
default int	shovingApplyAsInt(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(LIntFunction<? extends V> after) Combines two functions together in a order.
default LIntPredicate	thenToBool(LIntPredicate after) Combines two functions together in a order.
default LIntToByteFunction	thenToByte(LIntToByteFunction after) Combines two functions together in a order.
default LIntToCharFunction	thenToChar(LIntToCharFunction after) Combines two functions together in a order.
default LIntToDblFunction	thenToDbl(LIntToDblFunction after) Combines two functions together in a order.
default LIntToFltFunction	thenToFlt(LIntToFltFunction after) Combines two functions together in a order.
default LIntUnaryOperator	thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LIntToLongFunction	thenToLong(LIntToLongFunction after) Combines two functions together in a order.
default LIntToSrtFunction	thenToSrt(LIntToSrtFunction after) Combines two functions together in a order.
static void	times(int max_a, LIntUnaryOperator func) From-To.
static int	tryApplyAsInt(int a, LIntUnaryOperator func)
static int	tryApplyAsInt(int a, LIntUnaryOperator func, ExWF<RuntimeException> exF)
static int	tryApplyAsInt(int a, LIntUnaryOperator func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static int	tryApplyAsIntThen(int a, LIntUnaryOperator func, LToIntFunction<Throwable> handler)
default LIntUnaryOperator	trying(ExWF<RuntimeException> exF)
default LIntUnaryOperator	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LIntUnaryOperator	tryingThen(LToIntFunction<Throwable> handler)
default int	tupleApplyAsInt(LIntSingle args)
static LIntUnaryOperator	wrap(java.util.function.IntUnaryOperator other) Wraps JRE instance.

Methods inherited from interface java.util.function.IntUnaryOperator

andThen, compose

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

applyAsInt

default int applyAsInt(int a)

Specified by:

applyAsInt in interface java.util.function.IntUnaryOperator

applyAsIntX

int applyAsIntX(int a)
         throws Throwable

Implement this, but call applyAsInt(int a)

Throws:

Throwable

tupleApplyAsInt

default int tupleApplyAsInt(LIntSingle args)

handlingApplyAsInt

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

Function call that handles exceptions according to the instructions.

handling

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

applyAsInt

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

trying

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

applyAsInt

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

trying

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

applyAsIntThen

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

tryingThen

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

nestingApplyAsInt

default int nestingApplyAsInt(int a)

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

shovingApplyAsInt

default int shovingApplyAsInt(int a)

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

handlingApplyAsInt

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

tryApplyAsInt

static int tryApplyAsInt(int a,
                         LIntUnaryOperator func)

tryApplyAsInt

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

tryApplyAsInt

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

tryApplyAsIntThen

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

failSafeApplyAsInt

default int failSafeApplyAsInt(int a,
                               @Nonnull
                               LIntUnaryOperator failSafe)

failSafeApplyAsInt

static int failSafeApplyAsInt(int a,
                              LIntUnaryOperator func,
                              @Nonnull
                              LIntUnaryOperator failSafe)

failSafe

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

nonNullApplyAsInt

default int nonNullApplyAsInt(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,
                   LIntUnaryOperator func)

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

fromTill

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

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

times

static void times(int max_a,
                  LIntUnaryOperator func)

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

capture

default LIntSupplier capture(int a)

Captures arguments but delays the evaluation.

constant

static LIntUnaryOperator constant(int r)

Creates function that always returns the same value.

intUnaryOp

@Nonnull
static LIntUnaryOperator intUnaryOp(@Nonnull
                                              LIntUnaryOperator lambda)

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

recursive

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

intUnaryOpThrowing

@Nonnull
static LIntUnaryOperator intUnaryOpThrowing(@Nonnull
                                                      ExF<Throwable> exF)

intUnaryOpThrowing

@Nonnull
static LIntUnaryOperator intUnaryOpThrowing(String message,
                                                      @Nonnull
                                                      ExMF<Throwable> exF)

call

static int call(int a,
                @Nonnull
                LIntUnaryOperator lambda)

wrap

@Nonnull
static LIntUnaryOperator wrap(java.util.function.IntUnaryOperator other)

Wraps JRE instance.

safe

@Nonnull
static LIntUnaryOperator safe()

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

safeSupplier

@Nonnull
static LSupplier<LIntUnaryOperator> safeSupplier()

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

safe

@Nonnull
static LIntUnaryOperator safe(@Nullable
                                        LIntUnaryOperator other)

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

safeSupplier

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

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

compose

@Nonnull
default LIntUnaryOperator compose(@Nonnull
                                            LIntUnaryOperator before)

Allows to manipulate the domain of the function.

composed

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

intUnaryOpCompose

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

Allows to manipulate the domain of the function.

composed

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

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LIntToByteFunction thenToByte(@Nonnull
                                                LIntToByteFunction after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LIntToSrtFunction thenToSrt(@Nonnull
                                              LIntToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LIntUnaryOperator thenToInt(@Nonnull
                                              LIntUnaryOperator after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LIntToLongFunction thenToLong(@Nonnull
                                                LIntToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LIntToFltFunction thenToFlt(@Nonnull
                                              LIntToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LIntToDblFunction thenToDbl(@Nonnull
                                              LIntToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LIntToCharFunction thenToChar(@Nonnull
                                                LIntToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LIntPredicate thenToBool(@Nonnull
                                           LIntPredicate after)

Combines two functions together in a order.

identity

@Nonnull
static LIntUnaryOperator identity()

Returns a function that always returns its input argument.

Specified by:

identity in interface java.util.function.IntUnaryOperator

produceInt

static int produceInt(int a)

Does nothing (LIntUnaryOperator) Operator

forEach

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