com.aol.cyclops.types.futurestream.mixins

Class OptimizedLazyReact

java.lang.Object

com.aol.cyclops.types.futurestream.mixins.OptimizedLazyReact

public class OptimizedLazyReact
extends java.lang.Object

Builder of LazyFutureStreams

Constructor Summary

Constructors

Constructor and Description
OptimizedLazyReact()

Method Summary

Modifier and Type	Method and Description
<T> LazyFutureStream<T>	of(java.util.Collection<T> collection) Generate a FutureStream from the specified Collection.
<T> LazyFutureStream<T>	of(java.util.stream.Stream<T> stream) Generate a FutureStream from the specified Stream.
<T> LazyFutureStream<T>	of(T... elements) Generate a FutureStream from the specified elements.
<T> LazyFutureStream<T>	ofIterable(java.lang.Iterable<T> iterable) Generate a FutureStream from the specified Iterable.
<T> LazyFutureStream<T>	react(java.util.Collection<java.util.function.Supplier<T>> suppliers) Generate a FutureStream from the specified Collection of Suppliers.
<T> LazyFutureStream<T>	react(java.util.stream.Stream<java.util.function.Supplier<T>> suppliers) Generate a FutureStream from the specified Stream of Suppliers.
<T> LazyFutureStream<T>	react(java.util.function.Supplier<T>... suppliers) Generate a FutureStream from the specified Suppliers.
<T> LazyFutureStream<T>	reactIterable(java.lang.Iterable<java.util.function.Supplier<T>> suppliers) Generate a FutureStream from the specified Iterable of Suppliers.

Methods inherited from class java.lang.Object

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

Constructor Detail

OptimizedLazyReact

public OptimizedLazyReact()

Method Detail

of

public <T> LazyFutureStream<T> of(T... elements)

Generate a FutureStream from the specified elements. Each element will be wrapped in a Supplier and submitted to a task executor for execution, the returned Stream will be in synchronous mode, where any subsequent operations performed on task results will occur on the same thread without involving a task executor (performance difference between submitting non-tasks and continuing on calling thread is an order of magnitude). E.g. given 3 URLs, we can use this method to move each call onto a separte thread, but work will continue on the same thread once complete

 
  
       microReact.of(ioCallURL1,ioCallURL2,ioCallURL3)  //each URL is wrapped in a task to be recieved on potentially different threads
       		   .map(this::doIO)             //each I/O Call can run on a separate thread, the calling thread always executes
                 .map(this::processResult)     //map occurs on the calling thread
                 .forEach(System.out::println);
 
 

Parameters:

elements - to create LazyFutureStream from

Returns:

LazyFutureStream

of

public <T> LazyFutureStream<T> of(java.util.stream.Stream<T> stream)

Generate a FutureStream from the specified Stream. Each element in the Stream will be wrapped in a Supplier and submitted to a task executor for execution, the returned Stream will be in synchronous mode, where any subsequent operations performed on task results will occur on the same thread without involving a task executor (performance difference between submitting non-tasks and continuing on calling thread is an order of magnitude). E.g. given 3 URLs, we can use this method to move each call onto a separte thread, but work will continue on the same thread once complete

 
  
       microReact.of(Stream.of(ioCallURL1,ioCallURL2,ioCallURL3))  //each URL is wrapped in a task to be recieved on potentially different threads
       		   .map(this::doIO)             //each I/O Call can run on a separate thread, the calling thread always executes
                 .map(this::processResult)     //map occurs on the calling thread
                 .forEach(System.out::println);
 
 

Parameters:

stream - to create LazyFutureStream from

Returns:

LazyFutureStream

of

public <T> LazyFutureStream<T> of(java.util.Collection<T> collection)

Generate a FutureStream from the specified Collection. Each element in the Collection will be wrapped in a Supplier and submitted to a task executor for execution, the returned Stream will be in synchronous mode, where any subsequent operations performed on task results will occur on the same thread without involving a task executor (performance difference between submitting non-tasks and continuing on calling thread is an order of magnitude). E.g. given 3 URLs, we can use this method to move each call onto a separte thread, but work will continue on the same thread once complete

 
  
       microReact.of(Arrays.asList(ioCallURL1,ioCallURL2,ioCallURL3))  //each URL is wrapped in a task to be recieved on potentially different threads
       		   .map(this::doIO)             //each I/O Call can run on a separate thread, the calling thread always executes
                 .map(this::processResult)     //map occurs on the calling thread
                 .forEach(System.out::println);
 
 

Parameters:

collection - to create LazyFutureStream from

Returns:

LazyFutureStream

ofIterable

