LBoolSupplier (magma-func 2.0.0 API)

All Superinterfaces:

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

All Known Implementing Classes:

LBoolSupplier.LBoolSupplierSingle
```
@FunctionalInterface
public interface LBoolSupplier
extends java.util.function.BooleanSupplier, MetaSupplier, MetaInterface.NonThrowing, Codomain<aType.aBool>, Domain0
```
Non-throwing functional interface (lambda) LBoolSupplier for Java 8.
Type: supplier
Domain (lvl: 0): none
Co-domain: boolean

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class LBoolSupplier.LBoolSupplierSingle
- 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`	`LBoolSupplier.LBoolSupplierSingle`

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 LBoolSupplier`	`boolSup(LBoolSupplier lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static LBoolSupplier`	`boolSupThrowing(ExF<Throwable> exF)`
`static LBoolSupplier`	`boolSupThrowing(String message, ExMF<Throwable> exF)`
`static boolean`	`call(LBoolSupplier lambda)`
`static LBoolSupplier`	`failSafe(LBoolSupplier func, LBoolSupplier failSafe)`
`default boolean`	`failSafeGetAsBool(LBoolSupplier failSafe)`
`static boolean`	`failSafeGetAsBool(LBoolSupplier func, LBoolSupplier failSafe)`
`static void`	`fromTill(int min_i, int max_i, LBoolSupplier func)` From-To.
`static void`	`fromTo(int min_i, int max_i, LBoolSupplier func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default boolean`	`getAsBool()`
`default boolean`	`getAsBool(ExWF<RuntimeException> exF)`
`default boolean`	`getAsBool(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default boolean`	`getAsBoolean()` Deprecated. Calling this method via LBoolSupplier interface should be discouraged.
`default boolean`	`getAsBoolThen(LPredicate<Throwable> handler)`
`boolean`	`getAsBoolX()` Implement this, but call getAsBool()
`default LBoolSupplier`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default boolean`	`handlingGetAsBool(HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static boolean`	`handlingGetAsBool(LBoolSupplier func, HandlingInstructions<Throwable,RuntimeException> handling)`
`default boolean`	`nestingGetAsBool()` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default boolean`	`nonNullGetAsBool()` Just to mirror the method: Ensures the result is not null
`static LBoolSupplier`	`of(boolean r)` Creates function that always returns the same value.
`static boolean`	`produceBoolean()` Does nothing (LBoolSupplier) Supplier
`static LBoolSupplier`	`recursive(LFunction<LBoolSupplier,LBoolSupplier> selfLambda)`
`static LBoolSupplier`	`safe()` Safe instance.
`static LBoolSupplier`	`safe(LBoolSupplier other)` Safe wrapping.
`static LSupplier<LBoolSupplier>`	`safeSupplier()` Safe instance supplier.
`static LSupplier<LBoolSupplier>`	`safeSupplier(LSupplier<LBoolSupplier> supplier)` Safe supplier.
`default boolean`	`shovingGetAsBool()` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`static void`	`times(int max_i, LBoolSupplier func)` From-To.
`default LBoolSupplier`	`toBoolSup(LLogicalOperator after)` Combines two functions together in a order.
`default LByteSupplier`	`toByteSup(LBoolToByteFunction after)` Combines two functions together in a order.
`default LCharSupplier`	`toCharSup(LBoolToCharFunction after)` Combines two functions together in a order.
`default LDblSupplier`	`toDblSup(LBoolToDblFunction after)` Combines two functions together in a order.
`default LFltSupplier`	`toFltSup(LBoolToFltFunction after)` Combines two functions together in a order.
`default LIntSupplier`	`toIntSup(LBoolToIntFunction after)` Combines two functions together in a order.
`default LLongSupplier`	`toLongSup(LBoolToLongFunction after)` Combines two functions together in a order.
`default LSrtSupplier`	`toSrtSup(LBoolToSrtFunction after)` Combines two functions together in a order.
`default <V> LSupplier<V>`	`toSup(LBoolFunction<? extends V> after)` Combines two functions together in a order.
`static boolean`	`tryGetAsBool(LBoolSupplier func)`
`static boolean`	`tryGetAsBool(LBoolSupplier func, ExWF<RuntimeException> exF)`
`static boolean`	`tryGetAsBool(LBoolSupplier func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static boolean`	`tryGetAsBoolThen(LBoolSupplier func, LPredicate<Throwable> handler)`
`default LBoolSupplier`	`trying(ExWF<RuntimeException> exF)`
`default LBoolSupplier`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LBoolSupplier`	`tryingThen(LPredicate<Throwable> handler)`
`default boolean`	`tupleGetAsBool(LTuple.Void args)`
`static LBoolSupplier`	`wrap(java.util.function.BooleanSupplier 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

getAsBoolean
```
@Deprecated
default boolean getAsBoolean()
```
Deprecated. Calling this method via LBoolSupplier interface should be discouraged.

Default implementation for JRE method that calls exception nesting method.

Specified by:

getAsBoolean in interface java.util.function.BooleanSupplier

getAsBool
```
default boolean getAsBool()
```

getAsBoolX
```
boolean getAsBoolX()
            throws Throwable
```
Implement this, but call getAsBool()

Throws:

Throwable

tupleGetAsBool

default boolean tupleGetAsBool(LTuple.Void args)

handlingGetAsBool

default boolean handlingGetAsBool(HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

getAsBool

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

trying

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

getAsBool

default boolean getAsBool(@Nonnull
                          ExWF<RuntimeException> exF)

trying

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

getAsBoolThen

default boolean getAsBoolThen(@Nonnull
                              LPredicate<Throwable> handler)

tryingThen

default LBoolSupplier tryingThen(@Nonnull
                                 LPredicate<Throwable> handler)

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

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

handlingGetAsBool

static boolean handlingGetAsBool(LBoolSupplier func,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

tryGetAsBool

static boolean tryGetAsBool(LBoolSupplier func)

tryGetAsBool

static boolean tryGetAsBool(LBoolSupplier func,
                            @Nonnull
                            ExWMF<RuntimeException> exF,
                            @Nonnull
                            String newMessage,
                            @Nullable
                            Object... messageParams)

tryGetAsBool

static boolean tryGetAsBool(LBoolSupplier func,
                            @Nonnull
                            ExWF<RuntimeException> exF)

tryGetAsBoolThen

static boolean tryGetAsBoolThen(LBoolSupplier func,
                                @Nonnull
                                LPredicate<Throwable> handler)

failSafeGetAsBool

default boolean failSafeGetAsBool(@Nonnull
                                  LBoolSupplier failSafe)

failSafeGetAsBool

static boolean failSafeGetAsBool(LBoolSupplier func,
                                 @Nonnull
                                 LBoolSupplier failSafe)

failSafe

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

nonNullGetAsBool
```
default boolean nonNullGetAsBool()
```
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,
                   LBoolSupplier func)

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

fromTill

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

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

times

static void times(int max_i,
                  LBoolSupplier func)

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

of
```
static LBoolSupplier of(boolean r)
```
Creates function that always returns the same value.

boolSup

@Nonnull
static LBoolSupplier boolSup(@Nonnull
                                       LBoolSupplier lambda)

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

recursive

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

boolSupThrowing

@Nonnull
static LBoolSupplier boolSupThrowing(@Nonnull
                                               ExF<Throwable> exF)

boolSupThrowing

@Nonnull
static LBoolSupplier boolSupThrowing(String message,
                                               @Nonnull
                                               ExMF<Throwable> exF)

call

static boolean call(@Nonnull
                    LBoolSupplier lambda)

wrap

@Nonnull
static LBoolSupplier wrap(java.util.function.BooleanSupplier other)

Wraps JRE instance.

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

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

safe

@Nonnull
static LBoolSupplier safe(@Nullable
                                    LBoolSupplier other)

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

safeSupplier

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

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