eu.lunisolar.magma.func.action

Interface LAction

All Superinterfaces:

Codomain<aType.aVoid>, Domain, Domain0, Formattable, MetaAction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, Runnable

All Known Implementing Classes:

LAction.LActionSingle

@FunctionalInterface
public interface LAction
extends Runnable, MetaAction, MetaInterface.NonThrowing, Codomain<aType.aVoid>, Domain0

LAction is a replacement for Runnable.

• offers default methods
• do not rise warnings about Runnable being call directly
• two versions (throwing and non-throwing) have conversion methods that mirrors each other)

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

Type: action

Domain (lvl: 0): none

Co-domain: none

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LAction.LActionSingle

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
static LAction	act(LAction lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static LAction	actThrowing(ExF<Throwable> exF)
static LAction	actThrowing(String message, ExMF<Throwable> exF)
default LAction	andThen(LAction after) Combines two LAction together in a order.
static void	call(LAction lambda)
static void	doNothing() You can use this as a reference method whenever nothing should be done.
default void	execute()
default void	execute(ExWF<RuntimeException> exF)
default void	execute(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default void	executeThen(LConsumer<Throwable> handler)
void	executeX() Implement this, but call execute()
static LAction	failSafe(LAction func, LAction failSafe)
default void	failSafeExecute(LAction failSafe)
static void	failSafeExecute(LAction func, LAction failSafe)
static void	fromTill(int min_i, int max_i, LAction func) From-To.
static void	fromTo(int min_i, int max_i, LAction func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LAction	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default void	handlingExecute(HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static void	handlingExecute(LAction func, HandlingInstructions<Throwable,RuntimeException> handling)
default void	nestingExecute() Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
static LAction	recursive(LFunction<LAction,LAction> selfLambda)
default void	run() Deprecated. Calling this method via LAction interface should be discouraged.
static LAction	safe() Safe instance.
static LAction	safe(LAction other) Safe wrapping.
static LSupplier<LAction>	safeSupplier() Safe instance supplier.
static LSupplier<LAction>	safeSupplier(LSupplier<LAction> supplier) Safe supplier.
default void	shovingExecute() Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
static void	times(int max_i, LAction func) From-To.
static void	tryExecute(LAction func)
static void	tryExecute(LAction func, ExWF<RuntimeException> exF)
static void	tryExecute(LAction func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static void	tryExecuteThen(LAction func, LConsumer<Throwable> handler)
default LAction	trying(ExWF<RuntimeException> exF)
default LAction	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LAction	tryingThen(LConsumer<Throwable> handler)
default LTuple.Void	tupleExecute(LTuple.Void args)
static LAction	wrap(Runnable other) Wraps JRE instance.

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

isAction

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.MetaFunctionalInterface

formatTo, isConsumer, isFunction, 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

run

@Deprecated
default void run()

Deprecated. Calling this method via LAction interface should be discouraged.

Default implementation for JRE method that calls exception nesting method.

Specified by:

run in interface Runnable

execute

default void execute()

executeX

void executeX()
       throws Throwable

Implement this, but call execute()

Throws:

Throwable

tupleExecute

default LTuple.Void tupleExecute(LTuple.Void args)

handlingExecute

default void handlingExecute(HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

execute

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

trying

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

execute

default void execute(@Nonnull
                     ExWF<RuntimeException> exF)

trying

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

executeThen

default void executeThen(@Nonnull
                         LConsumer<Throwable> handler)

tryingThen

default LAction tryingThen(@Nonnull
                           LConsumer<Throwable> handler)

nestingExecute

default void nestingExecute()

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

shovingExecute

default void shovingExecute()

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

handlingExecute

static void handlingExecute(LAction func,
                            HandlingInstructions<Throwable,RuntimeException> handling)

tryExecute

static void tryExecute(LAction func)

tryExecute

static void tryExecute(LAction func,
                       @Nonnull
                       ExWMF<RuntimeException> exF,
                       @Nonnull
                       String newMessage,
                       @Nullable
                       Object... messageParams)

tryExecute

static void tryExecute(LAction func,
                       @Nonnull
                       ExWF<RuntimeException> exF)

tryExecuteThen

static void tryExecuteThen(LAction func,
                           @Nonnull
                           LConsumer<Throwable> handler)

failSafeExecute

default void failSafeExecute(@Nonnull
                             LAction failSafe)

failSafeExecute

static void failSafeExecute(LAction func,
                            @Nonnull
                            LAction failSafe)

failSafe

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

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,
                   LAction func)

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     LAction func)

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

times

static void times(int max_i,
                  LAction func)

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

act

@Nonnull
static LAction act(@Nonnull
                             LAction lambda)

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

recursive

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

actThrowing

@Nonnull
static LAction actThrowing(@Nonnull
                                     ExF<Throwable> exF)

actThrowing

@Nonnull
static LAction actThrowing(String message,
                                     @Nonnull
                                     ExMF<Throwable> exF)

call

static void call(@Nonnull
                 LAction lambda)

wrap

@Nonnull
static LAction wrap(Runnable other)

Wraps JRE instance.

safe

@Nonnull
static LAction safe()

Safe instance.

safeSupplier

@Nonnull
static LSupplier<LAction> safeSupplier()

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

safe

@Nonnull
static LAction safe(@Nullable
                              LAction other)

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

safeSupplier

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

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

andThen

@Nonnull
default LAction andThen(@Nonnull
                                  LAction after)

Combines two LAction together in a order.

doNothing

static void doNothing()

You can use this as a reference method whenever nothing should be done.