Queue (cyclops-react 2.0.0-MI1 API)

java.lang.Object
- cyclops.async.Queue<T>

Type Parameters:: T - Type of data stored in Queue

All Implemented Interfaces:: Adapter<T>

public class Queue<T>
extends java.lang.Object
implements Adapter<T>

Inspired by scalaz-streams async.Queue (functionally similar, but wraps a JDK Queue - wait-free or Blocking) A Queue that takes data from one or more input Streams and provides them to one or more output Streams Interface specifies a BlockingQueue, but non-BlockingQueues (such as ConcurrentLinkedQueue can be used in conjunction with an implementation of the Continuation interface

See Also:

)
 
 
 Example transfering data using a Queue between two streams
  {@code 
  Queue transferQueue = QueueFactories.boundedQueue(4)
                                                 .build();
        
        new LazyReact(Executors.newFixedThreadPool(4)).generate(()->"data")
                                                      .map(d->"produced on " + Thread.currentThread().getId())
                                                      .peek(System.out::println)
                                                      .peek(d->transferQueue.offer(d))
                                                      .run();
        

        transferQueue.stream()
                  .map(e->"Consumed on " + Thread.currentThread().getId())
                  .futureOperations(Executors.newFixedThreadPool(1))
                  .forEach(System.out::println);
        
        
        
        
        while(true){
          //  System.out.println(inputQueue.size());
        }
 
 
 }

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Queue.ClosedQueueException` Exception thrown if Queue closed
`static class`	`Queue.NIL`
`static class`	`Queue.QueueReader<T>`
`static class`	`Queue.QueueTimeoutException` Exception thrown if Queue polling timesout

Field Summary

Fields
Modifier and Type Field and Description

static Queue.NIL NILL

Fields
Modifier and Type	Field and Description
`static Queue.NIL`	`NILL`

Constructor Summary

Constructors
Constructor and Description
`Queue()` Construct a Queue backed by a LinkedBlockingQueue
`Queue(java.util.concurrent.BlockingQueue<T> queue)` Queue accepts a BlockingQueue to make use of Blocking semantics
`Queue(java.util.Queue<T> q, WaitStrategy<T> consumer, WaitStrategy<T> producer)`
`Queue(QueueFactory<T> factory)` Construct an async.Queue backed by a JDK Queue from the provided QueueFactory

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(T data)` Add a single data point to the queue If the queue is a bounded queue and is full, will return false
`void`	`addContinuation(Continuation c)`
`java.util.Queue<T>`	`asJDKQueue()`
`boolean`	`close()` Close this Queue Poison Pills are used to communicate closure to connected Streams A Poison Pill is added per connected Stream to the Queue If a BlockingQueue is backing this async.Queue it will block until able to add to the Queue.
`void`	`closeAndClear()`
`static <T> Queue<T>`	`createMergeQueue()`
`void`	`disconnectStreams(int pillsToSend)`
`boolean`	`fromStream(java.util.stream.Stream<T> stream)`
`T`	`get()`
`boolean`	`isOpen()`
`java.util.stream.Stream<T>`	`jdkStream()` Return a standard (unextended) JDK Stream connected to this Queue To disconnect cleanly close the queue
`java.util.stream.Stream<T>`	`jdkStream(Continueable s)`
`java.util.stream.Stream<T>`	`jdkStream(int closeScalingFactor)` Return a standard (unextended) JDK Stream connected to this Queue To disconnect cleanly close the queue
`boolean`	`offer(T data)` Offer a single datapoint to this Queue If the queue is a bounded queue and is full it will block until space comes available or until offer time out is reached (default is Integer.MAX_VALUE DAYS).
`T`	`poll(long time, java.util.concurrent.TimeUnit unit)`
`int`	`size()`
`ReactiveSeq<T>`	`stream()`
`ReactiveSeq<T>`	`stream(Continueable s)`
`ReactiveSeq<java.util.Collection<T>>`	`streamBatch(Continueable s, java.util.function.Function<java.util.function.BiFunction<java.lang.Long,java.util.concurrent.TimeUnit,T>,java.util.function.Supplier<java.util.Collection<T>>> batcher)`
`ReactiveSeq<java.util.Collection<T>>`	`streamBatchNoTimeout(Continueable s, java.util.function.Function<java.util.function.Supplier<T>,java.util.function.Supplier<java.util.Collection<T>>> batcher)`
`ReactiveSeq<java.util.concurrent.CompletableFuture<T>>`	`streamCompletableFutures()`
`ReactiveSeq<T>`	`streamControl(Continueable s, java.util.function.Function<java.util.function.Supplier<T>,java.util.function.Supplier<T>> batcher)`
`ReactiveSeq<java.util.concurrent.CompletableFuture<T>>`	`streamControlFutures(Continueable s, java.util.function.Function<java.util.function.Supplier<T>,java.util.concurrent.CompletableFuture<T>> batcher)`
`<R> R`	`visit(java.util.function.Function<? super Queue<T>,? extends R> caseQueue, java.util.function.Function<? super Topic<T>,? extends R> caseTopic)` Conditionally execute one of the supplied function depending on whether or not this Adapter is a Queue or a Topic

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

