com.oath.cyclops.async.adapters

Class Queue<T>

java.lang.Object

com.oath.cyclops.async.adapters.Queue<T>

Type Parameters:

T - Type of data stored in Queue

All Implemented Interfaces:

Adapter<T>, Sealed2<Queue<T>,Topic<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 emitted 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->"emitted 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)
java.util.Queue<T>	asJDKQueue()
boolean	checkTime(long current, long start, long toRun)
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)
<R> R	fold(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
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
static <T> T	nillSafe(T data)
static <T> T	nullSafe(T data)
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)
void	setContinuations(Queue<T> queue)
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)
ReactiveSeq<Seq<T>>	streamGroupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit t)
ReactiveSeq<Seq<T>>	streamGroupedByTime(long time, java.util.concurrent.TimeUnit t)
java.lang.String	toString()

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.oath.cyclops.async.adapters.Adapter

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)

streamGroupedByTime

public ReactiveSeq<Seq<T>> streamGroupedByTime(long time,
                                               java.util.concurrent.TimeUnit t)

checkTime

public boolean checkTime(long current,
                         long start,
                         long toRun)

streamGroupedBySizeAndTime

public ReactiveSeq<Seq<T>> streamGroupedBySizeAndTime(int size,
                                                      long time,
                                                      java.util.concurrent.TimeUnit t)

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 applyHKT 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

nillSafe

public static <T> T nillSafe(T data)

nullSafe

public static <T> T nullSafe(T data)

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)

Specified by:

addContinuation in interface Adapter<T>

setContinuations

public void setContinuations(Queue<T> queue)

fold

public <R> R fold(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:

fold in interface Adapter<T>

Specified by:

fold in interface Sealed2<Queue<T>,Topic<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

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object