cyclops.stream

Class StreamSource

java.lang.Object

cyclops.stream.StreamSource

public class StreamSource
extends java.lang.Object

Create Java 8 Streams that data can be pushed into Pushing data into a Java 8 Stream

  
 PushableStream<Integer> pushable = StreamSource.ofUnbounded()
                                                        .reactiveStream();
   pushable.getInput()
           .offer(10);
    
    Stream<Integer> reactiveStream = pushable.getStream();
    reactiveStream.forEach(System.out::println);
    
    //print 10
     
    pushable.getInput()
           .offer(20);
           
    //print 20       
       
                
    pushable.getInput()
            .close();            
 
 
 
 

Pushing data into a FutureStream

  
 PushableFutureStream<Integer> pushable = StreamSource.ofUnbounded()
                                                            .futureStream(new LazyReact());
   pushable.getInput()
           .offer(100);
   
   //on another thread
   pushable.getStream()
           .forEach(this:process);
               
                
   //close input into Stream -         
   pushable.getInput().close();             
 
 
 
 

Multiple Streams reading the same data across threads

  
   MultipleStreamSource<Integer> multi = StreamSource.ofMultiple();
     multi.getInput()
          .offer(100);
        
    //example on separate threads
    
     //thread 1
    LazyFutureStream<Integer> futureStream = multi.futureStream(new LazyReact());
    futureStream.forEach(System.out::println);
    
    //print 100
    
    //thread 2
    ReactiveSeq<Integer> seq = multi.reactiveSeq();
    seq.forEach(System.out::println);
   
    //print 100
     
    //thread 3
    Stream<Integer> reactiveStream = multi.reactiveStream();
    reactiveStream.forEach(System.out::println);
   
    //print 100    
       
    multi.getInput()
         .offer(200);  
         
    //thread 1 
    //print 200  
    
    //thread 2 
    //print 200 
    
    //thread 3 
    //print 200 
     
    multi.getInput()
         .close();
        
        
 
 
 
 

Method Summary

Modifier and Type	Method and Description
static <T> FutureStream<T>	futureStream(Adapter<T> adapter, LazyReact react) Create a FutureStream.
<T> PushableFutureStream<T>	futureStream(LazyReact s) Create a pushable FutureStream using the supplied ReactPool
static StreamSource	of(int backPressureAfter) A builder for pushable Streams that applyHKT backpressure if producing Streams exceed the capacity of consuming Streams.
static StreamSource	of(QueueFactory<?> q) Construct a Pushable StreamSource using the provided QueueFactory as a push mechanism
static <T> MultipleStreamSource<T>	ofMultiple() Connect multiple Streams to a Pushable datasource, each Stream will recieve the same data.
static <T> MultipleStreamSource<T>	ofMultiple(int backPressureAfter) Connect multiple Streams to a Pushable datasource, each Stream will recieve the same data.
static <T> MultipleStreamSource<T>	ofMultiple(QueueFactory<?> q) Construct a StreamSource that supports multiple readers of the same data backed by a Queue created from the supplied QueueFactory
static StreamSource	ofUnbounded() Construct a Pushable StreamSource with no max size.
<T> PushableReactiveSeq<T>	reactiveSeq() Create a pushable PushableReactiveSeq
static <T> ReactiveSeq<T>	reactiveSeq(Adapter<T> adapter) Create a pushable ReactiveSeq
<T> PushableStream<T>	stream() Create a pushable JDK 8 Stream
static <T> java.util.stream.Stream<T>	stream(Adapter<T> adapter) Create a JDK 8 Stream from the supplied Adapter

Methods inherited from class java.lang.Object

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

Method Detail

ofMultiple

public static <T> MultipleStreamSource<T> ofMultiple()

Connect multiple Streams to a Pushable datasource, each Stream will recieve the same data.

  
 
 
   MultipleStreamSource<Integer> multi = StreamSource.ofMultiple();
         multi.getInput()
              .offer(100);
        
        //example on separate threads
    
         //thread 1
        LazyFutureStream<Integer> futureStream = multi.futureStream(new LazyReact());
        futureStream.forEach(System.out::println);
        
        //print 100
        
        //thread 2
        ReactiveSeq<Integer> seq = multi.reactiveSeq();
        seq.forEach(System.out::println);
       
        //print 100
         
        //thread 3
        Stream<Integer> reactiveStream = multi.reactiveStream();
        reactiveStream.forEach(System.out::println);
       
        //print 100    
           
        multi.getInput()
             .offer(200);  
             
        //thread 1 
        //print 200  
        
        //thread 2 
        //print 200 
        
        //thread 3 
        //print 200 
         
        multi.getInput()
             .close();

 
 
 

