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:

)

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)

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

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)

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

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

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

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)

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)

Specified by:

visit in interface Adapter<T>