eu.lunisolar.magma.func.consumer.primitives

Interface LFltConsumer

All Superinterfaces:

Codomain<aType.aVoid>, Domain, Domain1<aType.aFloat>, Formattable, MetaConsumer, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>

All Known Implementing Classes:

LFltConsumer.LFltConsumerSingle

@FunctionalInterface
public interface LFltConsumer
extends MetaConsumer, MetaInterface.NonThrowing, Codomain<aType.aVoid>, Domain1<aType.aFloat>

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

Type: consumer

Domain (lvl: 1): float a

Co-domain: none

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LFltConsumer.LFltConsumerSingle

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(float a)
default void	accept(float a, ExWF<RuntimeException> exF)
default void	accept(float a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default void	acceptThen(float a, LConsumer<Throwable> handler)
void	acceptX(float a) Implement this, but call accept(float a)
default LFltConsumer	andThen(LFltConsumer after) Combines two LFltConsumer together in a order.
static void	call(float a, LFltConsumer lambda)
default LAction	capture(float a) Captures arguments but delays the evaluation.
default LFltConsumer	compose(LFltUnaryOperator before) Allows to manipulate the domain of the function.
static LFltConsumer	composed(LFltUnaryOperator before, LFltConsumer after)
static <V> LConsumer<V>	composed(LToFltFunction<? super V> before, LFltConsumer after)
static void	doNothing(float a) Does nothing (LFltConsumer)
static LFltConsumer	failSafe(LFltConsumer func, LFltConsumer failSafe)
default void	failSafeAccept(float a, LFltConsumer failSafe)
static void	failSafeAccept(float a, LFltConsumer func, LFltConsumer failSafe)
static LFltConsumer	fltCons(LFltConsumer 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>	fltConsCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
static LFltConsumer	fltConsThrowing(ExF<Throwable> exF)
static LFltConsumer	fltConsThrowing(String message, ExMF<Throwable> exF)
static <C0> int	forEach(IndexedRead<C0,aType.aFloat> ia, C0 source, LFltConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
static void	fromTill(int min_i, int max_i, float a, LFltConsumer func) From-To.
static void	fromTo(int min_i, int max_i, float a, LFltConsumer func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LFltConsumer	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default void	handlingAccept(float a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static void	handlingAccept(float a, LFltConsumer func, HandlingInstructions<Throwable,RuntimeException> handling)
static <C0,I0> int	iterate(SequentialRead<C0,I0,aType.aFloat> sa, C0 source, LFltConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
default void	nestingAccept(float a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
static LFltConsumer	recursive(LFunction<LFltConsumer,LFltConsumer> selfLambda)
static LFltConsumer	safe() Safe instance.
static LFltConsumer	safe(LFltConsumer other) Safe wrapping.
static LSupplier<LFltConsumer>	safeSupplier() Safe instance supplier.
static LSupplier<LFltConsumer>	safeSupplier(LSupplier<LFltConsumer> supplier) Safe supplier.
default void	shovingAccept(float 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, float a, LFltConsumer func) From-To.
static void	tryAccept(float a, LFltConsumer func)
static void	tryAccept(float a, LFltConsumer func, ExWF<RuntimeException> exF)
static void	tryAccept(float a, LFltConsumer func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static void	tryAcceptThen(float a, LFltConsumer func, LConsumer<Throwable> handler)
default LFltConsumer	trying(ExWF<RuntimeException> exF)
default LFltConsumer	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LFltConsumer	tryingThen(LConsumer<Throwable> handler)
default LTuple.Void	tupleAccept(LFltSingle args)

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(float a)

acceptX

void acceptX(float a)
      throws Throwable

Implement this, but call accept(float a)

Throws:

Throwable

tupleAccept

default LTuple.Void tupleAccept(LFltSingle args)

handlingAccept

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

Function call that handles exceptions according to the instructions.

handling

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

accept

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

trying

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

accept

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

trying

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

acceptThen

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

tryingThen

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

nestingAccept

default void nestingAccept(float a)

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

shovingAccept

default void shovingAccept(float a)

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

handlingAccept

static void handlingAccept(float a,
                           LFltConsumer func,
                           HandlingInstructions<Throwable,RuntimeException> handling)

tryAccept

static void tryAccept(float a,
                      LFltConsumer func)

tryAccept

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

tryAccept

static void tryAccept(float a,
                      LFltConsumer func,
                      @Nonnull
                      ExWF<RuntimeException> exF)

tryAcceptThen

static void tryAcceptThen(float a,
                          LFltConsumer func,
                          @Nonnull
                          LConsumer<Throwable> handler)

failSafeAccept

default void failSafeAccept(float a,
                            @Nonnull
                            LFltConsumer failSafe)

failSafeAccept

static void failSafeAccept(float a,
                           LFltConsumer func,
                           @Nonnull
                           LFltConsumer failSafe)

failSafe

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

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     float a,
                     LFltConsumer func)

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

times

static void times(int max_i,
                  float a,
                  LFltConsumer func)

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

capture

default LAction capture(float a)

Captures arguments but delays the evaluation.

fltCons

@Nonnull
static LFltConsumer fltCons(@Nonnull
                                      LFltConsumer lambda)

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

recursive

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

fltConsThrowing

@Nonnull
static LFltConsumer fltConsThrowing(@Nonnull
                                              ExF<Throwable> exF)

fltConsThrowing

@Nonnull
static LFltConsumer fltConsThrowing(String message,
                                              @Nonnull
                                              ExMF<Throwable> exF)

call

static void call(float a,
                 @Nonnull
                 LFltConsumer lambda)

safe

@Nonnull
static LFltConsumer safe()

Safe instance.

safeSupplier

@Nonnull
static LSupplier<LFltConsumer> safeSupplier()

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

safe

@Nonnull
static LFltConsumer safe(@Nullable
                                   LFltConsumer other)

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

safeSupplier

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

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

compose

@Nonnull
default LFltConsumer compose(@Nonnull
                                       LFltUnaryOperator before)

Allows to manipulate the domain of the function.

composed

static LFltConsumer composed(@Nonnull
                             LFltUnaryOperator before,
                             LFltConsumer after)

fltConsCompose

@Nonnull
default <V> LConsumer<V> fltConsCompose(@Nonnull
                                                  LToFltFunction<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LConsumer<V> composed(@Nonnull
                                 LToFltFunction<? super V> before,
                                 LFltConsumer after)

andThen

@Nonnull
default LFltConsumer andThen(@Nonnull
                                       LFltConsumer after)

Combines two LFltConsumer together in a order.

doNothing

static void doNothing(float a)

Does nothing (LFltConsumer)

forEach

static <C0> int forEach(IndexedRead<C0,aType.aFloat> ia,
                        C0 source,
                        LFltConsumer 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.aFloat> sa,
                           C0 source,
                           LFltConsumer 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.