LazyReact (cyclops-react 2.0.0-MI1 API)

java.lang.Object
- cyclops.async.LazyReact

All Implemented Interfaces:: com.aol.cyclops2.internal.react.stream.ReactBuilder

public class LazyReact
extends java.lang.Object
implements com.aol.cyclops2.internal.react.stream.ReactBuilder

Builder class for LazyFutureStreams Confgure Executors Parallelism / concurrent tasks Caching Object pooling

 
 new LazyReact(Executors.newFixedThreadPool(4)).of(6,5,2,1)
                                                      .map(this::loadData)
                                                      .map(e->e*100)
                                                      .filter(e->e<551)
                                                      .peek(e->{
                                                          System.out.println("e is " + e 
                                                                              + " on thread " 
                                                                              + Thread.currentThread().getId());
                                                      })
                                                      .runOnCurrent();

Constructor Summary

Constructors
Constructor and Description
`LazyReact()` Construct a LazyReact builder using standard thread pool.
`LazyReact(java.util.concurrent.Executor executor)` Construct a LazyReact builder with provided Executor
`LazyReact(java.util.concurrent.Executor executor, com.nurkiewicz.asyncretry.AsyncRetryExecutor retrier, boolean async, MaxActive maxActive2)`
`LazyReact(java.util.concurrent.Executor executor, com.nurkiewicz.asyncretry.RetryExecutor retrier, java.lang.Boolean async, MaxActive maxActive, boolean streamOfFutures, boolean objectPoolingActive, boolean autoOptimize, boolean autoMemoize, Cacheable memoizeCache)`
`LazyReact(int maxActive, java.util.concurrent.Executor executor)`
`LazyReact(int threadPoolSize, int maxActiveTasks)` LazyReact builder with a new TaskExecutor with threads determined by threadPoolSize Max concurrent tasks is determined by concurrency

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`LazyReact`	`async()` Start any created Streams in asyncrhonous mode - that is tasks will be submited to an Executor to be run.
`LazyReact`	`autoMemoizeOn(Cacheable<?> memoizeCache)` Turn automatic caching of values on for the FutureStream to be generated by this Stream builder
`LazyReact`	`autoOptimizeOff()` Turn off automatic threading management.
`LazyReact`	`autoOptimizeOn()` Turn on automatic threading optimization.
`<U> FutureStream<U>`	`construct(java.util.stream.Stream<U> s)`
`<U> FutureStream<U>`	`constructFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<U>> s)` Construct a FutureStream from a Stream of CompletableFutures
`<R> FutureStream<R>`	`from(java.util.Collection<R> collection)` Start a reactive flow from a Collection using an Iterator
`<U> FutureStream<U>`	`from(java.util.concurrent.CompletableFuture<U>... cf)` Construct a FutureStream from an array of CompletableFutures
`<U> FutureStream<U>`	`from(java.util.concurrent.CompletableFuture<U> cf)` Construct a FutureStream containing a single Future
`FutureStream<java.lang.Double>`	`from(java.util.stream.DoubleStream stream)` Start a reactive dataflow from a stream.
`FutureStream<java.lang.Integer>`	`from(java.util.stream.IntStream stream)` Start a reactive dataflow from a stream.
`<U> FutureStream<U>`	`from(java.util.Iterator<U> iterator)` Start a reactive flow from a JDK Iterator
`FutureStream<java.lang.Long>`	`from(java.util.stream.LongStream stream)` Start a reactive dataflow from a stream.
`<U> FutureStream<U>`	`fromAdapter(Adapter<U> adapter)` Generate a FutureStream from the data flowing into the prodiced Adapter
`<U> FutureStream<U>`	`fromIterable(java.lang.Iterable<U> iter)`
`<U> FutureStream<U>`	`fromIterableAsync(java.lang.Iterable<? extends java.util.function.Supplier<U>> actions)`
`<U> FutureStream<U>`	`fromIteratorAsync(java.util.Iterator<? extends java.util.function.Supplier<U>> actions)`
`<T> FutureStream<T>`	`fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)` Construct a FutureStream from an Publisher
`<U> FutureStream<U>`	`fromStream(java.util.stream.Stream<U> stream)`
`<U> FutureStream<U>`	`fromStreamAsync(java.util.stream.Stream<? extends java.util.function.Supplier<U>> actions)`
`<U> FutureStream<U>`	`fromStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<U>> stream)`
`<U> FutureStream<U>`	`generate(java.util.function.Supplier<U> generate)` Generate an infinite Stream
`<U> FutureStream<U>`	`generateAsync(java.util.function.Supplier<U> s)` Generate an infinite FutureStream executing the provided Supplier continually and asynhcronously
`boolean`	`isAsync()`
`<U> FutureStream<U>`	`iterate(U seed, java.util.function.UnaryOperator<U> f)` Iterate infinitely using the supplied seed and function Iteration is synchronized to support multiple threads using the same iterator.
`LazyReact`	`objectPoolingOff()` Turn objectPooling off for any Streams created by the returned LazyReact builder.
`LazyReact`	`objectPoolingOn()` Turn objectPooling on for any Streams created by the returned LazyReact builder This improves performance for Streams with very large numbers of elements, by reusing Future instances.
`<U> FutureStream<U>`	`of(U... array)` Construct a LazyFurureStream from the values in the supplied array
`<U> FutureStream<U>`	`ofAsync(java.util.function.Supplier<U>... actions)`
`static LazyReact`	`parallelBuilder()` * Construct a LazyReact builder using standard thread pool.
`static LazyReact`	`parallelBuilder(int parallelism)` Construct a new LazyReact builder, with a new task executor and retry executor with configured number of threads
`static LazyReact`	`parallelCommonBuilder()`
`FutureStream<java.lang.Integer>`	`range(int startInclusive, int endExclusive)`
`<U> FutureStream<U>`	`react(java.util.Collection<java.util.function.Supplier<U>> actions)`
`static LazyReact`	`sequentialBuilder()`
`static LazyReact`	`sequentialCommonBuilder()`
`static LazyReact`	`sequentialCurrentBuilder()`
`LazyReact`	`sync()` Start any created Streams in syncrhonous mode - that is tasks will be executed on the calling thread

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