Methods inherited from interface cyclops.async.Adapter
futureStream, futureStream, matches

- Field Detail
  - NILL
```
public static final Queue.NIL NILL
```
- Constructor Detail
  - Queue
```
public Queue()
```
    Construct a Queue backed by a LinkedBlockingQueue
  - Queue
```
public Queue(QueueFactory<T> factory)
```
    Construct an async.Queue backed by a JDK Queue from the provided QueueFactory
    
    Parameters:
    
    factory - QueueFactory to extract JDK Queue from
  - Queue
```
public Queue(java.util.concurrent.BlockingQueue<T> queue)
```
    Queue accepts a BlockingQueue to make use of Blocking semantics
    
    Parameters:
    
    queue - BlockingQueue to back this Queue
  - Queue
```
public Queue(java.util.Queue<T> q,
             WaitStrategy<T> consumer,
             WaitStrategy<T> producer)
```
- Method Detail
  - createMergeQueue
```
public static <T> Queue<T> createMergeQueue()
```
  - stream
```
public ReactiveSeq<T> stream()
```
    Specified by:
    
    stream in interface Adapter<T>
    
    Returns:
    
    Sequential Infinite (until Queue is closed) Stream of data from this Queue
  - jdkStream
```
public java.util.stream.Stream<T> jdkStream(int closeScalingFactor)
```
    Return a standard (unextended) JDK Stream connected to this Queue To disconnect cleanly close the queue
```
  
        use queue.stream().parallel() to convert to a parallel Stream
  
 
```
    Parameters:
    
    closeScalingFactor - Scaling factor for Queue closed messages to propagate to connected parallel Streams. Scaling Factor may need to be high to reach all connect parallel threads.
    
    Returns:
    
    Java 8 Stream connnected to this Queue
  - jdkStream
```
public java.util.stream.Stream<T> jdkStream()
```
    Return a standard (unextended) JDK Stream connected to this Queue To disconnect cleanly close the queue
```
  
        use queue.stream().parallel() to convert to a parallel Stream
  
 
```
    Returns:
    
    Java 8 Stream connnected to this Queue
    
    See Also:
    
    for an alternative that sends more poision pills for use with parallel Streams.
  - jdkStream
```
public java.util.stream.Stream<T> jdkStream(Continueable s)
```
  - stream
```
public ReactiveSeq<T> stream(Continueable s)
```
    Specified by:
    
    stream in interface Adapter<T>
    
    Returns:
    
    Stream of data
  - streamBatchNoTimeout
```
public ReactiveSeq<java.util.Collection<T>> streamBatchNoTimeout(Continueable s,
                                                                 java.util.function.Function<java.util.function.Supplier<T>,java.util.function.Supplier<java.util.Collection<T>>> batcher)
```
  - streamBatch
