Package one.microstream.util

Interface Executor<EX extends Throwable>

All Known Implementing Classes:

Executor.Default

public interface Executor<EX extends Throwable>

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static class	Executor.Default<EX extends Throwable>

Method Summary

Modifier and Type	Method	Description
default <E> void	execute(E element, Consumer<? super E> logic)
default void	execute(Runnable logic)
default <E> void	executeNullHandling(E element, Consumer<? super E> logic, Runnable nullCaseLogic)
default <E> void	executeNullIgnoring(E element, Consumer<? super E> logic)
default <E,R> R	executeR(E element, Function<? super E,R> logic)
default <R> R	executeR(Supplier<? extends R> logic)
default <E,R> R	executeRNullHandling(E element, Function<? super E,R> logic, Supplier<? extends R> nullCaseLogic)
default <E,R> R	executeRNullIgnoring(E element, Function<? super E,R> logic)
void	finalize(Runnable onSuccessLogics)
boolean	handle(Throwable t)
static <EX extends Throwable> Executor<EX>	New(Class<EX> exceptionType, Consumer<? super EX> exceptionFinalizer)
static <EX extends Throwable> Executor<EX>	New(Class<EX> exceptionType, BufferingCollector<? super EX> collector)
static Executor<Exception>	New(Consumer<? super Exception> exceptionFinalizer)
static Executor<Exception>	New(BufferingCollector<? super Exception> collector)
Executor<EX>	reset()

Method Detail

reset

Executor<EX> reset()

handle

boolean handle(Throwable t)

finalize

void finalize(Runnable onSuccessLogics)

execute

default void execute(Runnable logic)

execute

default <E> void execute(E element,
                         Consumer<? super E> logic)

executeNullIgnoring

default <E> void executeNullIgnoring(E element,
                                     Consumer<? super E> logic)

executeNullHandling

default <E> void executeNullHandling(E element,
                                     Consumer<? super E> logic,
                                     Runnable nullCaseLogic)

executeR

default <R> R executeR(Supplier<? extends R> logic)

executeR

default <E,R> R executeR(E element,
                               Function<? super E,R> logic)

executeRNullIgnoring

default <E,R> R executeRNullIgnoring(E element,
                                           Function<? super E,R> logic)

executeRNullHandling

default <E,R> R executeRNullHandling(E element,
                                           Function<? super E,R> logic,
                                           Supplier<? extends R> nullCaseLogic)

New

static Executor<Exception> New(BufferingCollector<? super Exception> collector)

New

static Executor<Exception> New(Consumer<? super Exception> exceptionFinalizer)

New

static <EX extends Throwable> Executor<EX> New(Class<EX> exceptionType,
                                               BufferingCollector<? super EX> collector)

New

static <EX extends Throwable> Executor<EX> New(Class<EX> exceptionType,
                                               Consumer<? super EX> exceptionFinalizer)