eu.lunisolar.magma.func.operator.unary

Interface LCharUnaryOperator

All Superinterfaces:

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

All Known Implementing Classes:

LCharUnaryOperator.LCharUnaryOperatorSingle

@FunctionalInterface
public interface LCharUnaryOperator
extends MetaOperator, MetaInterface.NonThrowing, Codomain<aType.aChar>, Domain1<aType.aChar>

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

Type: operator

Domain (lvl: 1): char a

Co-domain: char

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LCharUnaryOperator.LCharUnaryOperatorSingle

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 char	applyAsChar(char a)
default char	applyAsChar(char a, ExWF<RuntimeException> exF)
default char	applyAsChar(char a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default char	applyAsCharThen(char a, LToCharFunction<Throwable> handler)
char	applyAsCharX(char a) Implement this, but call applyAsChar(char a)
static char	call(char a, LCharUnaryOperator lambda)
default LCharSupplier	capture(char a) Captures arguments but delays the evaluation.
static LCharUnaryOperator	charUnaryOp(LCharUnaryOperator lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V> LToCharFunction<V>	charUnaryOpCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
static LCharUnaryOperator	charUnaryOpThrowing(ExF<Throwable> exF)
static LCharUnaryOperator	charUnaryOpThrowing(String message, ExMF<Throwable> exF)
default LCharUnaryOperator	compose(LCharUnaryOperator before) Allows to manipulate the domain of the function.
static LCharUnaryOperator	composed(LCharUnaryOperator before, LCharUnaryOperator after)
static <V> LToCharFunction<V>	composed(LToCharFunction<? super V> before, LCharUnaryOperator after)
static LCharUnaryOperator	constant(char r) Creates function that always returns the same value.
static LCharUnaryOperator	failSafe(LCharUnaryOperator func, LCharUnaryOperator failSafe)
default char	failSafeApplyAsChar(char a, LCharUnaryOperator failSafe)
static char	failSafeApplyAsChar(char a, LCharUnaryOperator func, LCharUnaryOperator failSafe)
default <C0> void	forEach(IndexedRead<C0,aType.aChar> ia, C0 source, LCharConsumer 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, char a, LCharUnaryOperator func) From-To.
static void	fromTo(int min_i, int max_i, char a, LCharUnaryOperator func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LCharUnaryOperator	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default char	handlingApplyAsChar(char a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static char	handlingApplyAsChar(char a, LCharUnaryOperator func, HandlingInstructions<Throwable,RuntimeException> handling)
static LCharUnaryOperator	identity() Returns a function that always returns its input argument.
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aChar> sa, C0 source, LCharConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default char	nestingApplyAsChar(char a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default char	nonNullApplyAsChar(char a) Just to mirror the method: Ensures the result is not null
static char	produceChar(char a) Does nothing (LCharUnaryOperator) Operator
static LCharUnaryOperator	recursive(LFunction<LCharUnaryOperator,LCharUnaryOperator> selfLambda)
static LCharUnaryOperator	safe() Safe instance.
static LCharUnaryOperator	safe(LCharUnaryOperator other) Safe wrapping.
static LSupplier<LCharUnaryOperator>	safeSupplier() Safe instance supplier.
static LSupplier<LCharUnaryOperator>	safeSupplier(LSupplier<LCharUnaryOperator> supplier) Safe supplier.
default char	shovingApplyAsChar(char a) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default <V> LCharFunction<V>	then(LCharFunction<? extends V> after) Combines two functions together in a order.
default LCharPredicate	thenToBool(LCharPredicate after) Combines two functions together in a order.
default LCharToByteFunction	thenToByte(LCharToByteFunction after) Combines two functions together in a order.
default LCharUnaryOperator	thenToChar(LCharUnaryOperator after) Combines two functions together in a order.
default LCharToDblFunction	thenToDbl(LCharToDblFunction after) Combines two functions together in a order.
default LCharToFltFunction	thenToFlt(LCharToFltFunction after) Combines two functions together in a order.
default LCharToIntFunction	thenToInt(LCharToIntFunction after) Combines two functions together in a order.
default LCharToLongFunction	thenToLong(LCharToLongFunction after) Combines two functions together in a order.
default LCharToSrtFunction	thenToSrt(LCharToSrtFunction after) Combines two functions together in a order.
static void	times(int max_i, char a, LCharUnaryOperator func) From-To.
static char	tryApplyAsChar(char a, LCharUnaryOperator func)
static char	tryApplyAsChar(char a, LCharUnaryOperator func, ExWF<RuntimeException> exF)
static char	tryApplyAsChar(char a, LCharUnaryOperator func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static char	tryApplyAsCharThen(char a, LCharUnaryOperator func, LToCharFunction<Throwable> handler)
default LCharUnaryOperator	trying(ExWF<RuntimeException> exF)
default LCharUnaryOperator	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LCharUnaryOperator	tryingThen(LToCharFunction<Throwable> handler)
default char	tupleApplyAsChar(LCharSingle 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

applyAsChar

default char applyAsChar(char a)

applyAsCharX

char applyAsCharX(char a)
           throws Throwable

Implement this, but call applyAsChar(char a)

Throws:

Throwable

tupleApplyAsChar

default char tupleApplyAsChar(LCharSingle args)

handlingApplyAsChar

default char handlingApplyAsChar(char a,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

applyAsChar

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

trying

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

applyAsChar

default char applyAsChar(char a,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

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

applyAsCharThen

default char applyAsCharThen(char a,
                             @Nonnull
                             LToCharFunction<Throwable> handler)

tryingThen

default LCharUnaryOperator tryingThen(@Nonnull
                                      LToCharFunction<Throwable> handler)

nestingApplyAsChar

default char nestingApplyAsChar(char a)

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

shovingApplyAsChar

default char shovingApplyAsChar(char a)

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

handlingApplyAsChar

static char handlingApplyAsChar(char a,
                                LCharUnaryOperator func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsChar

static char tryApplyAsChar(char a,
                           LCharUnaryOperator func)

tryApplyAsChar

static char tryApplyAsChar(char a,
                           LCharUnaryOperator func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryApplyAsChar

static char tryApplyAsChar(char a,
                           LCharUnaryOperator func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsCharThen

static char tryApplyAsCharThen(char a,
                               LCharUnaryOperator func,
                               @Nonnull
                               LToCharFunction<Throwable> handler)

failSafeApplyAsChar

default char failSafeApplyAsChar(char a,
                                 @Nonnull
                                 LCharUnaryOperator failSafe)

failSafeApplyAsChar

static char failSafeApplyAsChar(char a,
                                LCharUnaryOperator func,
                                @Nonnull
                                LCharUnaryOperator failSafe)

failSafe

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

nonNullApplyAsChar

default char nonNullApplyAsChar(char 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,
                   char a,
                   LCharUnaryOperator func)

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     char a,
                     LCharUnaryOperator func)

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

times

static void times(int max_i,
                  char a,
                  LCharUnaryOperator func)

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

capture

default LCharSupplier capture(char a)

Captures arguments but delays the evaluation.

constant

static LCharUnaryOperator constant(char r)

Creates function that always returns the same value.

charUnaryOp

@Nonnull
static LCharUnaryOperator charUnaryOp(@Nonnull
                                                LCharUnaryOperator lambda)

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

recursive

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

charUnaryOpThrowing

@Nonnull
static LCharUnaryOperator charUnaryOpThrowing(@Nonnull
                                                        ExF<Throwable> exF)

charUnaryOpThrowing

@Nonnull
static LCharUnaryOperator charUnaryOpThrowing(String message,
                                                        @Nonnull
                                                        ExMF<Throwable> exF)

call

static char call(char a,
                 @Nonnull
                 LCharUnaryOperator lambda)

safe

@Nonnull
static LCharUnaryOperator safe()

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

safeSupplier

@Nonnull
static LSupplier<LCharUnaryOperator> safeSupplier()

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

safe

@Nonnull
static LCharUnaryOperator safe(@Nullable
                                         LCharUnaryOperator other)

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

safeSupplier

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

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

compose

@Nonnull
default LCharUnaryOperator compose(@Nonnull
                                             LCharUnaryOperator before)

Allows to manipulate the domain of the function.

composed

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

charUnaryOpCompose

@Nonnull
default <V> LToCharFunction<V> charUnaryOpCompose(@Nonnull
                                                            LToCharFunction<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LToCharFunction<V> composed(@Nonnull
                                       LToCharFunction<? super V> before,
                                       LCharUnaryOperator after)

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LCharToByteFunction thenToByte(@Nonnull
                                                 LCharToByteFunction after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LCharToSrtFunction thenToSrt(@Nonnull
                                               LCharToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LCharToIntFunction thenToInt(@Nonnull
                                               LCharToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LCharToLongFunction thenToLong(@Nonnull
                                                 LCharToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LCharToFltFunction thenToFlt(@Nonnull
                                               LCharToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LCharToDblFunction thenToDbl(@Nonnull
                                               LCharToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LCharUnaryOperator thenToChar(@Nonnull
                                                LCharUnaryOperator after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LCharPredicate thenToBool(@Nonnull
                                            LCharPredicate after)

Combines two functions together in a order.

identity

@Nonnull
static LCharUnaryOperator identity()

Returns a function that always returns its input argument.

produceChar

static char produceChar(char a)

Does nothing (LCharUnaryOperator) Operator

forEach

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