com.aol.cyclops.reactor

Class FluxTs

java.lang.Object

com.aol.cyclops.reactor.FluxTs

public class FluxTs
extends java.lang.Object

Companion class for working with FluxTransformers

Constructor Summary

Constructors

Constructor and Description
FluxTs()

Method Summary

Modifier and Type	Method and Description
static <T> AnyMSeq<T>	anyM(FluxT<T> flux) Construct an AnyM type from a Flux.
static <T> FluxTSeq<T>	fluxT(org.reactivestreams.Publisher<reactor.core.publisher.Flux<T>> nested) Construct a FluxT from a Publisher containing Fluxes.
static <T,R1,R> FluxT<R>	forEach(FluxT<? extends T> value1, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<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 FluxT, accepting a generating function.
static <T,R1,R> FluxT<R>	forEach(FluxT<? extends T> value1, java.util.function.Function<? super T,org.reactivestreams.Publisher<R1>> value2, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction) Perform a For Comprehension over a FluxT, accepting a generating function.
static <T1,T2,R1,R2,R> FluxT<R>	forEach3(FluxT<? extends T1> value1, java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<R2>> value3, TriFunction<? super T1,? super R1,? super R2,? extends R> yieldingFunction) Perform a For Comprehension over a FluxT, accepting 2 generating functions.
static <T1,T2,R1,R2,R> FluxT<R>	forEach3(FluxT<? extends T1> value1, java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<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 FluxT, accepting 2 generating functions.
static <T1,T2,T3,R1,R2,R3,R> FluxT<R>	forEach4(FluxT<? extends T1> value1, java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<R2>> value3, TriFunction<? super T1,? super R1,? super R2,? extends org.reactivestreams.Publisher<R3>> value4, QuadFunction<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a For Comprehension over a FluxT, accepting 3 generating functions.
static <T1,T2,T3,R1,R2,R3,R> FluxT<R>	forEach4(FluxT<? extends T1> value1, java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<R2>> value3, TriFunction<? super T1,? super R1,? super R2,? extends org.reactivestreams.Publisher<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 FluxT, accepting 3 generating functions.

Methods inherited from class java.lang.Object

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

Constructor Detail

FluxTs

public FluxTs()

Method Detail

anyM

public static <T> AnyMSeq<T> anyM(FluxT<T> flux)

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

  
    
    AnyMSeq<Integer> fluxT = Reactor.fromFluxT(fluxT);
    AnyMSeq<Integer> transformedFluxT = myGenericOperation(flux);
    
    public AnyMSeq<Integer> myGenericOperation(AnyMSeq<Integer> monad);
 
 

Parameters:

fluxT - To wrap inside an AnyM

Returns:

AnyMSeq wrapping a fluxT

fluxT

public static <T> FluxTSeq<T> fluxT(org.reactivestreams.Publisher<reactor.core.publisher.Flux<T>> nested)

Construct a FluxT from a Publisher containing Fluxes.

Parameters:

nested - Publisher of Fluxes

Returns:

Flux Transformer for manipulating nested Fluxes

forEach4

public static <T1,T2,T3,R1,R2,R3,R> FluxT<R> forEach4(FluxT<? extends T1> value1,
                                                      java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2,
                                                      java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<R2>> value3,
                                                      TriFunction<? super T1,? super R1,? super R2,? extends org.reactivestreams.Publisher<R3>> value4,
                                                      QuadFunction<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

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

 
    
   import static com.aol.cyclops.reactor.FluxTs.forEach4;
   
    FluxT<Integer> fluxT = FluxT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
    
         forEach4(fluxT, 
                  a-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                  (a,b)-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                  (a,b,c)-> ReactiveSeq.iterate(a,i->i+1).limit(2),
               Tuple::tuple)
               .forEach(System.out::println);
               
     //(10, 10, 10, 10)
       (11, 11, 11, 11)
       (100, 100, 100, 100)
       (101, 101, 101, 101)        
 
 
 

Parameters:

value1 - top level FluxT

value2 - Nested publisher

value3 - Nested publisher

value4 - Nested publisher

yieldingFunction - Generates a result per combination

Returns:

FluxT with an element per combination of nested publishers generated by the yielding function

forEach4

public static <T1,T2,T3,R1,R2,R3,R> FluxT<R> forEach4(FluxT<? extends T1> value1,
                                                      java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2,
                                                      java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<R2>> value3,
                                                      TriFunction<? super T1,? super R1,? super R2,? extends org.reactivestreams.Publisher<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 FluxT, accepting 3 generating functions. This results in a four level nested internal iteration over the provided Publishers.

 
    
   import static com.aol.cyclops.reactor.FluxTs.forEach4;
   
    FluxT<Integer> fluxT = FluxT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
    
        forEach4(fluxT, 
                 a-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                 (a,b)-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                 (a,b,c)-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                 (a,b,c,d)->a+b+c+d<102,
              Tuple::tuple)
              .forEach(System.out::println);
              
    //(10, 10, 10, 10)
      (11, 11, 11, 11)       
 
 
 

Parameters:

value1 - top level FluxT

value2 - Nested publisher

value3 - Nested publisher

value4 - Nested publisher

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

yieldingFunction - Generates a result per combination

Returns:

FluxT with an element per combination of nested publishers generated by the yielding function

forEach3

public static <T1,T2,R1,R2,R> FluxT<R> forEach3(FluxT<? extends T1> value1,
                                                java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2,
                                                java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<R2>> value3,
                                                TriFunction<? super T1,? super R1,? super R2,? extends R> yieldingFunction)

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

 
    
   import static com.aol.cyclops.reactor.FluxTs.forEach3;
   
    FluxT<Integer> fluxT = FluxT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
    
        forEach3(fluxT, 
                 a-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                 (a,b)-> ReactiveSeq.iterate(a,i->i+1).limit(2),
              Tuple::tuple)
              .forEach(System.out::println);
              
         
 
 
 

Parameters:

value1 - top level FluxT

value2 - Nested publisher

value3 - Nested publisher

yieldingFunction - Generates a result per combination

Returns:

FluxT with an element per combination of nested publishers generated by the yielding function

forEach3

public static <T1,T2,R1,R2,R> FluxT<R> forEach3(FluxT<? extends T1> value1,
                                                java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2,
                                                java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<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 FluxT, accepting 2 generating functions. This results in a three level nested internal iteration over the provided Publishers.

 
    
   import static com.aol.cyclops.reactor.FluxTs.forEach3;
   
    FluxT<Integer> fluxT = FluxT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
    
        forEach3(fluxT, 
                 a-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                 (a,b)-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                 (a,b,c)->a+b+c<102,
              Tuple::tuple)
              .forEach(System.out::println);
    
 
 
 

Parameters:

value1 - top level FluxT

value2 - Nested publisher

value3 - Nested publisher

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

yieldingFunction - Generates a result per combination

Returns:

FluxT with an element per combination of nested publishers generated by the yielding function

forEach

public static <T,R1,R> FluxT<R> forEach(FluxT<? extends T> value1,
                                        java.util.function.Function<? super T,org.reactivestreams.Publisher<R1>> value2,
                                        java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

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

 
    
   import static com.aol.cyclops.reactor.FluxTs.forEach;
   
    FluxT<Integer> fluxT = FluxT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
    
       forEach(fluxT, 
                a-> ReactiveSeq.iterate(a,i->i+1).limit(2),
             Tuple::tuple)
             .forEach(System.out::println);
             
        
 
 
 

Parameters:

value1 - top level FluxT

value2 - Nested publisher

value3 - Nested publisher

yieldingFunction - Generates a result per combination

Returns:

FluxT with an element per combination of nested publishers generated by the yielding function

forEach

public static <T,R1,R> FluxT<R> forEach(FluxT<? extends T> value1,
                                        java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<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 FluxT, accepting a generating function. This results in a two level nested internal iteration over the provided Publishers.

 
    
   import static com.aol.cyclops.reactor.FluxTs.forEach;
   
   FluxT<Integer> fluxT = FluxT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
    
        forEach(fluxT, 
                 a-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                 (a,b)->a+b<102,
              Tuple::tuple)
              .forEach(System.out::println);
    
 
 
 

Parameters:

value1 - top level FluxT

value2 - Nested publisher

value3 - Nested publisher

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

yieldingFunction - Generates a result per combination

Returns:

FluxT with an element per combination of nested publishers generated by the yielding function