Constructor Detail
- LazyReact
```
public LazyReact()
```
  Construct a LazyReact builder using standard thread pool. By default, unless ThreadPools is configured otherwise this will be sized to the available processors ThreadPools#getStandard is used to determine task executor for parallel task execution
  
  See Also:
  
  ThreadPools.getStandard()
- LazyReact
```
public LazyReact(java.util.concurrent.Executor executor)
```
  Construct a LazyReact builder with provided Executor
  
  Parameters:
  
  executor - Executor to use
- LazyReact
```
public LazyReact(int maxActive,
                 java.util.concurrent.Executor executor)
```
  Parameters:
  
  maxActive - Max active Future Tasks
  
  executor - Executor to use
- LazyReact
```
public LazyReact(int threadPoolSize,
                 int maxActiveTasks)
```
  LazyReact builder with a new TaskExecutor with threads determined by threadPoolSize Max concurrent tasks is determined by concurrency
  
  Parameters:
  
  threadPoolSize -
  
  maxActiveTasks -
- LazyReact
```
public LazyReact(java.util.concurrent.Executor executor,
                 com.nurkiewicz.asyncretry.RetryExecutor retrier,
                 java.lang.Boolean async,
                 MaxActive maxActive,
                 boolean streamOfFutures,
                 boolean objectPoolingActive,
                 boolean autoOptimize,
                 boolean autoMemoize,
                 Cacheable memoizeCache)
```
  Parameters:
  
  executor - Task Executor for concurrent tasks
  
  retrier - Async Retrier
  
  async - If true each task will be submitted to an executor service
