eu.lunisolar.magma.func.supplier

Interface LSupplier<T>

All Superinterfaces:

Codomain<aType.a<T>>, Domain, Domain0, Formattable, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaSupplier, java.util.function.Supplier<T>

All Known Implementing Classes:

LSupplier.LSupplierSingle

@FunctionalInterface
public interface LSupplier<T>
extends java.util.function.Supplier<T>, MetaSupplier, MetaInterface.NonThrowing, Codomain<aType.a<T>>, Domain0

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

Type: supplier

Domain (lvl: 0): none

Co-domain: T

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LSupplier.LSupplierSingle<T>

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
static LSupplier<String>	NULL_VALUE_MESSAGE_SUPPLIER

Method Summary

Modifier and Type	Method and Description
default LSupplier<T>	after(LConsumer<? super T> after)
default LSupplier<T>	before(LAction before)
static <T> T	call(LSupplier<T> lambda)
default <V2> LSupplier<V2>	cast() Cast that replace generics.
static <V2,T> LSupplier<V2>	cast(LSupplier<T> function) Cast that replace generics.
static <T> LSupplier<T>	failSafe(LSupplier<T> func, LSupplier<T> failSafe)
default T	failSafeGet(LSupplier<T> failSafe)
static <T> T	failSafeGet(LSupplier<T> func, LSupplier<T> failSafe)
static <T> void	fromTill(int min_i, int max_i, LSupplier<T> func) From-To.
static <T> void	fromTo(int min_i, int max_i, LSupplier<T> func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default T	get()
default T	get(ExWF<RuntimeException> exF)
default T	get(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default T	getThen(LFunction<Throwable,T> handler)
T	getX() Implement this, but call get()
default LSupplier<T>	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default T	handlingGet(HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static <T> T	handlingGet(LSupplier<T> func, HandlingInstructions<Throwable,RuntimeException> handling)
default T	nestingGet() Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default LSupplier<T>	nonNullable() Converts to function that makes sure that the result is not null.
default T	nonNullGet() Function call that ensures the result is not null
static <T> LSupplier<T>	of(T r) Creates function that always returns the same value.
static <T> T	produce() Does nothing (LSupplier) Supplier
static <T> LSupplier<T>	recursive(LFunction<LSupplier<T>,LSupplier<T>> selfLambda)
static <T> LSupplier<T>	safe() Safe instance.
static <T> LSupplier<T>	safe(LSupplier<T> other) Safe wrapping.
static <T> LSupplier<LSupplier<T>>	safeSupplier() Safe instance supplier.
static <T> LSupplier<LSupplier<T>>	safeSupplier(LSupplier<LSupplier<T>> supplier) Safe supplier.
default T	shovingGet() Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
static <T> LSupplier<T>	sup(LSupplier<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T> LSupplier<T>	supThrowing(ExF<Throwable> exF)
static <T> LSupplier<T>	supThrowing(String message, ExMF<Throwable> exF)
static <T> void	times(int max_i, LSupplier<T> func) From-To.
default LAction	toAct(LConsumer<? super T> after) Combines two functions together in a order.
default LBoolSupplier	toBoolSup(LPredicate<? super T> after) Combines two functions together in a order.
default LByteSupplier	toByteSup(LToByteFunction<? super T> after) Combines two functions together in a order.
default LCharSupplier	toCharSup(LToCharFunction<? super T> after) Combines two functions together in a order.
default LDblSupplier	toDblSup(LToDblFunction<? super T> after) Combines two functions together in a order.
default LFltSupplier	toFltSup(LToFltFunction<? super T> after) Combines two functions together in a order.
default LIntSupplier	toIntSup(LToIntFunction<? super T> after) Combines two functions together in a order.
default LLongSupplier	toLongSup(LToLongFunction<? super T> after) Combines two functions together in a order.
default LSrtSupplier	toSrtSup(LToSrtFunction<? super T> after) Combines two functions together in a order.
default <V> LSupplier<V>	toSup(LFunction<? super T,? extends V> after) Combines two functions together in a order.
static <T> T	tryGet(LSupplier<T> func)
static <T> T	tryGet(LSupplier<T> func, ExWF<RuntimeException> exF)
static <T> T	tryGet(LSupplier<T> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T> T	tryGetThen(LSupplier<T> func, LFunction<Throwable,T> handler)
default LSupplier<T>	trying(ExWF<RuntimeException> exF)
default LSupplier<T>	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LSupplier<T>	tryingThen(LFunction<Throwable,T> handler)
default T	tupleGet(LTuple.Void args)
default LSupplier	untyped() Cast that removes generics.
static <T> LSupplier<T>	wrap(java.util.function.Supplier<T> other) Wraps JRE instance.

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

isSupplier

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

formatTo, isAction, isConsumer, isFunction, isOperator, isPredicate

Methods inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface.NonThrowing

isThrowing

Field Detail

DESCRIPTION

static final String DESCRIPTION

See Also:

Constant Field Values

NULL_VALUE_MESSAGE_SUPPLIER

static final LSupplier<String> NULL_VALUE_MESSAGE_SUPPLIER

Method Detail

get

@Nullable
default T get()

Specified by:

get in interface java.util.function.Supplier<T>

getX

T getX()
throws Throwable

Implement this, but call get()

Throws:

Throwable

tupleGet

default T tupleGet(LTuple.Void args)

handlingGet

default T handlingGet(HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

default LSupplier<T> handling(HandlingInstructions<Throwable,RuntimeException> handling)

get

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

trying

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

get

default T get(@Nonnull
              ExWF<RuntimeException> exF)

trying

default LSupplier<T> trying(@Nonnull
                            ExWF<RuntimeException> exF)

getThen

default T getThen(@Nonnull
                  LFunction<Throwable,T> handler)

tryingThen

default LSupplier<T> tryingThen(@Nonnull
                                LFunction<Throwable,T> handler)

nestingGet

default T nestingGet()

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

shovingGet

default T shovingGet()

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

handlingGet

static <T> T handlingGet(LSupplier<T> func,
                         HandlingInstructions<Throwable,RuntimeException> handling)

tryGet

static <T> T tryGet(LSupplier<T> func)

tryGet

static <T> T tryGet(LSupplier<T> func,
                    @Nonnull
                    ExWMF<RuntimeException> exF,
                    @Nonnull
                    String newMessage,
                    @Nullable
                    Object... messageParams)

tryGet

static <T> T tryGet(LSupplier<T> func,
                    @Nonnull
                    ExWF<RuntimeException> exF)

tryGetThen

static <T> T tryGetThen(LSupplier<T> func,
                        @Nonnull
                        LFunction<Throwable,T> handler)

failSafeGet

default T failSafeGet(@Nonnull
                      LSupplier<T> failSafe)

failSafeGet

static <T> T failSafeGet(LSupplier<T> func,
                         @Nonnull
                         LSupplier<T> failSafe)

failSafe

static <T> LSupplier<T> failSafe(LSupplier<T> func,
                                 @Nonnull
                                 LSupplier<T> failSafe)

nonNullGet

@Nonnull
default T nonNullGet()

Function call that 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 <T> void fromTo(int min_i,
                       int max_i,
                       LSupplier<T> func)

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

fromTill

static <T> void fromTill(int min_i,
                         int max_i,
                         LSupplier<T> func)

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

times

static <T> void times(int max_i,
                      LSupplier<T> func)

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

untyped

default LSupplier untyped()

Cast that removes generics.

cast

default <V2> LSupplier<V2> cast()

Cast that replace generics.

cast

static <V2,T> LSupplier<V2> cast(LSupplier<T> function)

Cast that replace generics.

of

static <T> LSupplier<T> of(T r)

Creates function that always returns the same value.

sup

@Nonnull
static <T> LSupplier<T> sup(@Nonnull
                                      LSupplier<T> lambda)

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

recursive

@Nonnull
static <T> LSupplier<T> recursive(@Nonnull
                                            LFunction<LSupplier<T>,LSupplier<T>> selfLambda)

supThrowing

@Nonnull
static <T> LSupplier<T> supThrowing(@Nonnull
                                              ExF<Throwable> exF)

supThrowing

@Nonnull
static <T> LSupplier<T> supThrowing(String message,
                                              @Nonnull
                                              ExMF<Throwable> exF)

call

static <T> T call(@Nonnull
                  LSupplier<T> lambda)

wrap

@Nonnull
static <T> LSupplier<T> wrap(java.util.function.Supplier<T> other)

Wraps JRE instance.

safe

@Nonnull
static <T> LSupplier<T> safe()

Safe instance. That always returns the same value (as produce).

safeSupplier

@Nonnull
static <T> LSupplier<LSupplier<T>> safeSupplier()

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

safe

@Nonnull
static <T> LSupplier<T> safe(@Nullable
                                       LSupplier<T> other)

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

safeSupplier

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

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

toSup

@Nonnull
default <V> LSupplier<V> toSup(@Nonnull
                                         LFunction<? super T,? extends V> after)

Combines two functions together in a order.

toAct

@Nonnull
default LAction toAct(@Nonnull
                                LConsumer<? super T> after)

Combines two functions together in a order.

before

@Nonnull
default LSupplier<T> before(@Nonnull
                                      LAction before)

after

@Nonnull
default LSupplier<T> after(@Nonnull
                                     LConsumer<? super T> after)

toByteSup

@Nonnull
default LByteSupplier toByteSup(@Nonnull
                                          LToByteFunction<? super T> after)

Combines two functions together in a order.

toSrtSup

@Nonnull
default LSrtSupplier toSrtSup(@Nonnull
                                        LToSrtFunction<? super T> after)

Combines two functions together in a order.

toIntSup

@Nonnull
default LIntSupplier toIntSup(@Nonnull
                                        LToIntFunction<? super T> after)

Combines two functions together in a order.

toLongSup

@Nonnull
default LLongSupplier toLongSup(@Nonnull
                                          LToLongFunction<? super T> after)

Combines two functions together in a order.

toFltSup

@Nonnull
default LFltSupplier toFltSup(@Nonnull
                                        LToFltFunction<? super T> after)

Combines two functions together in a order.

toDblSup

@Nonnull
default LDblSupplier toDblSup(@Nonnull
                                        LToDblFunction<? super T> after)

Combines two functions together in a order.

toCharSup

@Nonnull
default LCharSupplier toCharSup(@Nonnull
                                          LToCharFunction<? super T> after)

Combines two functions together in a order.

toBoolSup

@Nonnull
default LBoolSupplier toBoolSup(@Nonnull
                                          LPredicate<? super T> after)

Combines two functions together in a order.

nonNullable

@Nonnull
default LSupplier<T> nonNullable()

Converts to function that makes sure that the result is not null.

produce

static <T> T produce()

Does nothing (LSupplier) Supplier