eu.lunisolar.magma.func.operator.unary

Interface LLongUnaryOperator

All Superinterfaces:

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

All Known Implementing Classes:

LLongUnaryOperator.LLongUnaryOperatorSingle

@FunctionalInterface
public interface LLongUnaryOperator
extends java.util.function.LongUnaryOperator, MetaOperator, MetaInterface.NonThrowing, Codomain<aType.aLong>, Domain1<aType.aLong>

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

Type: operator

Domain (lvl: 1): long a

Co-domain: long

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LLongUnaryOperator.LLongUnaryOperatorSingle

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 long	applyAsLong(long a)
default long	applyAsLong(long a, ExWF<RuntimeException> exF)
default long	applyAsLong(long a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default long	applyAsLongThen(long a, LToLongFunction<Throwable> handler)
long	applyAsLongX(long a) Implement this, but call applyAsLong(long a)
static long	call(long a, LLongUnaryOperator lambda)
default LLongSupplier	capture(long a) Captures arguments but delays the evaluation.
default LLongUnaryOperator	compose(LLongUnaryOperator before) Allows to manipulate the domain of the function.
static LLongUnaryOperator	composed(LLongUnaryOperator before, LLongUnaryOperator after)
static <V> LToLongFunction<V>	composed(LToLongFunction<? super V> before, LLongUnaryOperator after)
static LLongUnaryOperator	constant(long r) Creates function that always returns the same value.
static LLongUnaryOperator	failSafe(LLongUnaryOperator func, LLongUnaryOperator failSafe)
default long	failSafeApplyAsLong(long a, LLongUnaryOperator failSafe)
static long	failSafeApplyAsLong(long a, LLongUnaryOperator func, LLongUnaryOperator failSafe)
default <C0> void	forEach(IndexedRead<C0,aType.aLong> ia, C0 source, LLongConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static void	fromTill(long min_a, long max_a, LLongUnaryOperator func) From-To.
static void	fromTo(long min_a, long max_a, LLongUnaryOperator func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LLongUnaryOperator	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default long	handlingApplyAsLong(long a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static long	handlingApplyAsLong(long a, LLongUnaryOperator func, HandlingInstructions<Throwable,RuntimeException> handling)
static LLongUnaryOperator	identity() Returns a function that always returns its input argument.
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aLong> sa, C0 source, LLongConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static LLongUnaryOperator	longUnaryOp(LLongUnaryOperator lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V> LToLongFunction<V>	longUnaryOpCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
static LLongUnaryOperator	longUnaryOpThrowing(ExF<Throwable> exF)
static LLongUnaryOperator	longUnaryOpThrowing(String message, ExMF<Throwable> exF)
default long	nestingApplyAsLong(long a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default long	nonNullApplyAsLong(long a) Just to mirror the method: Ensures the result is not null
static long	produceLong(long a) Does nothing (LLongUnaryOperator) Operator
static LLongUnaryOperator	recursive(LFunction<LLongUnaryOperator,LLongUnaryOperator> selfLambda)
static LLongUnaryOperator	safe() Safe instance.
static LLongUnaryOperator	safe(LLongUnaryOperator other) Safe wrapping.
static LSupplier<LLongUnaryOperator>	safeSupplier() Safe instance supplier.
static LSupplier<LLongUnaryOperator>	safeSupplier(LSupplier<LLongUnaryOperator> supplier) Safe supplier.
default long	shovingApplyAsLong(long a) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default <V> LLongFunction<V>	then(LLongFunction<? extends V> after) Combines two functions together in a order.
default LLongPredicate	thenToBool(LLongPredicate after) Combines two functions together in a order.
default LLongToByteFunction	thenToByte(LLongToByteFunction after) Combines two functions together in a order.
default LLongToCharFunction	thenToChar(LLongToCharFunction after) Combines two functions together in a order.
default LLongToDblFunction	thenToDbl(LLongToDblFunction after) Combines two functions together in a order.
default LLongToFltFunction	thenToFlt(LLongToFltFunction after) Combines two functions together in a order.
default LLongToIntFunction	thenToInt(LLongToIntFunction after) Combines two functions together in a order.
default LLongUnaryOperator	thenToLong(LLongUnaryOperator after) Combines two functions together in a order.
default LLongToSrtFunction	thenToSrt(LLongToSrtFunction after) Combines two functions together in a order.
static void	times(long max_a, LLongUnaryOperator func) From-To.
static long	tryApplyAsLong(long a, LLongUnaryOperator func)
static long	tryApplyAsLong(long a, LLongUnaryOperator func, ExWF<RuntimeException> exF)
static long	tryApplyAsLong(long a, LLongUnaryOperator func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static long	tryApplyAsLongThen(long a, LLongUnaryOperator func, LToLongFunction<Throwable> handler)
default LLongUnaryOperator	trying(ExWF<RuntimeException> exF)
default LLongUnaryOperator	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LLongUnaryOperator	tryingThen(LToLongFunction<Throwable> handler)
default long	tupleApplyAsLong(LLongSingle args)
static LLongUnaryOperator	wrap(java.util.function.LongUnaryOperator other) Wraps JRE instance.

Methods inherited from interface java.util.function.LongUnaryOperator

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

applyAsLong

default long applyAsLong(long a)

Specified by:

applyAsLong in interface java.util.function.LongUnaryOperator

applyAsLongX

long applyAsLongX(long a)
           throws Throwable

Implement this, but call applyAsLong(long a)

Throws:

Throwable

tupleApplyAsLong

default long tupleApplyAsLong(LLongSingle args)

handlingApplyAsLong

default long handlingApplyAsLong(long a,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

applyAsLong

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

trying

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

applyAsLong

default long applyAsLong(long a,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

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

applyAsLongThen

default long applyAsLongThen(long a,
                             @Nonnull
                             LToLongFunction<Throwable> handler)

tryingThen

default LLongUnaryOperator tryingThen(@Nonnull
                                      LToLongFunction<Throwable> handler)

nestingApplyAsLong

default long nestingApplyAsLong(long a)

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

shovingApplyAsLong

default long shovingApplyAsLong(long a)

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

handlingApplyAsLong

static long handlingApplyAsLong(long a,
                                LLongUnaryOperator func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsLong

static long tryApplyAsLong(long a,
                           LLongUnaryOperator func)

tryApplyAsLong

static long tryApplyAsLong(long a,
                           LLongUnaryOperator func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryApplyAsLong

static long tryApplyAsLong(long a,
                           LLongUnaryOperator func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsLongThen

static long tryApplyAsLongThen(long a,
                               LLongUnaryOperator func,
                               @Nonnull
                               LToLongFunction<Throwable> handler)

failSafeApplyAsLong

default long failSafeApplyAsLong(long a,
                                 @Nonnull
                                 LLongUnaryOperator failSafe)

failSafeApplyAsLong

static long failSafeApplyAsLong(long a,
                                LLongUnaryOperator func,
                                @Nonnull
                                LLongUnaryOperator failSafe)

failSafe

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

nonNullApplyAsLong

default long nonNullApplyAsLong(long 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(long min_a,
                   long max_a,
                   LLongUnaryOperator func)

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

fromTill

static void fromTill(long min_a,
                     long max_a,
                     LLongUnaryOperator func)

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

times

static void times(long max_a,
                  LLongUnaryOperator func)

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

capture

default LLongSupplier capture(long a)

Captures arguments but delays the evaluation.

constant

static LLongUnaryOperator constant(long r)

Creates function that always returns the same value.

longUnaryOp

@Nonnull
static LLongUnaryOperator longUnaryOp(@Nonnull
                                                LLongUnaryOperator lambda)

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

recursive

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

longUnaryOpThrowing

@Nonnull
static LLongUnaryOperator longUnaryOpThrowing(@Nonnull
                                                        ExF<Throwable> exF)

longUnaryOpThrowing

@Nonnull
static LLongUnaryOperator longUnaryOpThrowing(String message,
                                                        @Nonnull
                                                        ExMF<Throwable> exF)

call

static long call(long a,
                 @Nonnull
                 LLongUnaryOperator lambda)

wrap

@Nonnull
static LLongUnaryOperator wrap(java.util.function.LongUnaryOperator other)

Wraps JRE instance.

safe

@Nonnull
static LLongUnaryOperator safe()

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

safeSupplier

@Nonnull
static LSupplier<LLongUnaryOperator> safeSupplier()

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

safe

@Nonnull
static LLongUnaryOperator safe(@Nullable
                                         LLongUnaryOperator other)

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

safeSupplier

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

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

compose

@Nonnull
default LLongUnaryOperator compose(@Nonnull
                                             LLongUnaryOperator before)

Allows to manipulate the domain of the function.

composed

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

longUnaryOpCompose

@Nonnull
default <V> LToLongFunction<V> longUnaryOpCompose(@Nonnull
                                                            LToLongFunction<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LToLongFunction<V> composed(@Nonnull
                                       LToLongFunction<? super V> before,
                                       LLongUnaryOperator after)

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LLongToByteFunction thenToByte(@Nonnull
                                                 LLongToByteFunction after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LLongToSrtFunction thenToSrt(@Nonnull
                                               LLongToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LLongToIntFunction thenToInt(@Nonnull
                                               LLongToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LLongUnaryOperator thenToLong(@Nonnull
                                                LLongUnaryOperator after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LLongToFltFunction thenToFlt(@Nonnull
                                               LLongToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LLongToDblFunction thenToDbl(@Nonnull
                                               LLongToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LLongToCharFunction thenToChar(@Nonnull
                                                 LLongToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LLongPredicate thenToBool(@Nonnull
                                            LLongPredicate after)

Combines two functions together in a order.

identity

@Nonnull
static LLongUnaryOperator identity()

Returns a function that always returns its input argument.

Specified by:

identity in interface java.util.function.LongUnaryOperator

produceLong

static long produceLong(long a)

Does nothing (LLongUnaryOperator) Operator

forEach

default <C0> void forEach(IndexedRead<C0,aType.aLong> ia,
                          C0 source,
                          LLongConsumer 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.aLong> sa,
                             C0 source,
                             LLongConsumer 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.