- LazyReact
```
public LazyReact(java.util.concurrent.Executor executor,
                 com.nurkiewicz.asyncretry.AsyncRetryExecutor retrier,
                 boolean async,
                 MaxActive maxActive2)
```
  Parameters:
  
  executor - Task Executor for concurrent tasks
  
  retrier - Async Retrier
  
  async - If true each task will be submitted to an executor service
  
  maxActive2 - Max Active Future Tasks

Method Detail

autoMemoizeOn

public LazyReact autoMemoizeOn(Cacheable<?> memoizeCache)

Turn automatic caching of values on for the FutureStream to be generated by this Stream builder

  
  Map cache = new ConcurrentHashMap<>();
        LazyReact builder = new LazyReact().autoMemoizeOn((key,fn)-> cache.computeIfAbsent(key,fn));
        Set<Integer> result = builder.of(1,1,1,1)
                                     .capture(e->e.printStackTrace())
                                     .map(i->calc(i))
                                     .peek(System.out::println)
                                     .toSet();

Parameters:: memoizeCache - Cacheable instance that controls memoization (Caching)
Returns:: LazyReact Stream builder

isAsync
```
public boolean isAsync()
```

from
```
public  FutureStream from(java.util.concurrent.CompletableFuture cf)
```
Construct a FutureStream containing a single Future

Parameters:

cf - CompletableFuture to create Stream from

Returns:

FutureStream of a single value

from

public <U> FutureStream<U> from(java.util.concurrent.CompletableFuture<U>... cf)

Construct a FutureStream from an array of CompletableFutures

  
  CompletableFuture<String> future1 = CompletableFuture.supplyAsync(()->"hello");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(()->"hello2");
        new LazyReact().from(future1,future2)
                       .peek(System.out::println)
                       .transform(action->"result")
                       .toList()
                       .size()
        //2

Parameters:: cf - Array of Futures to construct Stream from
Returns:: FutureStream from array of Futures

construct

public <U> FutureStream<U> construct(java.util.stream.Stream<U> s)

constructFutures
```
public  FutureStream constructFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture> s)
```
Construct a FutureStream from a Stream of CompletableFutures

Parameters:

s - Stream of CompletableFutures

Returns:

FutureStream

objectPoolingOn
```
public LazyReact objectPoolingOn()
```
Turn objectPooling on for any Streams created by the returned LazyReact builder This improves performance for Streams with very large numbers of elements, by reusing Future instances. By default Object Pooling is Off.
```
  
  return new LazyReact()
    					.objectPoolingOn()
    					.range(0,5_000_000_000)
    					.map(this::process)
    					.forEach(System.out::println);
       
       
```
Returns:

New LazyReact builder with Object pooling on.

objectPoolingOff

public LazyReact objectPoolingOff()

Turn objectPooling off for any Streams created by the returned LazyReact builder. By default Object Pooling is Off.

  
 	LazyReact react; 
  
    react.objectPoolingOff()
    					.range(0,5_000)
    					.map(this::process)
    					.forEach(System.out::println);

Returns:: New LazyReact builder with Object pooling off.

autoOptimizeOn
```
public LazyReact autoOptimizeOn()
```
Turn on automatic threading optimization. Tasks will be 'fanned' out across threads initially and subsequent task completion events will trigger further processing on the same thread. Where operations require working on the results of multiple tasks, data will be forwarded to a Queue, data read from the queue will transform also be 'fanned' out for processing across threads (with subsequent events again occuring on the same thread). This is equivalent to optimal use of the async() and sync() operators on a Stream. autoOptimize overrides direct calls to sync() and async() on the Stream. By default autoOptimize is On.
```
  
 new LazyReact().autoOptimizeOn()
                  .range(0, 1_000_000)
    					.map(i->i+2)
    					.map(i->Thread.currentThread().getId())
    					.peek(System.out::println)
    					.runOnCurrent();
 
 
```
Returns:

autoOptimizeOff

public LazyReact autoOptimizeOff()

