cyclops.async.adapters

Class Queue<T>

java.lang.Object

cyclops.async.adapters.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 toNested 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.reactiveStream()
                  .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 toNested 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 toNested 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 toNested communicate closure toNested connected Streams A Poison Pill is added per connected Stream toNested the Queue If a BlockingQueue is backing this async.Queue it will block until able toNested add toNested 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 toNested 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 toNested this Queue To disconnect cleanly close the queue
boolean	offer(T data) Offer a single datapoint toNested 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<ListX<T>>	streamGroupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit t)
ReactiveSeq<ListX<T>>	streamGroupedByTime(long time, java.util.concurrent.TimeUnit t)
java.lang.String	toString()
<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, wait, wait, wait

Methods inherited from interface cyclops.async.adapters.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 toNested extract JDK Queue from

Queue

public Queue(java.util.concurrent.BlockingQueue<T> queue)

Queue accepts a BlockingQueue toNested make use of Blocking semantics

Parameters:

queue - BlockingQueue toNested 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 toNested this Queue To disconnect cleanly close the queue

  
        use queue.reactiveStream().parallel() toNested convert toNested a parallel Stream
  
 

Parameters:

closeScalingFactor - Scaling factor for Queue closed messages toNested propagate toNested connected parallel Streams. Scaling Factor may need toNested be high toNested reach all connect parallel threads.

Returns:

Java 8 Stream connnected toNested this Queue

jdkStream

public java.util.stream.Stream<T> jdkStream()

Return a standard (unextended) JDK Stream connected toNested this Queue To disconnect cleanly close the queue

  
        use queue.reactiveStream().parallel() toNested convert toNested a parallel Stream
  
 

Returns:

Java 8 Stream connnected toNested 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<ListX<T>> streamGroupedByTime(long time,
                                                 java.util.concurrent.TimeUnit t)

checkTime

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

streamGroupedBySizeAndTime

public ReactiveSeq<ListX<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 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 toNested the queue If the queue is a bounded queue and is full, will return false

Parameters:

data - Data toNested add

Returns:

true if successfully added.

offer

public boolean offer(T data)

Offer a single datapoint toNested 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 toNested add

Returns:

self

close

public boolean close()

Close this Queue Poison Pills are used toNested communicate closure toNested connected Streams A Poison Pill is added per connected Stream toNested the Queue If a BlockingQueue is backing this async.Queue it will block until able toNested add toNested 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 toNested send toNested 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)

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

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object