LIntSupplier (magma-func 2.0.0 API)

All Superinterfaces:

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

All Known Implementing Classes:

LIntSupplier.LIntSupplierSingle
```
@FunctionalInterface
public interface LIntSupplier
extends java.util.function.IntSupplier, MetaSupplier, MetaInterface.NonThrowing, Codomain<aType.aInt>, Domain0
```
Non-throwing functional interface (lambda) LIntSupplier for Java 8.
Type: supplier
Domain (lvl: 0): none
Co-domain: int

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class LIntSupplier.LIntSupplierSingle
- 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`	`LIntSupplier.LIntSupplierSingle`

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 int`	`call(LIntSupplier lambda)`
`static LIntSupplier`	`failSafe(LIntSupplier func, LIntSupplier failSafe)`
`default int`	`failSafeGetAsInt(LIntSupplier failSafe)`
`static int`	`failSafeGetAsInt(LIntSupplier func, LIntSupplier failSafe)`
`static void`	`fromTill(int min_i, int max_i, LIntSupplier func)` From-To.
`static void`	`fromTo(int min_i, int max_i, LIntSupplier func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default int`	`getAsInt()`
`default int`	`getAsInt(ExWF<RuntimeException> exF)`
`default int`	`getAsInt(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default int`	`getAsIntThen(LToIntFunction<Throwable> handler)`
`int`	`getAsIntX()` Implement this, but call getAsInt()
`default LIntSupplier`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default int`	`handlingGetAsInt(HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static int`	`handlingGetAsInt(LIntSupplier func, HandlingInstructions<Throwable,RuntimeException> handling)`
`static LIntSupplier`	`intSup(LIntSupplier lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static LIntSupplier`	`intSupThrowing(ExF<Throwable> exF)`
`static LIntSupplier`	`intSupThrowing(String message, ExMF<Throwable> exF)`
`default int`	`nestingGetAsInt()` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default int`	`nonNullGetAsInt()` Just to mirror the method: Ensures the result is not null
`static LIntSupplier`	`of(int r)` Creates function that always returns the same value.
`static int`	`produceInt()` Does nothing (LIntSupplier) Supplier
`static LIntSupplier`	`recursive(LFunction<LIntSupplier,LIntSupplier> selfLambda)`
`static LIntSupplier`	`safe()` Safe instance.
`static LIntSupplier`	`safe(LIntSupplier other)` Safe wrapping.
`static LSupplier<LIntSupplier>`	`safeSupplier()` Safe instance supplier.
`static LSupplier<LIntSupplier>`	`safeSupplier(LSupplier<LIntSupplier> supplier)` Safe supplier.
`default int`	`shovingGetAsInt()` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`static void`	`times(int max_i, LIntSupplier func)` From-To.
`default LBoolSupplier`	`toBoolSup(LIntPredicate after)` Combines two functions together in a order.
`default LByteSupplier`	`toByteSup(LIntToByteFunction after)` Combines two functions together in a order.
`default LCharSupplier`	`toCharSup(LIntToCharFunction after)` Combines two functions together in a order.
`default LDblSupplier`	`toDblSup(LIntToDblFunction after)` Combines two functions together in a order.
`default LFltSupplier`	`toFltSup(LIntToFltFunction after)` Combines two functions together in a order.
`default LIntSupplier`	`toIntSup(LIntUnaryOperator after)` Combines two functions together in a order.
`default LLongSupplier`	`toLongSup(LIntToLongFunction after)` Combines two functions together in a order.
`default LSrtSupplier`	`toSrtSup(LIntToSrtFunction after)` Combines two functions together in a order.
`default <V> LSupplier<V>`	`toSup(LIntFunction<? extends V> after)` Combines two functions together in a order.
`static int`	`tryGetAsInt(LIntSupplier func)`
`static int`	`tryGetAsInt(LIntSupplier func, ExWF<RuntimeException> exF)`
`static int`	`tryGetAsInt(LIntSupplier func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static int`	`tryGetAsIntThen(LIntSupplier func, LToIntFunction<Throwable> handler)`
`default LIntSupplier`	`trying(ExWF<RuntimeException> exF)`
`default LIntSupplier`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LIntSupplier`	`tryingThen(LToIntFunction<Throwable> handler)`
`default int`	`tupleGetAsInt(LTuple.Void args)`
`static LIntSupplier`	`wrap(java.util.function.IntSupplier 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

getAsInt
```
default int getAsInt()
```
Specified by:

getAsInt in interface java.util.function.IntSupplier

getAsIntX
```
int getAsIntX()
       throws Throwable
```
Implement this, but call getAsInt()

Throws:

Throwable

tupleGetAsInt

default int tupleGetAsInt(LTuple.Void args)

handlingGetAsInt

default int handlingGetAsInt(HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

getAsInt

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

trying

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

getAsInt

default int getAsInt(@Nonnull
                     ExWF<RuntimeException> exF)

trying

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

getAsIntThen

default int getAsIntThen(@Nonnull
                         LToIntFunction<Throwable> handler)

tryingThen

default LIntSupplier tryingThen(@Nonnull
                                LToIntFunction<Throwable> handler)

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

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

handlingGetAsInt

static int handlingGetAsInt(LIntSupplier func,
                            HandlingInstructions<Throwable,RuntimeException> handling)

tryGetAsInt

static int tryGetAsInt(LIntSupplier func)

tryGetAsInt

static int tryGetAsInt(LIntSupplier func,
                       @Nonnull
                       ExWMF<RuntimeException> exF,
                       @Nonnull
                       String newMessage,
                       @Nullable
                       Object... messageParams)

tryGetAsInt

static int tryGetAsInt(LIntSupplier func,
                       @Nonnull
                       ExWF<RuntimeException> exF)

tryGetAsIntThen

static int tryGetAsIntThen(LIntSupplier func,
                           @Nonnull
                           LToIntFunction<Throwable> handler)

failSafeGetAsInt

default int failSafeGetAsInt(@Nonnull
                             LIntSupplier failSafe)

failSafeGetAsInt

static int failSafeGetAsInt(LIntSupplier func,
                            @Nonnull
                            LIntSupplier failSafe)

failSafe

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

nonNullGetAsInt
```
default int nonNullGetAsInt()
```
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,
                   LIntSupplier func)

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

fromTill

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

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

times

static void times(int max_i,
                  LIntSupplier func)

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

of
```
static LIntSupplier of(int r)
```
Creates function that always returns the same value.

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

recursive

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

intSupThrowing

@Nonnull
static LIntSupplier intSupThrowing(@Nonnull
                                             ExF<Throwable> exF)

intSupThrowing

@Nonnull
static LIntSupplier intSupThrowing(String message,
                                             @Nonnull
                                             ExMF<Throwable> exF)

call

static int call(@Nonnull
                LIntSupplier lambda)

wrap

@Nonnull
static LIntSupplier wrap(java.util.function.IntSupplier other)

Wraps JRE instance.

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

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

safe

@Nonnull
static LIntSupplier safe(@Nullable
                                   LIntSupplier other)

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

safeSupplier

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

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