eu.lunisolar.magma.func.consumer.primitives

Interface LDblConsumer

All Superinterfaces:

Codomain<aType.aVoid>, Domain, Domain1<aType.aDouble>, java.util.function.DoubleConsumer, Formattable, MetaConsumer, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>

All Known Implementing Classes:

LDblConsumer.LDblConsumerSingle

@FunctionalInterface
public interface LDblConsumer
extends java.util.function.DoubleConsumer, MetaConsumer, MetaInterface.NonThrowing, Codomain<aType.aVoid>, Domain1<aType.aDouble>

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

Type: consumer

Domain (lvl: 1): double a

Co-domain: none

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LDblConsumer.LDblConsumerSingle

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 void	accept(double a)
default void	accept(double a, ExWF<RuntimeException> exF)
default void	accept(double a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default void	acceptThen(double a, LConsumer<Throwable> handler)
void	acceptX(double a) Implement this, but call accept(double a)
default LDblConsumer	andThen(LDblConsumer after) Combines two LDblConsumer together in a order.
static void	call(double a, LDblConsumer lambda)
default LAction	capture(double a) Captures arguments but delays the evaluation.
default LDblConsumer	compose(LDblUnaryOperator before) Allows to manipulate the domain of the function.
static LDblConsumer	composed(LDblUnaryOperator before, LDblConsumer after)
static <V> LConsumer<V>	composed(LToDblFunction<? super V> before, LDblConsumer after)
static LDblConsumer	dblCons(LDblConsumer lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V> LConsumer<V>	dblConsCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
static LDblConsumer	dblConsThrowing(ExF<Throwable> exF)
static LDblConsumer	dblConsThrowing(String message, ExMF<Throwable> exF)
static void	doNothing(double a) Does nothing (LDblConsumer)
static LDblConsumer	failSafe(LDblConsumer func, LDblConsumer failSafe)
default void	failSafeAccept(double a, LDblConsumer failSafe)
static void	failSafeAccept(double a, LDblConsumer func, LDblConsumer failSafe)
static <C0> int	forEach(IndexedRead<C0,aType.aDouble> ia, C0 source, LDblConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
static void	fromTill(int min_i, int max_i, double a, LDblConsumer func) From-To.
static void	fromTo(int min_i, int max_i, double a, LDblConsumer func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LDblConsumer	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default void	handlingAccept(double a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static void	handlingAccept(double a, LDblConsumer func, HandlingInstructions<Throwable,RuntimeException> handling)
static <C0,I0> int	iterate(SequentialRead<C0,I0,aType.aDouble> sa, C0 source, LDblConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
default void	nestingAccept(double a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
static LDblConsumer	recursive(LFunction<LDblConsumer,LDblConsumer> selfLambda)
static LDblConsumer	safe() Safe instance.
static LDblConsumer	safe(LDblConsumer other) Safe wrapping.
static LSupplier<LDblConsumer>	safeSupplier() Safe instance supplier.
static LSupplier<LDblConsumer>	safeSupplier(LSupplier<LDblConsumer> supplier) Safe supplier.
default void	shovingAccept(double a) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
static void	times(int max_i, double a, LDblConsumer func) From-To.
static void	tryAccept(double a, LDblConsumer func)
static void	tryAccept(double a, LDblConsumer func, ExWF<RuntimeException> exF)
static void	tryAccept(double a, LDblConsumer func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static void	tryAcceptThen(double a, LDblConsumer func, LConsumer<Throwable> handler)
default LDblConsumer	trying(ExWF<RuntimeException> exF)
default LDblConsumer	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LDblConsumer	tryingThen(LConsumer<Throwable> handler)
default LTuple.Void	tupleAccept(LDblSingle args)
static LDblConsumer	wrap(java.util.function.DoubleConsumer other) Wraps JRE instance.

Methods inherited from interface java.util.function.DoubleConsumer

andThen

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

isConsumer

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

formatTo, isAction, 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

accept

default void accept(double a)

Specified by:

accept in interface java.util.function.DoubleConsumer

acceptX

void acceptX(double a)
      throws Throwable

Implement this, but call accept(double a)

Throws:

Throwable

tupleAccept

default LTuple.Void tupleAccept(LDblSingle args)

handlingAccept

default void handlingAccept(double a,
                            HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

accept

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

trying

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

accept

default void accept(double a,
                    @Nonnull
                    ExWF<RuntimeException> exF)

trying

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

acceptThen

default void acceptThen(double a,
                        @Nonnull
                        LConsumer<Throwable> handler)

tryingThen

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

nestingAccept

default void nestingAccept(double a)

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

shovingAccept

default void shovingAccept(double a)

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

handlingAccept

static void handlingAccept(double a,
                           LDblConsumer func,
                           HandlingInstructions<Throwable,RuntimeException> handling)

tryAccept

static void tryAccept(double a,
                      LDblConsumer func)

tryAccept

static void tryAccept(double a,
                      LDblConsumer func,
                      @Nonnull
                      ExWMF<RuntimeException> exF,
                      @Nonnull
                      String newMessage,
                      @Nullable
                      Object... messageParams)

tryAccept

static void tryAccept(double a,
                      LDblConsumer func,
                      @Nonnull
                      ExWF<RuntimeException> exF)

tryAcceptThen

static void tryAcceptThen(double a,
                          LDblConsumer func,
                          @Nonnull
                          LConsumer<Throwable> handler)

failSafeAccept

default void failSafeAccept(double a,
                            @Nonnull
                            LDblConsumer failSafe)

failSafeAccept

static void failSafeAccept(double a,
                           LDblConsumer func,
                           @Nonnull
                           LDblConsumer failSafe)

failSafe

static LDblConsumer failSafe(LDblConsumer func,
                             @Nonnull
                             LDblConsumer 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,
                   double a,
                   LDblConsumer func)

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     double a,
                     LDblConsumer func)

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

times

static void times(int max_i,
                  double a,
                  LDblConsumer func)

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

capture

default LAction capture(double a)

Captures arguments but delays the evaluation.

dblCons

@Nonnull
static LDblConsumer dblCons(@Nonnull
                                      LDblConsumer lambda)

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

recursive

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

dblConsThrowing

@Nonnull
static LDblConsumer dblConsThrowing(@Nonnull
                                              ExF<Throwable> exF)

dblConsThrowing

@Nonnull
static LDblConsumer dblConsThrowing(String message,
                                              @Nonnull
                                              ExMF<Throwable> exF)

call

static void call(double a,
                 @Nonnull
                 LDblConsumer lambda)

wrap

@Nonnull
static LDblConsumer wrap(java.util.function.DoubleConsumer other)

Wraps JRE instance.

safe

@Nonnull
static LDblConsumer safe()

Safe instance.

safeSupplier

@Nonnull
static LSupplier<LDblConsumer> safeSupplier()

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

safe

@Nonnull
static LDblConsumer safe(@Nullable
                                   LDblConsumer other)

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

safeSupplier

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

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

compose

@Nonnull
default LDblConsumer compose(@Nonnull
                                       LDblUnaryOperator before)

Allows to manipulate the domain of the function.

composed

static LDblConsumer composed(@Nonnull
                             LDblUnaryOperator before,
                             LDblConsumer after)

dblConsCompose

@Nonnull
default <V> LConsumer<V> dblConsCompose(@Nonnull
                                                  LToDblFunction<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LConsumer<V> composed(@Nonnull
                                 LToDblFunction<? super V> before,
                                 LDblConsumer after)

andThen

@Nonnull
default LDblConsumer andThen(@Nonnull
                                       LDblConsumer after)

Combines two LDblConsumer together in a order.

doNothing

static void doNothing(double a)

Does nothing (LDblConsumer)

forEach

static <C0> int forEach(IndexedRead<C0,aType.aDouble> ia,
                        C0 source,
                        LDblConsumer consumer)

For each element (or tuple) from arguments, calls the consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

static <C0,I0> int iterate(SequentialRead<C0,I0,aType.aDouble> sa,
                           C0 source,
                           LDblConsumer consumer)

For each element (or tuple) from arguments, calls the consumer. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.