Turn off automatic threading management. This allows use async() and sync() to control fan out directly in a FutureStream By default autoOptimize is On.

  
 	LazyReact react; 
  
    react.autoOptimizeOff()
    				    .range(0, 1_000_000)
    					.map(i->i+2)
    					.map(i->Thread.currentThread().getId())
    					.peek(System.out::println)
    					.runOnCurrent();

Returns:

async

public LazyReact async()

Start any created Streams in asyncrhonous mode - that is tasks will be submited to an Executor to be run.

  
 Turn async on
 LazyReact.sequentialBuilder()
          .withMaxActive(MaxActive.IO)
          .async()
                .generateAsync(()->1)
                .limit(1_000_000);

Returns:: LazyReact that creates Streams in async mode

sync
```
public LazyReact sync()
```
Start any created Streams in syncrhonous mode - that is tasks will be executed on the calling thread

Returns:

LazyReact that creates Streams in sync mode

fromPublisher

public <T> FutureStream<T> fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)

Construct a FutureStream from an Publisher

  
    new LazyReact().fromPublisher(Flux.just(1,2,3)).toList();

Parameters:: publisher - to construct FutureStream from
Returns:: FutureStream

range

public FutureStream<java.lang.Integer> range(int startInclusive,
                                             int endExclusive)

fromStreamFutures

public <U> FutureStream<U> fromStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<U>> stream)

ofAsync

@SafeVarargs
public final <U> FutureStream<U> ofAsync(java.util.function.Supplier<U>... actions)

fromStream

public <U> FutureStream<U> fromStream(java.util.stream.Stream<U> stream)

react

public <U> FutureStream<U> react(java.util.Collection<java.util.function.Supplier<U>> actions)

fromIterable

public <U> FutureStream<U> fromIterable(java.lang.Iterable<U> iter)

fromStreamAsync

public <U> FutureStream<U> fromStreamAsync(java.util.stream.Stream<? extends java.util.function.Supplier<U>> actions)

fromIteratorAsync

public <U> FutureStream<U> fromIteratorAsync(java.util.Iterator<? extends java.util.function.Supplier<U>> actions)

fromIterableAsync

public <U> FutureStream<U> fromIterableAsync(java.lang.Iterable<? extends java.util.function.Supplier<U>> actions)

parallelBuilder
```
public static LazyReact parallelBuilder()
```
* Construct a LazyReact builder using standard thread pool. By default, unless ThreadPools is configured otherwise this will be sized to the available processors ThreadPools#getStandard is used to determine task executor for parallel task execution

Returns:

LazyReact for building infinite, parallel streams

See Also:

ThreadPools.getStandard()

parallelBuilder
```
public static LazyReact parallelBuilder(int parallelism)
```
Construct a new LazyReact builder, with a new task executor and retry executor with configured number of threads

Parameters:

parallelism - Number of threads task executor should have

Returns:

LazyReact instance

parallelCommonBuilder
```
public static LazyReact parallelCommonBuilder()
```
Returns:

new LazyReact builder configured with standard parallel executor By default this is the ForkJoinPool common instance but is configurable in the ThreadPools class

See Also:

see RetryBuilder#getDefaultInstance()

sequentialBuilder
```
public static LazyReact sequentialBuilder()
```
Returns:

new LazyReact builder configured to run on a separate thread (non-blocking current thread), sequentially New ForkJoinPool will be created

sequentialCommonBuilder
```
public static LazyReact sequentialCommonBuilder()
```
Returns:

LazyReact builder configured to run on a separate thread (non-blocking current thread), sequentially Common free thread Executor from

sequentialCurrentBuilder
```
public static LazyReact sequentialCurrentBuilder()
```
Returns:

LazyReact builder configured to run on a separate thread (non-blocking current thread), sequentially Common free thread Executor from

iterate

public <U> FutureStream<U> iterate(U seed,
                                   java.util.function.UnaryOperator<U> f)

Iterate infinitely using the supplied seed and function Iteration is synchronized to support multiple threads using the same iterator.

  
  new LazyReact().objectPoolingOn()
                       .iterate(1,i->i+1)
                       .limit(1_000_000)
                       .map(this::process)
                       .forEach(this::save);