Returns:

a builder that will use Topics to allow multiple Streams from the same data

ofMultiple

public static <T> MultipleStreamSource<T> ofMultiple(int backPressureAfter)

Connect multiple Streams to a Pushable datasource, each Stream will recieve the same data. In this backpresure is applied by using a LinkedBlockingQueue. @see cyclops2.reactiveStream.StreamSource#ofMultiple(QueueFactory) For more granular management of Adapter based backpressure. Adapters can be backed by non-blocking data structures and different backpressure strategies applied

  
 
 
   MultipleStreamSource<Integer> multi = StreamSource.ofMultiple(2);
         multi.getInput()
              .offer(100);
        
        //example on separate threads
    
         //thread 1
        LazyFutureStream<Integer> futureStream = multi.futureStream(new LazyReact());
        futureStream.map(this::slowProcess)
                    .forEach(System.out::println);
        
        //print 100
        
        //thread 2
        ReactiveSeq<Integer> seq = multi.reactiveSeq();
        seq.forEach(System.out::println);
       
        //print 100
         
        //thread 3
        Stream<Integer> reactiveStream = multi.reactiveStream();
        reactiveStream.forEach(System.out::println);
       
        //print 100    
           
        multi.getInput()
             .offer(200);  
             
        //thread 1 
        //print 200  
        
        //thread 2 
        //print 200 
        
        //thread 3 
        //print 200 
         
        multi.getInput()
             .offer(300);
        multi.getInput()
             .offer(400); 
        multi.getInput()
             .offer(500);    //blocked as backpressure applied        
        multi.getInput()
             .close();

 
 
 

Parameters:

backPressureAfter - Excess number of emitted records over consumed (by all connected Streams after which backPressure will be applied).

Returns:

a builder that will use Topics to allow multiple Streams from the same data

ofMultiple

public static <T> MultipleStreamSource<T> ofMultiple(QueueFactory<?> q)

Construct a StreamSource that supports multiple readers of the same data backed by a Queue created from the supplied QueueFactory

Parameters:

q - QueueFactory used to create the Adapter to back the pushable StreamSource

Returns:

a builder that will use Topics to allow multiple Streams from the same data

See Also:

for Factory creation options and various backpressure strategies

 {@code 
  MultipleStreamSource multi = StreamSource
                                                .ofMultiple(QueueFactories.boundedQueue(100));
        FutureStream pushable = multi.futureStream(new LazyReact());
        ReactiveSeq seq = multi.reactiveSeq();
        multi.getInput().offer(100);
        multi.getInput().close();
        pushable.collect(CyclopsCollectors.toList()); //[100]
        seq.collect(CyclopsCollectors.toList()); //[100]
 
 }
 

of

public static StreamSource of(QueueFactory<?> q)

Construct a Pushable StreamSource using the provided QueueFactory as a push mechanism

Parameters:

q - QueueFactory used to create the Adapter to back the pushable StreamSource

Returns:

Pushable StreamSource

See Also:

for Factory creation options and various backpressure strategies

 {@code 
 PushableStream pushable = StreamSource.of(QueueFactories.boundedQueue(10))
                                                        .reactiveStream();
       pushable.getInput()
               .offer(10);
    
        Stream reactiveStream = pushable.getStream();
        reactiveStream.forEach(System.out::println);
    
        //print 10
     
        pushable.getInput()
               .offer(20);
           
        //print 20       
       
                
        pushable.getInput()
                .close();            
        }
 

ofUnbounded

public static StreamSource ofUnbounded()

Construct a Pushable StreamSource with no max size. Warning if data producers pushing data to this StreamSource are faster than Data consumers the JVM will eventually run out of memory.

  
 PushableStream<Integer> pushable = StreamSource.ofUnbounded()
                                                      .reactiveStream();
       pushable.getInput()
               .offer(10);
    
        Stream<Integer> reactiveStream = pushable.getStream();
        reactiveStream.forEach(System.out::println);
    
        //print 10
     
        pushable.getInput()
               .offer(20);
           
        //print 20       
       
                
        pushable.getInput()
                .close();            
        
 

