LLongSupplier (magma-func 2.0.0 API)

All Superinterfaces:

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

All Known Implementing Classes:

LLongSupplier.LLongSupplierSingle
```
@FunctionalInterface
public interface LLongSupplier
extends java.util.function.LongSupplier, MetaSupplier, MetaInterface.NonThrowing, Codomain<aType.aLong>, Domain0
```
Non-throwing functional interface (lambda) LLongSupplier for Java 8.
Type: supplier
Domain (lvl: 0): none
Co-domain: long

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class LLongSupplier.LLongSupplierSingle
- 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`	`LLongSupplier.LLongSupplierSingle`

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
Modifier and Type	Method and Description
`static long`	`call(LLongSupplier lambda)`
`static LLongSupplier`	`failSafe(LLongSupplier func, LLongSupplier failSafe)`
`default long`	`failSafeGetAsLong(LLongSupplier failSafe)`
`static long`	`failSafeGetAsLong(LLongSupplier func, LLongSupplier failSafe)`
`static void`	`fromTill(int min_i, int max_i, LLongSupplier func)` From-To.
`static void`	`fromTo(int min_i, int max_i, LLongSupplier func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default long`	`getAsLong()`
`default long`	`getAsLong(ExWF<RuntimeException> exF)`
`default long`	`getAsLong(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default long`	`getAsLongThen(LToLongFunction<Throwable> handler)`
`long`	`getAsLongX()` Implement this, but call getAsLong()
`default LLongSupplier`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default long`	`handlingGetAsLong(HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static long`	`handlingGetAsLong(LLongSupplier func, HandlingInstructions<Throwable,RuntimeException> handling)`
`static LLongSupplier`	`longSup(LLongSupplier lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static LLongSupplier`	`longSupThrowing(ExF<Throwable> exF)`
`static LLongSupplier`	`longSupThrowing(String message, ExMF<Throwable> exF)`
`default long`	`nestingGetAsLong()` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default long`	`nonNullGetAsLong()` Just to mirror the method: Ensures the result is not null
`static LLongSupplier`	`of(long r)` Creates function that always returns the same value.
`static long`	`produceLong()` Does nothing (LLongSupplier) Supplier
`static LLongSupplier`	`recursive(LFunction<LLongSupplier,LLongSupplier> selfLambda)`
`static LLongSupplier`	`safe()` Safe instance.
`static LLongSupplier`	`safe(LLongSupplier other)` Safe wrapping.
`static LSupplier<LLongSupplier>`	`safeSupplier()` Safe instance supplier.
`static LSupplier<LLongSupplier>`	`safeSupplier(LSupplier<LLongSupplier> supplier)` Safe supplier.
`default long`	`shovingGetAsLong()` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`static void`	`times(int max_i, LLongSupplier func)` From-To.
`default LBoolSupplier`	`toBoolSup(LLongPredicate after)` Combines two functions together in a order.
`default LByteSupplier`	`toByteSup(LLongToByteFunction after)` Combines two functions together in a order.
`default LCharSupplier`	`toCharSup(LLongToCharFunction after)` Combines two functions together in a order.
`default LDblSupplier`	`toDblSup(LLongToDblFunction after)` Combines two functions together in a order.
`default LFltSupplier`	`toFltSup(LLongToFltFunction after)` Combines two functions together in a order.
`default LIntSupplier`	`toIntSup(LLongToIntFunction after)` Combines two functions together in a order.
`default LLongSupplier`	`toLongSup(LLongUnaryOperator after)` Combines two functions together in a order.
`default LSrtSupplier`	`toSrtSup(LLongToSrtFunction after)` Combines two functions together in a order.
`default <V> LSupplier<V>`	`toSup(LLongFunction<? extends V> after)` Combines two functions together in a order.
`static long`	`tryGetAsLong(LLongSupplier func)`
`static long`	`tryGetAsLong(LLongSupplier func, ExWF<RuntimeException> exF)`
`static long`	`tryGetAsLong(LLongSupplier func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static long`	`tryGetAsLongThen(LLongSupplier func, LToLongFunction<Throwable> handler)`
`default LLongSupplier`	`trying(ExWF<RuntimeException> exF)`
`default LLongSupplier`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LLongSupplier`	`tryingThen(LToLongFunction<Throwable> handler)`
`default long`	`tupleGetAsLong(LTuple.Void args)`
`static LLongSupplier`	`wrap(java.util.function.LongSupplier 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

getAsLong
```
default long getAsLong()
```
Specified by:

getAsLong in interface java.util.function.LongSupplier

getAsLongX
```
long getAsLongX()
         throws Throwable
```
Implement this, but call getAsLong()

Throws:

Throwable

tupleGetAsLong

default long tupleGetAsLong(LTuple.Void args)

handlingGetAsLong

default long handlingGetAsLong(HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

getAsLong

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

trying

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

getAsLong

default long getAsLong(@Nonnull
                       ExWF<RuntimeException> exF)

trying

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

getAsLongThen

default long getAsLongThen(@Nonnull
                           LToLongFunction<Throwable> handler)

tryingThen

default LLongSupplier tryingThen(@Nonnull
                                 LToLongFunction<Throwable> handler)

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

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

handlingGetAsLong

static long handlingGetAsLong(LLongSupplier func,
                              HandlingInstructions<Throwable,RuntimeException> handling)

tryGetAsLong

static long tryGetAsLong(LLongSupplier func)

tryGetAsLong

static long tryGetAsLong(LLongSupplier func,
                         @Nonnull
                         ExWMF<RuntimeException> exF,
                         @Nonnull
                         String newMessage,
                         @Nullable
                         Object... messageParams)

tryGetAsLong

static long tryGetAsLong(LLongSupplier func,
                         @Nonnull
                         ExWF<RuntimeException> exF)

tryGetAsLongThen

static long tryGetAsLongThen(LLongSupplier func,
                             @Nonnull
                             LToLongFunction<Throwable> handler)

failSafeGetAsLong

default long failSafeGetAsLong(@Nonnull
                               LLongSupplier failSafe)

failSafeGetAsLong

static long failSafeGetAsLong(LLongSupplier func,
                              @Nonnull
                              LLongSupplier failSafe)

failSafe

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

nonNullGetAsLong
```
default long nonNullGetAsLong()
```
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,
                   LLongSupplier func)

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

fromTill

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

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

times

static void times(int max_i,
                  LLongSupplier func)

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

of
```
static LLongSupplier of(long r)
```
Creates function that always returns the same value.

longSup

@Nonnull
static LLongSupplier longSup(@Nonnull
                                       LLongSupplier lambda)

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

recursive

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

longSupThrowing

@Nonnull
static LLongSupplier longSupThrowing(@Nonnull
                                               ExF<Throwable> exF)

longSupThrowing

@Nonnull
static LLongSupplier longSupThrowing(String message,
                                               @Nonnull
                                               ExMF<Throwable> exF)

call

static long call(@Nonnull
                 LLongSupplier lambda)

wrap

@Nonnull
static LLongSupplier wrap(java.util.function.LongSupplier other)

Wraps JRE instance.

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

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

safe

@Nonnull
static LLongSupplier safe(@Nullable
                                    LLongSupplier other)

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

safeSupplier

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

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