Parameters:: seed - Initial value; f - Function that performs the iteration
Returns:: FutureStream
See Also:: for an alternative which does not synchronize iteration

fromAdapter

public <U> FutureStream<U> fromAdapter(Adapter<U> adapter)

Generate a FutureStream from the data flowing into the prodiced Adapter

  
    
    Topic<Integer> topic = new Topic<>();
    
    new LazyReact(10,10).fromAdapter(topic)
                        .forEach(this::process);
    
    //on anther thread
    topic.offer(100);
    topic.offer(200);

Parameters:: adapter - Adapter to construct FutureStream from
Returns:: FutureStream

generate

public <U> FutureStream<U> generate(java.util.function.Supplier<U> generate)

Generate an infinite Stream

  
  new LazyReact().generate(()->"hello")
                       .limit(5)
                       .reduce(Semigroups.stringConcat);
                       
        //Optional[hellohellohellohellohello]

Parameters:: generate - Supplier that generates stream input
Returns:: Infinite FutureStream

generateAsync

public <U> FutureStream<U> generateAsync(java.util.function.Supplier<U> s)

Generate an infinite FutureStream executing the provided Supplier continually and asynhcronously

  
  new LazyReact().generate(this::load)
                       .limit(5)
                       .reduce(Semigroups.stringConcat);
                       
        //Optional["data1data2data3data4data5"]

Parameters:: s - Supplier to execute asynchronously to create an infinite Stream
Returns:: Infinite FutureStream

from

public <U> FutureStream<U> from(java.util.Iterator<U> iterator)

Start a reactive flow from a JDK Iterator

  
  Iterator<Integer> iterator;
  new LazyReact(10,10).from(iterator)
                       .map(this::process);

Parameters:: iterator - SimpleReact will iterate over this iterator concurrently to skip the reactive dataflow
Returns:: FutureStream

from

public <R> FutureStream<R> from(java.util.Collection<R> collection)

Start a reactive flow from a Collection using an Iterator

  
 
  new LazyReact(10,10).from(myList)
                       .map(this::process);

Parameters:: collection - - Collection SimpleReact will iterate over at the skip of the flow
Returns:: FutureStream

from
```
public FutureStream<java.lang.Integer> from(java.util.stream.IntStream stream)
```
Start a reactive dataflow from a stream.

Parameters:

stream - that will be used to drive the reactive dataflow

Returns:

FutureStream

from
```
public FutureStream<java.lang.Double> from(java.util.stream.DoubleStream stream)
```
Start a reactive dataflow from a stream.

Parameters:

stream - that will be used to drive the reactive dataflow

Returns:

FutureStream

from
```
public FutureStream<java.lang.Long> from(java.util.stream.LongStream stream)
```
Start a reactive dataflow from a stream.

Parameters:

stream - that will be used to drive the reactive dataflow

Returns:

FutureStream

of

@SafeVarargs
public final <U> FutureStream<U> of(U... array)

Construct a LazyFurureStream from the values in the supplied array

  
 
  new LazyReact(10,10).of(1,2,3,4)
                      .map(this::process);

Parameters:: array - Array to construct FutureStream from
Returns:: FutureStream

Class LazyReact

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

LazyReact

LazyReact

LazyReact

LazyReact

LazyReact

LazyReact

Method Detail

autoMemoizeOn

isAsync

from

from

construct

constructFutures

objectPoolingOn

objectPoolingOff

autoOptimizeOn

autoOptimizeOff

async

sync

fromPublisher

range

fromStreamFutures

ofAsync

fromStream

react

fromIterable

fromStreamAsync

fromIteratorAsync

fromIterableAsync

parallelBuilder

parallelBuilder

parallelCommonBuilder

sequentialBuilder

sequentialCommonBuilder

sequentialCurrentBuilder

iterate

fromAdapter

generate

generateAsync

from

from

from

from

from

of