public <T> LazyFutureStream<T> ofIterable(java.lang.Iterable<T> iterable)

Generate a FutureStream from the specified Iterable. Each element in the Iterable will be wrapped in a Supplier and submitted to a task executor for execution, the returned Stream will be in synchronous mode, where any subsequent operations performed on task results will occur on the same thread without involving a task executor (performance difference between submitting non-tasks and continuing on calling thread is an order of magnitude). E.g. given 3 URLs, we can use this method to move each call onto a separte thread, but work will continue on the same thread once complete

 
  
       microReact.ofIterable(Arrays.asList(ioCallURL1,ioCallURL2,ioCallURL3))  //each URL is wrapped in a task to be recieved on potentially different threads
       		   .map(this::doIO)             //each I/O Call can run on a separate thread, the calling thread always executes
                 .map(this::processResult)     //map occurs on the calling thread
                 .forEach(System.out::println);
 
 

Parameters:

iterable - to create LazyFutureStream from

Returns:

LazyFutureStream

react

public <T> LazyFutureStream<T> react(java.util.function.Supplier<T>... suppliers)

Generate a FutureStream from the specified Suppliers. Each Supplier and submitted to a task executor for execution, the returned Stream will be in synchronous mode, where any subsequent operations performed on task results will occur on the same thread without involving a task executor (performance difference between submitting non-tasks and continuing on calling thread is an order of magnitude).

 
  
       microReact.react(()->ioCallURL1,()->ioCallURL2,()->ioCallURL3)  //each URL Supplier is an Async task to be recieved on potentially different threads
       		   .map(this::doIO)             //each I/O Call can run on a separate thread, the calling thread always executes
                 .map(this::processResult)     //map occurs on the calling thread
                 .forEach(System.out::println);
 
 

Parameters:

suppliers - to create LazyFutureStream from

Returns:

LazyFutureStream

react

public <T> LazyFutureStream<T> react(java.util.stream.Stream<java.util.function.Supplier<T>> suppliers)

Generate a FutureStream from the specified Stream of Suppliers. Each Supplier and submitted to a task executor for execution, the returned Stream will be in synchronous mode, where any subsequent operations performed on task results will occur on the same thread without involving a task executor (performance difference between submitting non-tasks and continuing on calling thread is an order of magnitude).

 
  
       microReact.react(Stream.of(()->ioCallURL1,()->ioCallURL2,()->ioCallURL3))  //each URL Supplier is an Async task to be recieved on potentially different threads
       		   .map(this::doIO)             //each I/O Call can run on a separate thread, the calling thread always executes
                 .map(this::processResult)     //map occurs on the calling thread
                 .forEach(System.out::println);
 
 

Parameters:

suppliers - to create LazyFutureStream from

Returns:

LazyFutureStream

react

public <T> LazyFutureStream<T> react(java.util.Collection<java.util.function.Supplier<T>> suppliers)

Generate a FutureStream from the specified Collection of Suppliers. Each Supplier and submitted to a task executor for execution, the returned Stream will be in synchronous mode, where any subsequent operations performed on task results will occur on the same thread without involving a task executor (performance difference between submitting non-tasks and continuing on calling thread is an order of magnitude).

 
  
       microReact.react(Arrays.asList(()->ioCallURL1,()->ioCallURL2,()->ioCallURL3))  //each URL Supplier is an Async task to be recieved on potentially different threads
       		   .map(this::doIO)             //each I/O Call can run on a separate thread, the calling thread always executes
                 .map(this::processResult)     //map occurs on the calling thread
                 .forEach(System.out::println);
 
 

Parameters:

suppliers - to create LazyFutureStream from

Returns:

LazyFutureStream

reactIterable

public <T> LazyFutureStream<T> reactIterable(java.lang.Iterable<java.util.function.Supplier<T>> suppliers)

Generate a FutureStream from the specified Iterable of Suppliers. Each Supplier and submitted to a task executor for execution, the returned Stream will be in synchronous mode, where any subsequent operations performed on task results will occur on the same thread without involving a task executor (performance difference between submitting non-tasks and continuing on calling thread is an order of magnitude).

 
  
       microReact.reactIterable(Arrays.asList(()->ioCallURL1,()->ioCallURL2,()->ioCallURL3))  //each URL Supplier is an Async task to be recieved on potentially different threads
       		   .map(this::doIO)             //each I/O Call can run on a separate thread, the calling thread always executes
                 .map(this::processResult)     //map occurs on the calling thread
                 .forEach(System.out::println);
 
 

Parameters:

suppliers - to create LazyFutureStream from

Returns:

LazyFutureStream