java.lang.Object
- life.expert.common.reactivestreams.Preconditions

public final class Preconditions
extends java.lang.Object

service (static class)


               Preconditions.compute();
               var s=Preconditions.MY_CONSTANT;
 *****

Constructor Summary

Constructors
Constructor Description

Preconditions()

Method Summary

Modifier and Type	Method	Description
`static <T1,T2> reactor.core.publisher.Mono<io.vavr.Tuple2<T1,T2>>`	`checkArgument(io.vavr.Tuple2<T1,T2> tuple, java.util.function.BiPredicate<T1,T2> predicate, java.lang.String message)`	Check argument mono.
`static <T1,T2,T3> reactor.core.publisher.Mono<io.vavr.Tuple3<T1,T2,T3>>`	`checkArgument(io.vavr.Tuple3<T1,T2,T3> tuple, reactor.function.Predicate3<T1,T2,T3> predicate, java.lang.String message)`	Check argument mono.
`static <T1,T2,T3,T4> reactor.core.publisher.Mono<io.vavr.Tuple4<T1,T2,T3,T4>>`	`checkArgument(io.vavr.Tuple4<T1,T2,T3,T4> tuple, reactor.function.Predicate4<T1,T2,T3,T4> predicate, java.lang.String message)`	Check argument mono.
`static <T1,T2,T3,T4,T5> reactor.core.publisher.Mono<io.vavr.Tuple5<T1,T2,T3,T4,T5>>`	`checkArgument(io.vavr.Tuple5<T1,T2,T3,T4,T5> tuple, reactor.function.Predicate5<T1,T2,T3,T4,T5> predicate, java.lang.String message)`	Check argument mono.
`static <T1,T2,T3,T4,T5,T6> reactor.core.publisher.Mono<io.vavr.Tuple6<T1,T2,T3,T4,T5,T6>>`	`checkArgument(io.vavr.Tuple6<T1,T2,T3,T4,T5,T6> tuple, reactor.function.Predicate6<T1,T2,T3,T4,T5,T6> predicate, java.lang.String message)`	Check argument mono.
`static <T1,T2,T3,T4,T5,T6,T7> reactor.core.publisher.Mono<io.vavr.Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	`checkArgument(io.vavr.Tuple7<T1,T2,T3,T4,T5,T6,T7> tuple, reactor.function.Predicate7<T1,T2,T3,T4,T5,T6,T7> predicate, java.lang.String message)`	Check argument mono.
`static <T1,T2,T3,T4,T5,T6,T7,T8> reactor.core.publisher.Mono<io.vavr.Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`checkArgument(io.vavr.Tuple8<T1,T2,T3,T4,T5,T6,T7,T8> tuple, reactor.function.Predicate8<T1,T2,T3,T4,T5,T6,T7,T8> predicate, java.lang.String message)`	Check 8 arguments and invoke some function.
`static <T1,T2> reactor.core.publisher.Mono<io.vavr.Tuple2<T1,T2>>`	`checkArgument(T1 argument1, T2 argument2, java.util.function.BiPredicate<T1,T2> predicate, java.lang.String message)`	Checking 2 arguments with predicate (usual test for empty elements) If argument is null then event with Tuple(null..
`static <T1,T2,T3> reactor.core.publisher.Mono<io.vavr.Tuple3<T1,T2,T3>>`	`checkArgument(T1 argument1, T2 argument2, T3 argument3, reactor.function.Predicate3<T1,T2,T3> predicate, java.lang.String message)`	Checking 3 arguments with predicate (usual test for empty elements) * If argument is null then event with Tuple(null..
`static <T1,T2,T3,T4> reactor.core.publisher.Mono<io.vavr.Tuple4<T1,T2,T3,T4>>`	`checkArgument(T1 argument1, T2 argument2, T3 argument3, T4 argument4, reactor.function.Predicate4<T1,T2,T3,T4> predicate, java.lang.String message)`	Checking 4 arguments with predicate (usual test for empty elements) * If argument is null then event with Tuple(null..
`static <T1,T2,T3,T4,T5> reactor.core.publisher.Mono<io.vavr.Tuple5<T1,T2,T3,T4,T5>>`	`checkArgument(T1 argument1, T2 argument2, T3 argument3, T4 argument4, T5 argument5, reactor.function.Predicate5<T1,T2,T3,T4,T5> predicate, java.lang.String message)`	Checking 5 arguments with predicate (usual test for empty elements) * If argument is null then event with Tuple(null..
`static <T1,T2,T3,T4,T5,T6> reactor.core.publisher.Mono<io.vavr.Tuple6<T1,T2,T3,T4,T5,T6>>`	`checkArgument(T1 argument1, T2 argument2, T3 argument3, T4 argument4, T5 argument5, T6 argument6, reactor.function.Predicate6<T1,T2,T3,T4,T5,T6> predicate, java.lang.String message)`	Checking 6 arguments with predicate (usual test for empty elements) * If argument is null then event with Tuple(null..
`static <T1,T2,T3,T4,T5,T6,T7> reactor.core.publisher.Mono<io.vavr.Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	`checkArgument(T1 argument1, T2 argument2, T3 argument3, T4 argument4, T5 argument5, T6 argument6, T7 argument7, reactor.function.Predicate7<T1,T2,T3,T4,T5,T6,T7> predicate, java.lang.String message)`	Checking 7 arguments with predicate (usual test for empty elements) * If argument is null then event with Tuple(null..
`static <T1,T2,T3,T4,T5,T6,T7,T8> reactor.core.publisher.Mono<io.vavr.Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`checkArgument(T1 argument1, T2 argument2, T3 argument3, T4 argument4, T5 argument5, T6 argument6, T7 argument7, T8 argument8, reactor.function.Predicate8<T1,T2,T3,T4,T5,T6,T7,T8> predicate, java.lang.String message)`	Checking 8 arguments with predicate (usual test for empty elements) * If argument is null then event with Tuple(null..
`static <T> reactor.core.publisher.Mono<T>`	`checkArgument(T argument, java.util.function.Predicate<T> predicate)`	Check argument mono.
`static <T> reactor.core.publisher.Mono<T>`	`checkArgument(T argument, java.util.function.Predicate<T> predicate, java.lang.String message)`	Checking argument with predicate (usual test for empty elements) If argument is null then empty event Wrap error as event
`static <T1,T2,R> reactor.core.publisher.Mono<R>`	`checkArgumentAndMap(T1 argument1, T2 argument2, java.util.function.BiPredicate<T1,T2> predicate, java.lang.String message, java.util.function.BiFunction<T1,T2,R> function)`	Check 2 arguments and invoke some function.
`static <T1,T2,T3,R> reactor.core.publisher.Mono<R>`	`checkArgumentAndMap(T1 argument1, T2 argument2, T3 argument3, reactor.function.Predicate3<T1,T2,T3> predicate, java.lang.String message, reactor.function.Function3<T1,T2,T3,R> function)`	Check 3 arguments and invoke some function.
`static <T1,T2,T3,T4,R> reactor.core.publisher.Mono<R>`	`checkArgumentAndMap(T1 argument1, T2 argument2, T3 argument3, T4 argument4, reactor.function.Predicate4<T1,T2,T3,T4> predicate, java.lang.String message, reactor.function.Function4<T1,T2,T3,T4,R> function)`	Check 4 arguments and invoke some function.
`static <T1,T2,T3,T4,T5,R> reactor.core.publisher.Mono<R>`	`checkArgumentAndMap(T1 argument1, T2 argument2, T3 argument3, T4 argument4, T5 argument5, reactor.function.Predicate5<T1,T2,T3,T4,T5> predicate, java.lang.String message, reactor.function.Function5<T1,T2,T3,T4,T5,R> function)`	Check 5 arguments and invoke some function.
`static <T1,T2,T3,T4,T5,T6,R> reactor.core.publisher.Mono<R>`	`checkArgumentAndMap(T1 argument1, T2 argument2, T3 argument3, T4 argument4, T5 argument5, T6 argument6, reactor.function.Predicate6<T1,T2,T3,T4,T5,T6> predicate, java.lang.String message, reactor.function.Function6<T1,T2,T3,T4,T5,T6,R> function)`	Check 6 arguments and invoke some function.
`static <T1,T2,T3,T4,T5,T6,T7,R> reactor.core.publisher.Mono<R>`	`checkArgumentAndMap(T1 argument1, T2 argument2, T3 argument3, T4 argument4, T5 argument5, T6 argument6, T7 argument7, reactor.function.Predicate7<T1,T2,T3,T4,T5,T6,T7> predicate, java.lang.String message, reactor.function.Function7<T1,T2,T3,T4,T5,T6,T7,R> function)`	Check 7 arguments and invoke some function.
`static <T1,T2,T3,T4,T5,T6,T7,T8,R> reactor.core.publisher.Mono<R>`	`checkArgumentAndMap(T1 argument1, T2 argument2, T3 argument3, T4 argument4, T5 argument5, T6 argument6, T7 argument7, T8 argument8, reactor.function.Predicate8<T1,T2,T3,T4,T5,T6,T7,T8> predicate, java.lang.String message, reactor.function.Function8<T1,T2,T3,T4,T5,T6,T7,T8,R> function)`	Check argument and map mono.
`static <T,R> reactor.core.publisher.Mono<R>`	`checkArgumentAndMap(T argument, java.util.function.Predicate<T> predicate, java.lang.String message, java.util.function.Function<T,R> function)`	Check argument and invoke some function.
`static <T> reactor.core.publisher.Mono<T>`	`checkFalse(boolean condition)`	Check false mono.
`static <T> reactor.core.publisher.Mono<T>`	`checkFalse(boolean condition, java.lang.String message)`	Chec false mono.
`static <T> reactor.core.publisher.Mono<T>`	`checkNotNull(T argument)`	Check not null mono.
`static <T> reactor.core.publisher.Mono<T>`	`checkNotNull(T argument, java.lang.String message)`	Check not null mono.
`static <T> reactor.core.publisher.Mono<T>`	`checkTrue(boolean condition)`	Check true mono.
`static <T> reactor.core.publisher.Mono<T>`	`checkTrue(boolean condition, java.lang.String message)`	Check true mono.
`static <T> reactor.core.publisher.Flux<T>`	`illegalArgumentError()`	Only when subscription, lazily produce Flux.error with IllegalArgumentException()
`static <T> reactor.core.publisher.Flux<T>`	`illegalArgumentError(java.lang.String description)`	Only when subscription, lazily produce Flux.error with IllegalArgumentException(description)
`static <T> reactor.core.publisher.Flux<T>`	`illegalArgumentError(java.lang.String description, java.lang.Throwable cause)`	Only when subscription, lazily produce Flux.error with IllegalArgumentException(description,cause)
`static <T> reactor.core.publisher.Mono<T>`	`illegalArgumentMonoError()`	Only when subscription, lazily produce Mono.error with IllegalArgumentException()
`static <T> reactor.core.publisher.Mono<T>`	`illegalArgumentMonoError(java.lang.String description)`	Only when subscription, lazily produce Mono.error with IllegalArgumentException(description)
`static <T> reactor.core.publisher.Mono<T>`	`illegalArgumentMonoError(java.lang.String description, java.lang.Throwable cause)`	Only when subscription, lazily produce Mono.error with IllegalArgumentException(description,cause)
`static <T> reactor.core.publisher.Flux<T>`	`illegalStateError()`	Only when subscription, lazily produce Flux.error with IllegalStateException()
`static <T> reactor.core.publisher.Flux<T>`	`illegalStateError(java.lang.String description)`	Only when subscription, lazily produce Flux.error with IllegalStateException(description)
`static <T> reactor.core.publisher.Flux<T>`	`illegalStateError(java.lang.String description, java.lang.Throwable cause)`	Only when subscription, lazily produce Flux.error with IllegalStateException(description,cause)
`static <T> reactor.core.publisher.Mono<T>`	`illegalStateMonoError()`	Only when subscription, lazily produce Mono.error with IllegalStateException()
`static <T> reactor.core.publisher.Mono<T>`	`illegalStateMonoError(java.lang.String description)`	Only when subscription, lazily produce Mono.error with IllegalStateException(description)
`static <T> reactor.core.publisher.Mono<T>`	`illegalStateMonoError(java.lang.String description, java.lang.Throwable cause)`	Only when subscription, lazily produce Mono.error with IllegalStateException(description,cause)
`static <T> reactor.core.publisher.Flux<T>`	`nullPointerError()`	Only when subscription, lazily produce Flux.error with NullPointerException
`static <T> reactor.core.publisher.Flux<T>`	`nullPointerError(java.lang.String description)`	Only when subscription, lazily produce Flux.error with NullPointerException(description))
`static <T> reactor.core.publisher.Mono<T>`	`nullPointerMonoError()`	Only when subscription, lazily produce Mono.error with NullPointerException()
`static <T> reactor.core.publisher.Mono<T>`	`nullPointerMonoError(java.lang.String description)`	Only when subscription, lazily produce Mono.error with NullPointerException(description)

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- Preconditions
```
public Preconditions()
```

Method Detail

checkArgument
```
public static <T> reactor.core.publisher.Mono<T> checkArgument(T argument,
                                                               java.util.function.Predicate<T> predicate,
                                                               java.lang.String message)
```
Checking argument with predicate (usual test for empty elements) If argument is null then empty event Wrap error as event

Type Parameters:

T - the type parameter

Parameters:

argument - the argument

predicate - the predicate

message - the message

Returns:

the mono with input argument

checkArgumentAndMap

public static <T,R> reactor.core.publisher.Mono<R> checkArgumentAndMap(T argument,
                                                                             java.util.function.Predicate<T> predicate,
                                                                             java.lang.String message,
                                                                             java.util.function.Function<T,R> function)

Check argument and invoke some function. Helper function when public method is wrapper for private Result must not be null

Type Parameters:: T - the type parameter; R - the type parameter
Parameters:: argument - the argument; predicate - the predicate; message - the message; function - the function
Returns:: the mono with transformed argument

checkArgument

public static <T1,T2> reactor.core.publisher.Mono<io.vavr.Tuple2<T1,T2>> checkArgument(T1 argument1,
                                                                                                   T2 argument2,
                                                                                                   java.util.function.BiPredicate<T1,T2> predicate,
                                                                                                   java.lang.String message)

Checking 2 arguments with predicate (usual test for empty elements) If argument is null then event with Tuple(null.. Wrap error as event

Type Parameters:: T1 - the type parameter; T2 - the type parameter
Parameters:: argument1 - the argument 1; argument2 - the argument 2; predicate - the predicate; message - the message
Returns:: the mono

checkArgumentAndMap

public static <T1,T2,R> reactor.core.publisher.Mono<R> checkArgumentAndMap(T1 argument1,
                                                                                       T2 argument2,
                                                                                       java.util.function.BiPredicate<T1,T2> predicate,
                                                                                       java.lang.String message,
                                                                                       java.util.function.BiFunction<T1,T2,R> function)

Check 2 arguments and invoke some function. Helper function when public method is wrapper for private.

Type Parameters:: T1 - the type parameter; T2 - the type parameter; R - the type parameter
Parameters:: argument1 - the argument 1; argument2 - the argument 2; predicate - the predicate; message - the message; function - the function
Returns:: the mono

checkArgument

public static <T1,T2> reactor.core.publisher.Mono<io.vavr.Tuple2<T1,T2>> checkArgument(io.vavr.Tuple2<T1,T2> tuple,
                                                                                                   java.util.function.BiPredicate<T1,T2> predicate,
                                                                                                   java.lang.String message)

Check argument mono.

Type Parameters:: T1 - the type parameter; T2 - the type parameter
Parameters:: tuple - the tuple; predicate - the predicate; message - the message
Returns:: the mono

checkArgument

public static <T1,T2,T3> reactor.core.publisher.Mono<io.vavr.Tuple3<T1,T2,T3>> checkArgument(T1 argument1,
                                                                                                                     T2 argument2,
                                                                                                                     T3 argument3,
                                                                                                                     reactor.function.Predicate3<T1,T2,T3> predicate,
                                                                                                                     java.lang.String message)

Checking 3 arguments with predicate (usual test for empty elements) * If argument is null then event with Tuple(null.. Wrap error as event

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter
Parameters:: argument1 - the argument 1; argument2 - the argument 2; argument3 - the argument 3; predicate - the predicate; message - the message
Returns:: the mono

checkArgumentAndMap

public static <T1,T2,T3,R> reactor.core.publisher.Mono<R> checkArgumentAndMap(T1 argument1,
                                                                                                T2 argument2,
                                                                                                T3 argument3,
                                                                                                reactor.function.Predicate3<T1,T2,T3> predicate,
                                                                                                java.lang.String message,
                                                                                                reactor.function.Function3<T1,T2,T3,R> function)

Check 3 arguments and invoke some function. Helper function when public method is wrapper for private.

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; R - the type parameter
Parameters:: argument1 - the argument 1; argument2 - the argument 2; argument3 - the argument 3; predicate - the predicate; message - the message; function - the function
Returns:: the mono

checkArgument

public static <T1,T2,T3> reactor.core.publisher.Mono<io.vavr.Tuple3<T1,T2,T3>> checkArgument(io.vavr.Tuple3<T1,T2,T3> tuple,
                                                                                                                     reactor.function.Predicate3<T1,T2,T3> predicate,
                                                                                                                     java.lang.String message)

Check argument mono.

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter
Parameters:: tuple - the tuple; predicate - the predicate; message - the message
Returns:: the mono

checkArgument

public static <T1,T2,T3,T4> reactor.core.publisher.Mono<io.vavr.Tuple4<T1,T2,T3,T4>> checkArgument(T1 argument1,
                                                                                                                                       T2 argument2,
                                                                                                                                       T3 argument3,
                                                                                                                                       T4 argument4,
                                                                                                                                       reactor.function.Predicate4<T1,T2,T3,T4> predicate,
                                                                                                                                       java.lang.String message)

Checking 4 arguments with predicate (usual test for empty elements) * If argument is null then event with Tuple(null.. Wrap error as event

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; T4 - the type parameter
Parameters:: argument1 - the argument 1; argument2 - the argument 2; argument3 - the argument 3; argument4 - the argument 4; predicate - the predicate; message - the message
Returns:: the mono

checkArgumentAndMap

public static <T1,T2,T3,T4,R> reactor.core.publisher.Mono<R> checkArgumentAndMap(T1 argument1,
                                                                                                         T2 argument2,
                                                                                                         T3 argument3,
                                                                                                         T4 argument4,
                                                                                                         reactor.function.Predicate4<T1,T2,T3,T4> predicate,
                                                                                                         java.lang.String message,
                                                                                                         reactor.function.Function4<T1,T2,T3,T4,R> function)

Check 4 arguments and invoke some function. Helper function when public method is wrapper for private.

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; T4 - the type parameter; R - the type parameter
Parameters:: argument1 - the argument 1; argument2 - the argument 2; argument3 - the argument 3; argument4 - the argument 4; predicate - the predicate; message - the message; function - the function
Returns:: the mono

checkArgument

public static <T1,T2,T3,T4> reactor.core.publisher.Mono<io.vavr.Tuple4<T1,T2,T3,T4>> checkArgument(io.vavr.Tuple4<T1,T2,T3,T4> tuple,
                                                                                                                                       reactor.function.Predicate4<T1,T2,T3,T4> predicate,
                                                                                                                                       java.lang.String message)

Check argument mono.

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; T4 - the type parameter
Parameters:: tuple - the tuple; predicate - the predicate; message - the message
Returns:: the mono

checkArgument

public static <T1,T2,T3,T4,T5> reactor.core.publisher.Mono<io.vavr.Tuple5<T1,T2,T3,T4,T5>> checkArgument(T1 argument1,
                                                                                                                                                         T2 argument2,
                                                                                                                                                         T3 argument3,
                                                                                                                                                         T4 argument4,
                                                                                                                                                         T5 argument5,
                                                                                                                                                         reactor.function.Predicate5<T1,T2,T3,T4,T5> predicate,
                                                                                                                                                         java.lang.String message)

Checking 5 arguments with predicate (usual test for empty elements) * If argument is null then event with Tuple(null.. Wrap error as event

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; T4 - the type parameter; T5 - the type parameter
Parameters:: argument1 - the argument 1; argument2 - the argument 2; argument3 - the argument 3; argument4 - the argument 4; argument5 - the argument 5; predicate - the predicate; message - the message
Returns:: the mono

checkArgumentAndMap

public static <T1,T2,T3,T4,T5,R> reactor.core.publisher.Mono<R> checkArgumentAndMap(T1 argument1,
                                                                                                                  T2 argument2,
                                                                                                                  T3 argument3,
                                                                                                                  T4 argument4,
                                                                                                                  T5 argument5,
                                                                                                                  reactor.function.Predicate5<T1,T2,T3,T4,T5> predicate,
                                                                                                                  java.lang.String message,
                                                                                                                  reactor.function.Function5<T1,T2,T3,T4,T5,R> function)

Check 5 arguments and invoke some function. Helper function when public method is wrapper for private.

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; T4 - the type parameter; T5 - the type parameter; R - the type parameter
Parameters:: argument1 - the argument 1; argument2 - the argument 2; argument3 - the argument 3; argument4 - the argument 4; argument5 - the argument 5; predicate - the predicate; message - the message; function - the function
Returns:: the mono

checkArgument

public static <T1,T2,T3,T4,T5> reactor.core.publisher.Mono<io.vavr.Tuple5<T1,T2,T3,T4,T5>> checkArgument(io.vavr.Tuple5<T1,T2,T3,T4,T5> tuple,
                                                                                                                                                         reactor.function.Predicate5<T1,T2,T3,T4,T5> predicate,
                                                                                                                                                         java.lang.String message)

Check argument mono.

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; T4 - the type parameter; T5 - the type parameter
Parameters:: tuple - the tuple; predicate - the predicate; message - the message
Returns:: the mono

checkArgument

public static <T1,T2,T3,T4,T5,T6> reactor.core.publisher.Mono<io.vavr.Tuple6<T1,T2,T3,T4,T5,T6>> checkArgument(T1 argument1,
                                                                                                                                                                           T2 argument2,
                                                                                                                                                                           T3 argument3,
                                                                                                                                                                           T4 argument4,
                                                                                                                                                                           T5 argument5,
                                                                                                                                                                           T6 argument6,
                                                                                                                                                                           reactor.function.Predicate6<T1,T2,T3,T4,T5,T6> predicate,
                                                                                                                                                                           java.lang.String message)

Checking 6 arguments with predicate (usual test for empty elements) * If argument is null then event with Tuple(null.. Wrap error as event

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; T4 - the type parameter; T5 - the type parameter; T6 - the type parameter
Parameters:: argument1 - the argument 1; argument2 - the argument 2; argument3 - the argument 3; argument4 - the argument 4; argument5 - the argument 5; argument6 - the argument 6; predicate - the predicate; message - the message
Returns:: the mono

checkArgumentAndMap

public static <T1,T2,T3,T4,T5,T6,R> reactor.core.publisher.Mono<R> checkArgumentAndMap(T1 argument1,
                                                                                                                           T2 argument2,
                                                                                                                           T3 argument3,
                                                                                                                           T4 argument4,
                                                                                                                           T5 argument5,
                                                                                                                           T6 argument6,
                                                                                                                           reactor.function.Predicate6<T1,T2,T3,T4,T5,T6> predicate,
                                                                                                                           java.lang.String message,
                                                                                                                           reactor.function.Function6<T1,T2,T3,T4,T5,T6,R> function)

Check 6 arguments and invoke some function. Helper function when public method is wrapper for private.

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; T4 - the type parameter; T5 - the type parameter; T6 - the type parameter; R - the type parameter
Parameters:: argument1 - the argument 1; argument2 - the argument 2; argument3 - the argument 3; argument4 - the argument 4; argument5 - the argument 5; argument6 - the argument 6; predicate - the predicate; message - the message; function - the function
Returns:: the mono

checkArgument

public static <T1,T2,T3,T4,T5,T6> reactor.core.publisher.Mono<io.vavr.Tuple6<T1,T2,T3,T4,T5,T6>> checkArgument(io.vavr.Tuple6<T1,T2,T3,T4,T5,T6> tuple,
                                                                                                                                                                           reactor.function.Predicate6<T1,T2,T3,T4,T5,T6> predicate,
                                                                                                                                                                           java.lang.String message)

Check argument mono.

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; T4 - the type parameter; T5 - the type parameter; T6 - the type parameter
Parameters:: tuple - the tuple; predicate - the predicate; message - the message
Returns:: the mono

checkArgument

public static <T1,T2,T3,T4,T5,T6,T7> reactor.core.publisher.Mono<io.vavr.Tuple7<T1,T2,T3,T4,T5,T6,T7>> checkArgument(T1 argument1,
                                                                                                                                                                                             T2 argument2,
                                                                                                                                                                                             T3 argument3,
                                                                                                                                                                                             T4 argument4,
                                                                                                                                                                                             T5 argument5,
                                                                                                                                                                                             T6 argument6,
                                                                                                                                                                                             T7 argument7,
                                                                                                                                                                                             reactor.function.Predicate7<T1,T2,T3,T4,T5,T6,T7> predicate,
                                                                                                                                                                                             java.lang.String message)

Checking 7 arguments with predicate (usual test for empty elements) * If argument is null then event with Tuple(null.. Wrap error as event

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; T4 - the type parameter; T5 - the type parameter; T6 - the type parameter; T7 - the type parameter
Parameters:: argument1 - the argument 1; argument2 - the argument 2; argument3 - the argument 3; argument4 - the argument 4; argument5 - the argument 5; argument6 - the argument 6; argument7 - the argument 7; predicate - the predicate; message - the message
Returns:: the mono

checkArgumentAndMap

public static <T1,T2,T3,T4,T5,T6,T7,R> reactor.core.publisher.Mono<R> checkArgumentAndMap(T1 argument1,
                                                                                                                                    T2 argument2,
                                                                                                                                    T3 argument3,
                                                                                                                                    T4 argument4,
                                                                                                                                    T5 argument5,
                                                                                                                                    T6 argument6,
                                                                                                                                    T7 argument7,
                                                                                                                                    reactor.function.Predicate7<T1,T2,T3,T4,T5,T6,T7> predicate,
                                                                                                                                    java.lang.String message,
                                                                                                                                    reactor.function.Function7<T1,T2,T3,T4,T5,T6,T7,R> function)

Check 7 arguments and invoke some function. Helper function when public method is wrapper for private.

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; T4 - the type parameter; T5 - the type parameter; T6 - the type parameter; T7 - the type parameter; R - the type parameter
Parameters:: argument1 - the argument 1; argument2 - the argument 2; argument3 - the argument 3; argument4 - the argument 4; argument5 - the argument 5; argument6 - the argument 6; argument7 - the argument 7; predicate - the predicate; message - the message; function - the function
Returns:: the mono

checkArgument

public static <T1,T2,T3,T4,T5,T6,T7> reactor.core.publisher.Mono<io.vavr.Tuple7<T1,T2,T3,T4,T5,T6,T7>> checkArgument(io.vavr.Tuple7<T1,T2,T3,T4,T5,T6,T7> tuple,
                                                                                                                                                                                             reactor.function.Predicate7<T1,T2,T3,T4,T5,T6,T7> predicate,
                                                                                                                                                                                             java.lang.String message)

Check argument mono.

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; T4 - the type parameter; T5 - the type parameter; T6 - the type parameter; T7 - the type parameter
Parameters:: tuple - the tuple; predicate - the predicate; message - the message
Returns:: the mono

checkArgument

public static <T1,T2,T3,T4,T5,T6,T7,T8> reactor.core.publisher.Mono<io.vavr.Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>> checkArgument(T1 argument1,
                                                                                                                                                                                                               T2 argument2,
                                                                                                                                                                                                               T3 argument3,
                                                                                                                                                                                                               T4 argument4,
                                                                                                                                                                                                               T5 argument5,
                                                                                                                                                                                                               T6 argument6,
                                                                                                                                                                                                               T7 argument7,
                                                                                                                                                                                                               T8 argument8,
                                                                                                                                                                                                               reactor.function.Predicate8<T1,T2,T3,T4,T5,T6,T7,T8> predicate,
                                                                                                                                                                                                               java.lang.String message)

Checking 8 arguments with predicate (usual test for empty elements) * If argument is null then event with Tuple(null.. Wrap error as event

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; T4 - the type parameter; T5 - the type parameter; T6 - the type parameter; T7 - the type parameter; T8 - the type parameter
Parameters:: argument1 - the argument 1; argument2 - the argument 2; argument3 - the argument 3; argument4 - the argument 4; argument5 - the argument 5; argument6 - the argument 6; argument7 - the argument 7; argument8 - the argument 8; predicate - the predicate; message - the message
Returns:: the mono

checkArgumentAndMap

public static <T1,T2,T3,T4,T5,T6,T7,T8,R> reactor.core.publisher.Mono<R> checkArgumentAndMap(T1 argument1,
                                                                                                                                             T2 argument2,
                                                                                                                                             T3 argument3,
                                                                                                                                             T4 argument4,
                                                                                                                                             T5 argument5,
                                                                                                                                             T6 argument6,
                                                                                                                                             T7 argument7,
                                                                                                                                             T8 argument8,
                                                                                                                                             reactor.function.Predicate8<T1,T2,T3,T4,T5,T6,T7,T8> predicate,
                                                                                                                                             java.lang.String message,
                                                                                                                                             reactor.function.Function8<T1,T2,T3,T4,T5,T6,T7,T8,R> function)

Check argument and map mono.

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; T4 - the type parameter; T5 - the type parameter; T6 - the type parameter; T7 - the type parameter; T8 - the type parameter; R - the type parameter
Parameters:: argument1 - the argument 1; argument2 - the argument 2; argument3 - the argument 3; argument4 - the argument 4; argument5 - the argument 5; argument6 - the argument 6; argument7 - the argument 7; argument8 - the argument 8; predicate - the predicate; message - the message; function - the function
Returns:: the mono

checkArgument

public static <T1,T2,T3,T4,T5,T6,T7,T8> reactor.core.publisher.Mono<io.vavr.Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>> checkArgument(io.vavr.Tuple8<T1,T2,T3,T4,T5,T6,T7,T8> tuple,
                                                                                                                                                                                                               reactor.function.Predicate8<T1,T2,T3,T4,T5,T6,T7,T8> predicate,
                                                                                                                                                                                                               java.lang.String message)

Check 8 arguments and invoke some function. Helper function when public method is wrapper for private.

Type Parameters:: T1 - the type parameter; T2 - the type parameter; T3 - the type parameter; T4 - the type parameter; T5 - the type parameter; T6 - the type parameter; T7 - the type parameter; T8 - the type parameter
Parameters:: tuple - the tuple; predicate - the predicate; message - the message
Returns:: the mono

checkArgument

public static <T> reactor.core.publisher.Mono<T> checkArgument(T argument,
                                                               java.util.function.Predicate<T> predicate)

Check argument mono.

Type Parameters:: T - the type parameter
Parameters:: argument - the argument; predicate - the predicate
Returns:: the mono

checkTrue
```
public static <T> reactor.core.publisher.Mono<T> checkTrue(boolean condition)
```
Check true mono.

Type Parameters:

T - the type parameter

Parameters:

condition - the condition

Returns:

the mono

checkTrue

public static <T> reactor.core.publisher.Mono<T> checkTrue(boolean condition,
                                                           java.lang.String message)

Check true mono.

Type Parameters:: T - the type parameter
Parameters:: condition - the condition; message - the message
Returns:: the mono

checkFalse
```
public static <T> reactor.core.publisher.Mono<T> checkFalse(boolean condition)
```
Check false mono.

Type Parameters:

T - the type parameter

Parameters:

condition - the condition

Returns:

the mono

checkFalse

public static <T> reactor.core.publisher.Mono<T> checkFalse(boolean condition,
                                                            java.lang.String message)

Chec false mono.

Type Parameters:: T - the type parameter
Parameters:: condition - the condition; message - the message
Returns:: the mono

checkNotNull

public static <T> reactor.core.publisher.Mono<T> checkNotNull(T argument,
                                                              java.lang.String message)

Check not null mono.

Type Parameters:: T - the type parameter
Parameters:: argument - the argument; message - the message
Returns:: the mono

checkNotNull
```
public static <T> reactor.core.publisher.Mono<T> checkNotNull(T argument)
```
Check not null mono.

Type Parameters:

T - the type parameter

Parameters:

argument - the argument

Returns:

the mono

nullPointerError
```
public static <T> reactor.core.publisher.Flux<T> nullPointerError()
```
Only when subscription, lazily produce Flux.error with NullPointerException

Type Parameters:

T - Component type of the Flux.

Returns:

Flux with error event.

nullPointerError
```
public static <T> reactor.core.publisher.Flux<T> nullPointerError(java.lang.String description)
```
Only when subscription, lazily produce Flux.error with NullPointerException(description))

Type Parameters:

T - Component type of the Flux.

Parameters:

description - the description

Returns:

Flux with error event.

illegalArgumentError
```
public static <T> reactor.core.publisher.Flux<T> illegalArgumentError()
```
Only when subscription, lazily produce Flux.error with IllegalArgumentException()

Type Parameters:

T - Component type of the Flux.

Returns:

Flux with error event.

illegalArgumentError
```
public static <T> reactor.core.publisher.Flux<T> illegalArgumentError(java.lang.String description)
```
Only when subscription, lazily produce Flux.error with IllegalArgumentException(description)

Type Parameters:

T - Component type of the Flux.

Parameters:

description - the description

Returns:

Flux with error event.

illegalArgumentError
```
public static <T> reactor.core.publisher.Flux<T> illegalArgumentError(java.lang.String description,
                                                                      java.lang.Throwable cause)
```
Only when subscription, lazily produce Flux.error with IllegalArgumentException(description,cause)

Type Parameters:

T - Component type of the Flux.

Parameters:

description - the description

cause - the cause

Returns:

Flux with error event.

illegalStateError
```
public static <T> reactor.core.publisher.Flux<T> illegalStateError()
```
Only when subscription, lazily produce Flux.error with IllegalStateException()

Type Parameters:

T - Component type of the Flux.

Returns:

Flux with error event.

illegalStateError
```
public static <T> reactor.core.publisher.Flux<T> illegalStateError(java.lang.String description)
```
Only when subscription, lazily produce Flux.error with IllegalStateException(description)

Type Parameters:

T - Component type of the Flux.

Parameters:

description - the description

Returns:

Flux with error event.

illegalStateError
```
public static <T> reactor.core.publisher.Flux<T> illegalStateError(java.lang.String description,
                                                                   java.lang.Throwable cause)
```
Only when subscription, lazily produce Flux.error with IllegalStateException(description,cause)

Type Parameters:

T - Component type of the Flux.

Parameters:

description - the description

cause - the cause

Returns:

Flux with error event.

nullPointerMonoError
```
public static <T> reactor.core.publisher.Mono<T> nullPointerMonoError()
```
Only when subscription, lazily produce Mono.error with NullPointerException()

Type Parameters:

T - Component type of the Mono.

Returns:

Mono with error event.

nullPointerMonoError
```
public static <T> reactor.core.publisher.Mono<T> nullPointerMonoError(java.lang.String description)
```
Only when subscription, lazily produce Mono.error with NullPointerException(description)

Type Parameters:

T - Component type of the Mono.

Parameters:

description - the description

Returns:

Mono with error event.

illegalArgumentMonoError
```
public static <T> reactor.core.publisher.Mono<T> illegalArgumentMonoError()
```
Only when subscription, lazily produce Mono.error with IllegalArgumentException()

Type Parameters:

T - Component type of the Mono.

Returns:

Mono with error event.

illegalArgumentMonoError
```
public static <T> reactor.core.publisher.Mono<T> illegalArgumentMonoError(java.lang.String description)
```
Only when subscription, lazily produce Mono.error with IllegalArgumentException(description)

Type Parameters:

T - Component type of the Mono.

Parameters:

description - the description

Returns:

Mono with error event.

illegalArgumentMonoError
```
public static <T> reactor.core.publisher.Mono<T> illegalArgumentMonoError(java.lang.String description,
                                                                          java.lang.Throwable cause)
```
Only when subscription, lazily produce Mono.error with IllegalArgumentException(description,cause)

Type Parameters:

T - Component type of the Mono.

Parameters:

description - the description

cause - the cause

Returns:

Mono with error event.

illegalStateMonoError
```
public static <T> reactor.core.publisher.Mono<T> illegalStateMonoError()
```
Only when subscription, lazily produce Mono.error with IllegalStateException()

Type Parameters:

T - Component type of the Mono.

Returns:

Mono with error event.

illegalStateMonoError
```
public static <T> reactor.core.publisher.Mono<T> illegalStateMonoError(java.lang.String description)
```
Only when subscription, lazily produce Mono.error with IllegalStateException(description)

Type Parameters:

T - Component type of the Mono.

Parameters:

description - the description

Returns:

Mono with error event.

illegalStateMonoError
```
public static <T> reactor.core.publisher.Mono<T> illegalStateMonoError(java.lang.String description,
                                                                       java.lang.Throwable cause)
```
Only when subscription, lazily produce Mono.error with IllegalStateException(description,cause)

Type Parameters:

T - Component type of the Mono.

Parameters:

description - the description

cause - the cause

Returns:

Mono with error event.

Class Preconditions

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Preconditions

Method Detail

checkArgument

checkArgumentAndMap

checkArgument

checkArgumentAndMap

checkArgument

checkArgument

checkArgumentAndMap

checkArgument

checkArgument

checkArgumentAndMap

checkArgument

checkArgument

checkArgumentAndMap

checkArgument

checkArgument

checkArgumentAndMap

checkArgument

checkArgument

checkArgumentAndMap

checkArgument

checkArgument

checkArgumentAndMap

checkArgument

checkArgument

checkTrue

checkTrue

checkFalse

checkFalse

checkNotNull

checkNotNull

nullPointerError

nullPointerError

illegalArgumentError

illegalArgumentError

illegalArgumentError

illegalStateError

illegalStateError

illegalStateError

nullPointerMonoError

nullPointerMonoError

illegalArgumentMonoError

illegalArgumentMonoError

illegalArgumentMonoError

illegalStateMonoError

illegalStateMonoError

illegalStateMonoError