Returns:

Pushable StreamSource

of

public static StreamSource of(int backPressureAfter)

A builder for pushable Streams that applyHKT backpressure if producing Streams exceed the capacity of consuming Streams. In this backpresure is applied by using a LinkedBlockingQueue. @see cyclops2.reactiveStream.StreamSource#ofMultiple(QueueFactory) For more granular management of Adapter based backpressure. Adapters can be backed by non-blocking data structures and different backpressure strategies applied

        
           StreamSource source = StreamSource.of(10);
           
           pushable.getInput()
               .offer(10);
           
           //on a separate thread
           source.reactiveSeq()
                 .forEach(System.out::println);
       
       
       

Parameters:

backPressureAfter - Excess number of emitted records over consumed (by all connected Streams after which backPressure will be applied).

Returns:

A builder for Pushable Streams

futureStream

public <T> PushableFutureStream<T> futureStream(LazyReact s)

Create a pushable FutureStream using the supplied ReactPool

  
 
  PushableFutureStream<Integer> pushable = StreamSource.ofUnbounded()
                                                                 .futureStream(new LazyReact());
        pushable.getInput().add(100);
        pushable.getInput().close();
        
        
        assertThat(pushable.getStream().collect(CyclopsCollectors.toList()),
                hasItem(100));
 
 
 

Parameters:

s - ReactPool to use to create the Stream

Returns:

a Tuple2 with a Queue<T> and LazyFutureStream<T> - add data to the Queue to push it to the Stream

futureStream

public static <T> FutureStream<T> futureStream(Adapter<T> adapter,
                                               LazyReact react)

Create a FutureStream. his will call FutureStream#futureStream(Stream) which creates a sequential LazyFutureStream

  
 
  PushableFutureStream<Integer> pushable = StreamSource.futureStream(QueueFactories.boundedNonBlockingQueue(1000),new LazyReact());
        pushable.getInput().add(100);
        pushable.getInput().close();
        
        
        assertThat(pushable.getStream().collect(CyclopsCollectors.toList()),
                hasItem(100));
 
 
 

Parameters:

adapter - Adapter to create a LazyFutureStream from

Returns:

A LazyFutureStream that will accept values from the supplied adapter

stream

public <T> PushableStream<T> stream()

Create a pushable JDK 8 Stream

  
 PushableStream<Integer> pushable = StreamSource.ofUnbounded()
                                                        .reactiveStream();
        pushable.getInput()
                .add(10);
        pushable.getInput()
                .close();
        
        pushable.getStream().collect(CyclopsCollectors.toList()) //[10]
               
 
 
 

Returns:

PushableStream that can accept data to push into a Java 8 Stream to push it to the Stream

reactiveSeq

public <T> PushableReactiveSeq<T> reactiveSeq()

Create a pushable PushableReactiveSeq

  
  PushableReactiveSeq<Integer> pushable = StreamSource.ofUnbounded()
                                                            .reactiveSeq();
        pushable.getInput()
                .add(10);
        
        //on another thread
        pushable.getStream()
                .collect(CyclopsCollectors.toList()) //[10]
              
 
 
 

Returns:

PushableStream that can accept data to push into a cyclops2.reactiveStream.ReactiveSeq to push it to the Stream

stream

public static <T> java.util.stream.Stream<T> stream(Adapter<T> adapter)

Create a JDK 8 Stream from the supplied Adapter

  
   Queue<Integer> q = QueueFactories.boundedNonBlockingQueue(1000);
   Stream<Integer> reactiveStream = StreamSource.reactiveStream(q);
   reactiveStream.forEach(System.out::println);
   
   //on a separate thread
   q.offer(10);
 
 

Parameters:

adapter - Adapter to create a Steam from

Returns:

Stream that will accept input from supplied adapter

reactiveSeq

public static <T> ReactiveSeq<T> reactiveSeq(Adapter<T> adapter)

Create a pushable ReactiveSeq

  
  Signal<Integer> signal = Signal.queueBackedSignal();
        ReactiveSeq<Integer> pushable = StreamSource.reactiveSeq(signal
                                                    .getDiscrete());
        signal.set(100);
        signal.close();
        
        assertThat(pushable.collect(CyclopsCollectors.toList()), hasItem(100));
 
 

Parameters:

adapter - Adapter to create a Seq from

Returns:

A Seq that will accept input from a supplied adapter