com.aol.simple.react.async

Class Queue<T>

java.lang.Object

com.aol.simple.react.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 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 NonBlockingQueues (such as ConcurrentLinkedQueue can be used in conjunction with an implementation of the Continuation interface

See Also:

)

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)

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
void	closeAndClear()
static <T> Queue<T>	createMergeQueue()
boolean	fromStream(java.util.stream.Stream<T> stream)
T	get()
boolean	isOpen()
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()
com.aol.cyclops.sequence.SequenceM<T>	stream()
com.aol.cyclops.sequence.SequenceM<T>	stream(Continueable s)
com.aol.cyclops.sequence.SequenceM<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)
com.aol.cyclops.sequence.SequenceM<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)
com.aol.cyclops.sequence.SequenceM<java.util.concurrent.CompletableFuture<T>>	streamCompletableFutures()
com.aol.cyclops.sequence.SequenceM<T>	streamControl(Continueable s, java.util.function.Function<java.util.function.Supplier<T>,java.util.function.Supplier<T>> batcher)
com.aol.cyclops.sequence.SequenceM<java.util.concurrent.CompletableFuture<T>>	streamControlFutures(Continueable s, java.util.function.Function<java.util.function.Supplier<T>,java.util.concurrent.CompletableFuture<T>> batcher)

Methods inherited from class java.lang.Object

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

Field Detail

NILL

public static final Queue.NIL NILL

Constructor Detail

Queue

public Queue()

Construct a Queue backed by a LinkedBlockingQueue

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 com.aol.cyclops.sequence.SequenceM<T> stream()

Specified by:

stream in interface Adapter<T>

Returns:

Sequential Infinite (until Queue is closed) Stream of data from this Queue

         use queue.stream().parallel() to convert to a parallel Stream
 

stream

public com.aol.cyclops.sequence.SequenceM<T> stream(Continueable s)

Specified by:

stream in interface Adapter<T>

Returns:

Stream of data

streamBatchNoTimeout

public com.aol.cyclops.sequence.SequenceM<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 com.aol.cyclops.sequence.SequenceM<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 com.aol.cyclops.sequence.SequenceM<T> streamControl(Continueable s,
                                                           java.util.function.Function<java.util.function.Supplier<T>,java.util.function.Supplier<T>> batcher)

streamControlFutures

public com.aol.cyclops.sequence.SequenceM<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 com.aol.cyclops.sequence.SequenceM<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

Specified by:

close in interface Adapter<T>

Returns:

true if closed

closeAndClear

public void closeAndClear()

size

public int size()

isOpen

public boolean isOpen()

addContinuation

public void addContinuation(Continuation c)