LDblSupplier (magma-func 2.0.0 API)

All Superinterfaces:

Codomain<aType.aDouble>, Domain, Domain0, java.util.function.DoubleSupplier, Formattable, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaSupplier

All Known Implementing Classes:

LDblSupplier.LDblSupplierSingle
```
@FunctionalInterface
public interface LDblSupplier
extends java.util.function.DoubleSupplier, MetaSupplier, MetaInterface.NonThrowing, Codomain<aType.aDouble>, Domain0
```
Non-throwing functional interface (lambda) LDblSupplier for Java 8.
Type: supplier
Domain (lvl: 0): none
Co-domain: double

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class LDblSupplier.LDblSupplierSingle
- Nested classes/interfaces inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface
  MetaInterface.NonThrowing, MetaInterface.Throwing<X>

Nested Classes
Modifier and Type	Interface and Description
`static class`	`LDblSupplier.LDblSupplierSingle`

Field Summary

Fields
Modifier and Type Field and Description

static String DESCRIPTION

Fields
Modifier and Type	Field and Description
`static String`	`DESCRIPTION`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`static double`	`call(LDblSupplier lambda)`
`static LDblSupplier`	`dblSup(LDblSupplier lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static LDblSupplier`	`dblSupThrowing(ExF<Throwable> exF)`
`static LDblSupplier`	`dblSupThrowing(String message, ExMF<Throwable> exF)`
`static LDblSupplier`	`failSafe(LDblSupplier func, LDblSupplier failSafe)`
`default double`	`failSafeGetAsDbl(LDblSupplier failSafe)`
`static double`	`failSafeGetAsDbl(LDblSupplier func, LDblSupplier failSafe)`
`static void`	`fromTill(int min_i, int max_i, LDblSupplier func)` From-To.
`static void`	`fromTo(int min_i, int max_i, LDblSupplier func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default double`	`getAsDbl()`
`default double`	`getAsDbl(ExWF<RuntimeException> exF)`
`default double`	`getAsDbl(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default double`	`getAsDblThen(LToDblFunction<Throwable> handler)`
`double`	`getAsDblX()` Implement this, but call getAsDbl()
`default double`	`getAsDouble()` Deprecated. Calling this method via LDblSupplier interface should be discouraged.
`default LDblSupplier`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default double`	`handlingGetAsDbl(HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static double`	`handlingGetAsDbl(LDblSupplier func, HandlingInstructions<Throwable,RuntimeException> handling)`
`default double`	`nestingGetAsDbl()` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default double`	`nonNullGetAsDbl()` Just to mirror the method: Ensures the result is not null
`static LDblSupplier`	`of(double r)` Creates function that always returns the same value.
`static double`	`produceDouble()` Does nothing (LDblSupplier) Supplier
`static LDblSupplier`	`recursive(LFunction<LDblSupplier,LDblSupplier> selfLambda)`
`static LDblSupplier`	`safe()` Safe instance.
`static LDblSupplier`	`safe(LDblSupplier other)` Safe wrapping.
`static LSupplier<LDblSupplier>`	`safeSupplier()` Safe instance supplier.
`static LSupplier<LDblSupplier>`	`safeSupplier(LSupplier<LDblSupplier> supplier)` Safe supplier.
`default double`	`shovingGetAsDbl()` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`static void`	`times(int max_i, LDblSupplier func)` From-To.
`default LBoolSupplier`	`toBoolSup(LDblPredicate after)` Combines two functions together in a order.
`default LByteSupplier`	`toByteSup(LDblToByteFunction after)` Combines two functions together in a order.
`default LCharSupplier`	`toCharSup(LDblToCharFunction after)` Combines two functions together in a order.
`default LDblSupplier`	`toDblSup(LDblUnaryOperator after)` Combines two functions together in a order.
`default LFltSupplier`	`toFltSup(LDblToFltFunction after)` Combines two functions together in a order.
`default LIntSupplier`	`toIntSup(LDblToIntFunction after)` Combines two functions together in a order.
`default LLongSupplier`	`toLongSup(LDblToLongFunction after)` Combines two functions together in a order.
`default LSrtSupplier`	`toSrtSup(LDblToSrtFunction after)` Combines two functions together in a order.
`default <V> LSupplier<V>`	`toSup(LDblFunction<? extends V> after)` Combines two functions together in a order.
`static double`	`tryGetAsDbl(LDblSupplier func)`
`static double`	`tryGetAsDbl(LDblSupplier func, ExWF<RuntimeException> exF)`
`static double`	`tryGetAsDbl(LDblSupplier func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static double`	`tryGetAsDblThen(LDblSupplier func, LToDblFunction<Throwable> handler)`
`default LDblSupplier`	`trying(ExWF<RuntimeException> exF)`
`default LDblSupplier`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LDblSupplier`	`tryingThen(LToDblFunction<Throwable> handler)`
`default double`	`tupleGetAsDbl(LTuple.Void args)`
`static LDblSupplier`	`wrap(java.util.function.DoubleSupplier 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

Method Detail

getAsDouble
```
@Deprecated
default double getAsDouble()
```
Deprecated. Calling this method via LDblSupplier interface should be discouraged.

Default implementation for JRE method that calls exception nesting method.

Specified by:

getAsDouble in interface java.util.function.DoubleSupplier

getAsDbl
```
default double getAsDbl()
```

getAsDblX
```
double getAsDblX()
          throws Throwable
```
Implement this, but call getAsDbl()

Throws:

Throwable

tupleGetAsDbl

default double tupleGetAsDbl(LTuple.Void args)

handlingGetAsDbl

default double handlingGetAsDbl(HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

getAsDbl

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

trying

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

getAsDbl

default double getAsDbl(@Nonnull
                        ExWF<RuntimeException> exF)

trying

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

getAsDblThen

default double getAsDblThen(@Nonnull
                            LToDblFunction<Throwable> handler)

tryingThen

default LDblSupplier tryingThen(@Nonnull
                                LToDblFunction<Throwable> handler)

nestingGetAsDbl
```
default double nestingGetAsDbl()
```
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

shovingGetAsDbl
```
default double shovingGetAsDbl()
```
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.

handlingGetAsDbl

static double handlingGetAsDbl(LDblSupplier func,
                               HandlingInstructions<Throwable,RuntimeException> handling)

tryGetAsDbl

static double tryGetAsDbl(LDblSupplier func)

tryGetAsDbl

static double tryGetAsDbl(LDblSupplier func,
                          @Nonnull
                          ExWMF<RuntimeException> exF,
                          @Nonnull
                          String newMessage,
                          @Nullable
                          Object... messageParams)

tryGetAsDbl

static double tryGetAsDbl(LDblSupplier func,
                          @Nonnull
                          ExWF<RuntimeException> exF)

tryGetAsDblThen

static double tryGetAsDblThen(LDblSupplier func,
                              @Nonnull
                              LToDblFunction<Throwable> handler)

failSafeGetAsDbl

default double failSafeGetAsDbl(@Nonnull
                                LDblSupplier failSafe)

failSafeGetAsDbl

static double failSafeGetAsDbl(LDblSupplier func,
                               @Nonnull
                               LDblSupplier failSafe)

failSafe

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

nonNullGetAsDbl
```
default double nonNullGetAsDbl()
```
Just to mirror the method: 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 void fromTo(int min_i,
                   int max_i,
                   LDblSupplier func)

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

fromTill

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

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

times

static void times(int max_i,
                  LDblSupplier func)

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

of
```
static LDblSupplier of(double r)
```
Creates function that always returns the same value.

dblSup
```
@Nonnull
static LDblSupplier dblSup(@Nonnull
                                     LDblSupplier lambda)
```
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

recursive

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

dblSupThrowing

@Nonnull
static LDblSupplier dblSupThrowing(@Nonnull
                                             ExF<Throwable> exF)

dblSupThrowing

@Nonnull
static LDblSupplier dblSupThrowing(String message,
                                             @Nonnull
                                             ExMF<Throwable> exF)

call

static double call(@Nonnull
                   LDblSupplier lambda)

wrap

@Nonnull
static LDblSupplier wrap(java.util.function.DoubleSupplier other)

Wraps JRE instance.

safe
```
@Nonnull
static LDblSupplier safe()
```
Safe instance. That always returns the same value (as produceDouble).

safeSupplier
```
@Nonnull
static LSupplier<LDblSupplier> safeSupplier()
```
Safe instance supplier. Returns supplier of safe() instance.

safe

@Nonnull
static LDblSupplier safe(@Nullable
                                   LDblSupplier other)

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

safeSupplier

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

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