```
public ReactiveSeq<java.util.Collection<T>> streamBatch(Continueable s,
                                                        java.util.function.Function<java.util.function.BiFunction<java.lang.Long,java.util.concurrent.TimeUnit,T>,java.util.function.Supplier<java.util.Collection<T>>> batcher)
```
  - streamControl
```
public ReactiveSeq<T> streamControl(Continueable s,
                                    java.util.function.Function<java.util.function.Supplier<T>,java.util.function.Supplier<T>> batcher)
```
  - streamControlFutures
```
public ReactiveSeq<java.util.concurrent.CompletableFuture<T>> streamControlFutures(Continueable s,
                                                                                   java.util.function.Function<java.util.function.Supplier<T>,java.util.concurrent.CompletableFuture<T>> batcher)
```
  - streamCompletableFutures
```
public ReactiveSeq<java.util.concurrent.CompletableFuture<T>> streamCompletableFutures()
```
    Specified by:
    
    streamCompletableFutures in interface Adapter<T>
    
    Returns:
    
    Infinite (until Queue is closed) Stream of CompletableFutures that can be used as input into a SimpleReact concurrent dataflow This Stream itself is Sequential, SimpleReact will apply concurrency / parralellism via the constituent CompletableFutures
  - fromStream
```
public boolean fromStream(java.util.stream.Stream<T> stream)
```
    Specified by:
    
    fromStream in interface Adapter<T>
    
    Parameters:
    
    stream - Input data from provided Stream
  - poll
```
public T poll(long time,
              java.util.concurrent.TimeUnit unit)
       throws Queue.QueueTimeoutException
```
    Throws:
    
    Queue.QueueTimeoutException
  - get
```
public T get()
```
  - add
```
public boolean add(T data)
```
    Add a single data point to the queue If the queue is a bounded queue and is full, will return false
    
    Parameters:
    
    data - Data to add
    
    Returns:
    
    true if successfully added.
  - offer
```
public boolean offer(T data)
```
    Offer a single datapoint to this Queue If the queue is a bounded queue and is full it will block until space comes available or until offer time out is reached (default is Integer.MAX_VALUE DAYS).
    
    Specified by:
    
    offer in interface Adapter<T>
    
    Parameters:
    
    data - data to add
    
    Returns:
    
    self
  - close
```
public boolean close()
```
    Close this Queue Poison Pills are used to communicate closure to connected Streams A Poison Pill is added per connected Stream to the Queue If a BlockingQueue is backing this async.Queue it will block until able to add to the Queue.
    
    Specified by:
    
    close in interface Adapter<T>
    
    Returns:
    
    true if closed
  - disconnectStreams
```
public void disconnectStreams(int pillsToSend)
```
    Parameters:
    
    pillsToSend - Number of poison pills to send to connected Streams
  - closeAndClear
```
public void closeAndClear()
```
  - asJDKQueue
```
public java.util.Queue<T> asJDKQueue()
```
  - size
```
public int size()
```
  - isOpen
```
public boolean isOpen()
```
  - addContinuation
```
public void addContinuation(Continuation c)
```
  - visit
```
public <R> R visit(java.util.function.Function<? super Queue<T>,? extends R> caseQueue,
                   java.util.function.Function<? super Topic<T>,? extends R> caseTopic)
```
    Description copied from interface: Adapter
    
    Conditionally execute one of the supplied function depending on whether or not this Adapter is a Queue or a Topic
    
    Specified by:
    
    visit in interface Adapter<T>
    
    Parameters:
    
    caseQueue - Function to execute if this Adapter is a Queue
    
    caseTopic - Function to execute if this Adapter is a Topic
    
    Returns:
    
    Value returned from executed funciton

Class Queue<T>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface cyclops.async.Adapter

Field Detail

NILL

Constructor Detail

Queue

Queue

Queue

Queue

Method Detail

createMergeQueue

stream

jdkStream

jdkStream

jdkStream

stream

streamBatchNoTimeout

streamBatch

streamControl

streamControlFutures

streamCompletableFutures

fromStream

poll

get

add

offer

close

disconnectStreams

closeAndClear

asJDKQueue

size

isOpen

addContinuation

visit