LCharToByteFunction (magma-func 2.0.0 API)

All Superinterfaces:

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

All Known Implementing Classes:

LCharToByteFunction.LCharToByteFunctionSingle
```
@FunctionalInterface
public interface LCharToByteFunction
extends MetaFunction, MetaInterface.NonThrowing, Codomain<aType.aByte>, Domain1<aType.aChar>
```
Non-throwing functional interface (lambda) LCharToByteFunction for Java 8.
Type: function
Domain (lvl: 1): char a
Co-domain: byte

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class LCharToByteFunction.LCharToByteFunctionSingle
- Nested classes/interfaces inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface
  MetaInterface.NonThrowing, MetaInterface.Throwing<X>

Nested Classes
Modifier and Type	Interface and Description
`static class`	`LCharToByteFunction.LCharToByteFunctionSingle`

Field Summary

Fields
Modifier and Type Field and Description

static String DESCRIPTION

Fields
Modifier and Type	Field and Description
`static String`	`DESCRIPTION`

Method Summary

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

applyAsByteX
```
byte applyAsByteX(char a)
           throws Throwable
```
Implement this, but call applyAsByte(char a)

Throws:

Throwable

tupleApplyAsByte

default byte tupleApplyAsByte(LCharSingle args)

handlingApplyAsByte

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

Function call that handles exceptions according to the instructions.

handling

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

applyAsByte

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

trying

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

applyAsByte

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

trying

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

applyAsByteThen

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

tryingThen

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

nestingApplyAsByte
```
default byte nestingApplyAsByte(char a)
```
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

shovingApplyAsByte
```
default byte shovingApplyAsByte(char a)
```
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.

handlingApplyAsByte

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

tryApplyAsByte

static byte tryApplyAsByte(char a,
                           LCharToByteFunction func)

tryApplyAsByte

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

tryApplyAsByte

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

tryApplyAsByteThen

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

failSafeApplyAsByte

default byte failSafeApplyAsByte(char a,
                                 @Nonnull
                                 LCharToByteFunction failSafe)

failSafeApplyAsByte

static byte failSafeApplyAsByte(char a,
                                LCharToByteFunction func,
                                @Nonnull
                                LCharToByteFunction failSafe)

failSafe

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

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

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

fromTill

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

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

times

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

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

capture
```
default LByteSupplier capture(char a)
```
Captures arguments but delays the evaluation.

constant
```
static LCharToByteFunction constant(byte r)
```
Creates function that always returns the same value.

charToByteFunc

@Nonnull
static LCharToByteFunction charToByteFunc(@Nonnull
                                                    LCharToByteFunction lambda)

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

recursive

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

charToByteFuncThrowing

@Nonnull
static LCharToByteFunction charToByteFuncThrowing(@Nonnull
                                                            ExF<Throwable> exF)

charToByteFuncThrowing

@Nonnull
static LCharToByteFunction charToByteFuncThrowing(String message,
                                                            @Nonnull
                                                            ExMF<Throwable> exF)

call

static byte call(char a,
                 @Nonnull
                 LCharToByteFunction lambda)

safe
```
@Nonnull
static LCharToByteFunction safe()
```
Safe instance. That always returns the same value (as produceByte).

safeSupplier
```
@Nonnull
static LSupplier<LCharToByteFunction> safeSupplier()
```
Safe instance supplier. Returns supplier of safe() instance.

safe

@Nonnull
static LCharToByteFunction safe(@Nullable
                                          LCharToByteFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LCharToByteFunction compose(@Nonnull
                                              LCharUnaryOperator before)

Allows to manipulate the domain of the function.

composed

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

charToByteFuncCompose

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

Allows to manipulate the domain of the function.