com.aol.cyclops2.types.stream

Interface HotStream<T>

Type Parameters:

T - Data type of elements in the Stream

All Known Subinterfaces:

PausableHotStream<T>

All Known Implementing Classes:

com.aol.cyclops2.internal.stream.BaseHotStreamImpl, NonPausableHotStream

public interface HotStream<T>

A HotStream - Stream already emitting data

  
   ReactiveSeq.range(1,1_000_000_000)
                .hotStream(exec)
                .connect()
                .forEach(System.out::println)
 
 
 

Method Summary

Modifier and Type	Method and Description
default ReactiveSeq<T>	connect() Connect to this HotStream (Stream that is already emitting data)
ReactiveSeq<T>	connect(java.util.Queue<T> queue) Connect to this HotStream using the provided transfer async.Queue.
default <R extends java.util.stream.Stream<T>> R	connectTo(java.util.Queue<T> queue, java.util.function.Function<ReactiveSeq<T>,R> to) Connect to this HotStream using the provided transfer async.Queue.

Method Detail

connect

default ReactiveSeq<T> connect()

Connect to this HotStream (Stream that is already emitting data)

  
 
 ReactiveSeq.range(0,Integer.MAX_VALUE)
                    .limit(100)
                    .peek(v->value=v)
                    .peek(v->latch.countDown())
                    .peek(System.out::println)
                    .hotStream(exec)
                    .connect()
                    .limit(100)
                    .futureOperations(ForkJoinPool.commonPool())
                    .forEach(System.out::println)
 
 
 

Returns:

Stream connected to the HotStream emitting data

connect

ReactiveSeq<T> connect(java.util.Queue<T> queue)

Connect to this HotStream using the provided transfer async.Queue. The transfer Queue can be used to apply backpressure to the HotStream if it produces data faster than the connected Stream can consume it cyclops2.async.wait.WaitStrategy

  
 new LazyReact().range(0,Integer.MAX_VALUE)
                .limit(1000)
                .peek(v->value=v)
                .peek(v->latch.countDown())
                .hotStream(exec)
                .connect(new LinkedBlockingQueue<>())
                .limit(100)
                .futureOperations(ForkJoinPool.commonPool())
                .forEach(System.out::println)
 
 
 
 
 

Parameters:

queue - Transfer Queue between the Streams

Returns:

Stream connected to the HotStream emitting data

connectTo

default <R extends java.util.stream.Stream<T>> R connectTo(java.util.Queue<T> queue,
                                                           java.util.function.Function<ReactiveSeq<T>,R> to)

Connect to this HotStream using the provided transfer async.Queue. The transfer Queue can be used to apply backpressure to the HotStream if it produces data faster than the connected Stream can consume it cyclops2.async.wait.WaitStrategy Convert the output Stream to the required type with the provided function

Parameters:

queue - Transfer Queue between the Streams

to - Function to convert a ReactiveSeq to desired Stream type

Returns:

Stream connected to the HotStream emitting data