com.aol.cyclops.data.async

Class Queue<T>

java.lang.Object

com.aol.cyclops.data.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

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

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)
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(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 com.aol.cyclops.data.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

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

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()

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