com.aol.cyclops.reactor

Class Monos

java.lang.Object

com.aol.cyclops.reactor.Monos

public class Monos
extends java.lang.Object

Companion class for working with Reactor Mono types

Constructor Summary

Constructors

Constructor and Description
Monos()

Method Summary

Modifier and Type	Method and Description
static <T> AnyMValue<T>	anyM(reactor.core.publisher.Mono<T> mono) Construct an AnyM type from a Mono.
static <T1,T2,R> reactor.core.publisher.Mono<R>	combine(reactor.core.publisher.Mono<? extends T1> mono, reactor.core.publisher.Mono<? extends T2> app, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn) Lazily combine this Mono with the supplied Mono via the supplied BiFunction
static <T1,T2,R> reactor.core.publisher.Mono<R>	combine(reactor.core.publisher.Mono<? extends T1> mono, Value<? extends T2> app, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn) Lazily combine this Mono with the supplied value via the supplied BiFunction
static <T,R1,R> reactor.core.publisher.Mono<R>	forEach(reactor.core.publisher.Mono<? extends T> value1, java.util.function.Function<? super T,? extends reactor.core.publisher.Mono<R1>> value2, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction) Perform a For Comprehension over a Mono, accepting a generating functions.
static <T,R1,R> reactor.core.publisher.Mono<R>	forEach(reactor.core.publisher.Mono<? extends T> value1, java.util.function.Function<? super T,reactor.core.publisher.Mono<R1>> value2, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction) Perform a For Comprehension over a Mono, accepting a generating function.
static <T1,T2,R1,R2,R> reactor.core.publisher.Mono<R>	forEach3(reactor.core.publisher.Mono<? extends T1> value1, java.util.function.Function<? super T1,? extends reactor.core.publisher.Mono<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends reactor.core.publisher.Mono<R2>> value3, TriFunction<? super T1,? super R1,? super R2,? extends R> yieldingFunction) Perform a For Comprehension over a Mono, accepting 2 generating functions.
static <T1,T2,R1,R2,R> reactor.core.publisher.Mono<R>	forEach3(reactor.core.publisher.Mono<? extends T1> value1, java.util.function.Function<? super T1,? extends reactor.core.publisher.Mono<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends reactor.core.publisher.Mono<R2>> value3, TriFunction<? super T1,? super R1,? super R2,java.lang.Boolean> filterFunction, TriFunction<? super T1,? super R1,? super R2,? extends R> yieldingFunction) Perform a For Comprehension over a Mono, accepting 2 generating functions.
static <T1,T2,T3,R1,R2,R3,R> reactor.core.publisher.Mono<R>	forEach4(reactor.core.publisher.Mono<? extends T1> value1, java.util.function.Function<? super T1,? extends reactor.core.publisher.Mono<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends reactor.core.publisher.Mono<R2>> value3, TriFunction<? super T1,? super R1,? super R2,? extends reactor.core.publisher.Mono<R3>> value4, QuadFunction<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a For Comprehension over a Mono, accepting 3 generating functions.
static <T1,T2,T3,R1,R2,R3,R> reactor.core.publisher.Mono<R>	forEach4(reactor.core.publisher.Mono<? extends T1> value1, java.util.function.Function<? super T1,? extends reactor.core.publisher.Mono<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends reactor.core.publisher.Mono<R2>> value3, TriFunction<? super T1,? super R1,? super R2,? extends reactor.core.publisher.Mono<R3>> value4, QuadFunction<? super T1,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, QuadFunction<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a For Comprehension over a Mono, accepting 3 generating functions.
static <T> reactor.core.publisher.Mono<T>	fromIterable(java.lang.Iterable<T> t) Construct a Mono from Iterable by taking the first value from Iterable
static <T> java.util.Iterator<T>	iterator(reactor.core.publisher.Mono<T> pub) Get an Iterator for the value (if any) in the provided Mono
static <T> boolean	test(reactor.core.publisher.Mono<T> mono, T test) Test if value is equal to the value inside this Mono
static <T1,T2,R> reactor.core.publisher.Mono<R>	zip(reactor.core.publisher.Mono<? extends T1> mono, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> app) Combine the provided Mono with the first element (if present) in the provided Publisher using the provided BiFunction
static <T1,T2,R> reactor.core.publisher.Mono<R>	zip(reactor.core.publisher.Mono<? extends T1> mono, java.lang.Iterable<? extends T2> app, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn) Combine the provided Mono with the first element (if present) in the provided Iterable using the provided BiFunction

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Monos

public Monos()

Method Detail

anyM

public static <T> AnyMValue<T> anyM(reactor.core.publisher.Mono<T> mono)

Construct an AnyM type from a Mono. This allows the Mono to be manipulated according to a standard interface along with a vast array of other Java Monad implementations

  
    
    AnyMSeq<Integer> mono = Fluxes.anyM(Mono.just(1,2,3));
    AnyMSeq<Integer> transformedMono = myGenericOperation(mono);
    
    public AnyMSeq<Integer> myGenericOperation(AnyMSeq<Integer> monad);
 
 

Parameters:

mono - To wrap inside an AnyM

Returns:

AnyMSeq wrapping a Mono

forEach4

public static <T1,T2,T3,R1,R2,R3,R> reactor.core.publisher.Mono<R> forEach4(reactor.core.publisher.Mono<? extends T1> value1,
                                                                            java.util.function.Function<? super T1,? extends reactor.core.publisher.Mono<R1>> value2,
                                                                            java.util.function.BiFunction<? super T1,? super R1,? extends reactor.core.publisher.Mono<R2>> value3,
                                                                            TriFunction<? super T1,? super R1,? super R2,? extends reactor.core.publisher.Mono<R3>> value4,
                                                                            QuadFunction<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Perform a For Comprehension over a Mono, accepting 3 generating functions. This results in a four level nested internal iteration over the provided Monos.

 
    
   import static com.aol.cyclops.reactor.Monos.forEach4;
    
          forEach4(Mono.just(1), 
                  a-> Mono.just(a+1),
                  (a,b) -> Mono.<Integer>just(a+b),
                  (a,b,c) -> Mono.<Integer>just(a+b+c),
                  Tuple::tuple)
 
 
 

Parameters:

value1 - top level Mono

value2 - Nested Mono

value3 - Nested Mono

value4 - Nested Mono

yieldingFunction - Generates a result per combination

Returns:

Mono with a combined value generated by the yielding function

forEach4

public static <T1,T2,T3,R1,R2,R3,R> reactor.core.publisher.Mono<R> forEach4(reactor.core.publisher.Mono<? extends T1> value1,
                                                                            java.util.function.Function<? super T1,? extends reactor.core.publisher.Mono<R1>> value2,
                                                                            java.util.function.BiFunction<? super T1,? super R1,? extends reactor.core.publisher.Mono<R2>> value3,
                                                                            TriFunction<? super T1,? super R1,? super R2,? extends reactor.core.publisher.Mono<R3>> value4,
                                                                            QuadFunction<? super T1,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
                                                                            QuadFunction<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Perform a For Comprehension over a Mono, accepting 3 generating functions. This results in a four level nested internal iteration over the provided Monos.

 
 
  import static com.aol.cyclops.reactor.Monos.forEach4;
   
  forEach4(Mono.just(1), 
                a-> Mono.just(a+1),
                (a,b) -> Mono.<Integer>just(a+b),
                (a,b,c) -> Mono.<Integer>just(a+b+c),
                (a,b,c,d) -> a+b+c+d <100,
                Tuple::tuple);
 
 
 

Parameters:

value1 - top level Mono

value2 - Nested Mono

value3 - Nested Mono

value4 - Nested Mono

filterFunction - A filtering function, keeps values where the predicate holds

yieldingFunction - Generates a result per combination

Returns:

Mono with a combined value generated by the yielding function

forEach3

public static <T1,T2,R1,R2,R> reactor.core.publisher.Mono<R> forEach3(reactor.core.publisher.Mono<? extends T1> value1,
                                                                      java.util.function.Function<? super T1,? extends reactor.core.publisher.Mono<R1>> value2,
                                                                      java.util.function.BiFunction<? super T1,? super R1,? extends reactor.core.publisher.Mono<R2>> value3,
                                                                      TriFunction<? super T1,? super R1,? super R2,? extends R> yieldingFunction)

Perform a For Comprehension over a Mono, accepting 2 generating functions. This results in a three level nested internal iteration over the provided Monos.

 
    
   import static com.aol.cyclops.reactor.Monos.forEach3;
    
          forEach3(Mono.just(1), 
                  a-> Mono.just(a+1),
                  (a,b) -> Mono.<Integer>just(a+b),
                  Tuple::tuple)
 
 
 

Parameters:

value1 - top level Mono

value2 - Nested Mono

value3 - Nested Mono

yieldingFunction - Generates a result per combination

Returns:

Mono with a combined value generated by the yielding function

forEach3

public static <T1,T2,R1,R2,R> reactor.core.publisher.Mono<R> forEach3(reactor.core.publisher.Mono<? extends T1> value1,
                                                                      java.util.function.Function<? super T1,? extends reactor.core.publisher.Mono<R1>> value2,
                                                                      java.util.function.BiFunction<? super T1,? super R1,? extends reactor.core.publisher.Mono<R2>> value3,
                                                                      TriFunction<? super T1,? super R1,? super R2,java.lang.Boolean> filterFunction,
                                                                      TriFunction<? super T1,? super R1,? super R2,? extends R> yieldingFunction)

Perform a For Comprehension over a Mono, accepting 2 generating functions. This results in a three level nested internal iteration over the provided Monos.

 
 
  import static com.aol.cyclops.reactor.Monos.forEach3;
   
  forEach3(Mono.just(1), 
                a-> Mono.just(a+1),
                (a,b) -> Mono.<Integer>just(a+b),
                (a,b,c) -> a+b+c <100,
                Tuple::tuple);
 
 
 

Parameters:

value1 - top level Mono

value2 - Nested Mono

value3 - Nested Mono

filterFunction - A filtering function, keeps values where the predicate holds

yieldingFunction - Generates a result per combination

Returns:

Mono with a combined value generated by the yielding function

forEach

public static <T,R1,R> reactor.core.publisher.Mono<R> forEach(reactor.core.publisher.Mono<? extends T> value1,
                                                              java.util.function.Function<? super T,reactor.core.publisher.Mono<R1>> value2,
                                                              java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

Perform a For Comprehension over a Mono, accepting a generating function. This results in a two level nested internal iteration over the provided Monos.

 
    
   import static com.aol.cyclops.reactor.Monos.forEach;
    
          forEach(Mono.just(1), 
                  a-> Mono.just(a+1),
                  Tuple::tuple)
 
 
 

Parameters:

value1 - top level Mono

value2 - Nested Mono

yieldingFunction - Generates a result per combination

Returns:

Mono with a combined value generated by the yielding function

forEach

public static <T,R1,R> reactor.core.publisher.Mono<R> forEach(reactor.core.publisher.Mono<? extends T> value1,
                                                              java.util.function.Function<? super T,? extends reactor.core.publisher.Mono<R1>> value2,
                                                              java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
                                                              java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

Perform a For Comprehension over a Mono, accepting a generating functions. This results in a two level nested internal iteration over the provided Monos.

 
 
  import static com.aol.cyclops.reactor.Monos.forEach;
   
  forEach(Mono.just(1), 
                a-> Mono.just(a+1),
                (a,b) -> Mono.<Integer>just(a+b),
                (a,b,c) -> a+b+c <100,
                Tuple::tuple);
 
 
 

Parameters:

value1 - top level Mono

value2 - Nested Mono

filterFunction - A filtering function, keeps values where the predicate holds

yieldingFunction - Generates a result per combination

Returns:

Mono with a combined value generated by the yielding function

combine

public static <T1,T2,R> reactor.core.publisher.Mono<R> combine(reactor.core.publisher.Mono<? extends T1> mono,
                                                               Value<? extends T2> app,
                                                               java.util.function.BiFunction<? super T1,? super T2,? extends R> fn)

Lazily combine this Mono with the supplied value via the supplied BiFunction

Parameters:

mono - Mono to combine with another value

app - Value to combine with supplied mono

fn - Combiner function

Returns:

Combined Mono

combine

public static <T1,T2,R> reactor.core.publisher.Mono<R> combine(reactor.core.publisher.Mono<? extends T1> mono,
                                                               reactor.core.publisher.Mono<? extends T2> app,
                                                               java.util.function.BiFunction<? super T1,? super T2,? extends R> fn)

Lazily combine this Mono with the supplied Mono via the supplied BiFunction

Parameters:

mono - Mono to combine with another value

app - Mono to combine with supplied mono

fn - Combiner function

Returns:

Combined Mono

zip

public static <T1,T2,R> reactor.core.publisher.Mono<R> zip(reactor.core.publisher.Mono<? extends T1> mono,
                                                           java.lang.Iterable<? extends T2> app,
                                                           java.util.function.BiFunction<? super T1,? super T2,? extends R> fn)

Combine the provided Mono with the first element (if present) in the provided Iterable using the provided BiFunction

Parameters:

mono - Mono to combine with an Iterable

app - Iterable to combine with a Mono

fn - Combining function

Returns:

Combined Mono

zip

public static <T1,T2,R> reactor.core.publisher.Mono<R> zip(reactor.core.publisher.Mono<? extends T1> mono,
                                                           java.util.function.BiFunction<? super T1,? super T2,? extends R> fn,
                                                           org.reactivestreams.Publisher<? extends T2> app)

Combine the provided Mono with the first element (if present) in the provided Publisher using the provided BiFunction

Parameters:

mono - Mono to combine with a Publisher

fn - Publisher to combine with a Mono

app - Combining function

Returns:

Combined Mono

test

public static <T> boolean test(reactor.core.publisher.Mono<T> mono,
                               T test)

Test if value is equal to the value inside this Mono

Parameters:

mono - Mono to test

test - Value to test

Returns:

true if equal

fromIterable

public static <T> reactor.core.publisher.Mono<T> fromIterable(java.lang.Iterable<T> t)

Construct a Mono from Iterable by taking the first value from Iterable

Parameters:

t - Iterable to populate Mono from

Returns:

Mono containing first element from Iterable (or empty Mono)

iterator

public static <T> java.util.Iterator<T> iterator(reactor.core.publisher.Mono<T> pub)

Get an Iterator for the value (if any) in the provided Mono

Parameters:

pub - Mono to get Iterator for

Returns:

Iterator over Mono value