cyclops.async

Class Pipes<K,V>

java.lang.Object

cyclops.async.Pipes<K,V>

Type Parameters:

K - Key type

V - Value type transferred via managed Adapters

public class Pipes<K,V>
extends java.lang.Object

Pipes : Stores and manages cyclops2-react Adapters for cross-thread communication Connected Streams will not be able to complete collect or reduce style methods unless the underlying Adapter for data transfer is closed. I.e. connected Streams remain connected until either the Adapter is closed, or they disconnect (due to a limit for example).

See Also:

Adapter

Constructor Summary

Constructors

Constructor and Description
Pipes()

Method Summary

Modifier and Type	Method and Description
void	clear() Clear all managed Adapters (without closing them or performing any other operation on them)
void	close(java.lang.String key) Close the Adapter identified by the provided Key if it exists
Maybe<FutureStream<V>>	futureStream(K key) Create a FutureStream using default Parallelism from the Adapter identified by the provided key
Maybe<FutureStream<V>>	futureStream(K key, LazyReact builder) Create a FutureStream using the provided LazyReact futureStream builder from the Adapter identified by the provided Key
Maybe<Adapter<V>>	get(K key) Get the Adapter identified by the specified key
Eval<V>	nextOrNull(K key) Return an Eval that allows retrieval of the next value from the attached pipe when get() is called A value is returned if a value is present, otherwise null is returned if the publisher is complete or an error occurs
Eval<Maybe<V>>	nextValue(K key) Return an Eval that allows retrieval of the next value from the attached pipe when get() is called, can be used as an Iterator over the future & present values in the Adapter Maybe.some is returned if a value is present, Maybe.none is returned if the publisher is complete or an error occurs
static <K,V> Pipes<K,V>	of()
static <K,V> Pipes<K,V>	of(java.util.Map<K,Adapter<V>> registered) Construct a Pipes instance to manage a predefined Map of Adapaters
Xor<java.lang.Throwable,V>	oneOrError(K key) Extact one value from the selected pipe or an error if it doesn't exist (NoSuchElementException).
Future<V>	oneOrErrorAsync(K key, java.util.concurrent.Executor ex) Asynchronously extract a value from the Adapter identified by the provided Key
Maybe<V>	oneValue(K key) Extract one value from the selected pipe, if it exists
Maybe<Try<V,java.lang.Throwable>>	oneValueOrError(K key) Deprecated.
<X extends java.lang.Throwable> Maybe<Try<V,X>>	oneValueOrError(K key, java.lang.Class<X>... classes) Deprecated.
void	publishTo(K key, org.reactivestreams.Publisher<V> publisher) Synchronously publish data to the Adapter specified by the provided Key, blocking the current thread
void	publishToAsync(K key, org.reactivestreams.Publisher<V> publisher) Asynchronously publish data to the Adapter specified by the provided Key
void	push(K key, V value) Push a single value synchronously into the Adapter identified by the supplied Key, if it exists
Maybe<ReactiveSeq<V>>	reactiveSeq(K key) Create a ReactiveSeq from the Adapter identified by the provided Key
void	register(K key, Adapter<V> adapter) Register a Queue, and get back a listening LazyFutureStream that runs on a single thread (not the calling thread)
PMapX<K,Adapter<V>>	registered()
int	size()
void	subscribeTo(K key, org.reactivestreams.Subscriber<V> subscriber) Subscribe synchronously to a pipe
void	subscribeTo(K key, org.reactivestreams.Subscriber<V> subscriber, java.util.concurrent.Executor subscribeOn) Subscribe asynchronously to a pipe
ListX<V>	xValues(K key, long x) Extract the next x values from the Adapter identified by the provided Key If the Adapter doesn't exist an empty List is returned

Methods inherited from class java.lang.Object

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

Constructor Detail

Pipes

public Pipes()

Method Detail

size

public int size()

Returns:

Numer of registered adapters

registered

public PMapX<K,Adapter<V>> registered()

Returns:

Persistent map of all registered adapters

of

public static <K,V> Pipes<K,V> of()

Returns:

Construct an empty Pipes instance

of

public static <K,V> Pipes<K,V> of(java.util.Map<K,Adapter<V>> registered)

Construct a Pipes instance to manage a predefined Map of Adapaters

Parameters:

registered - Adapters to register

Returns:

Pipes instance to manage provided Adapters

push

public void push(K key,
                 V value)

Push a single value synchronously into the Adapter identified by the supplied Key, if it exists

  
 
     Pipes<String,String> pipes = Pipes.of();
     pipes.register("hello", new Queue<String>());
           
           pipes.push("hello", "world");
            
           //on another thread 
           pipes.reactiveSeq("hello")
                .get()
                .forEach(System.out::println);
 
 
 

Parameters:

key - Adapter key

value - Value to push to Adapter

get

public Maybe<Adapter<V>> get(K key)

Get the Adapter identified by the specified key

  
    //close an adapter
   pipes.get("adapter-key")
        .map(a->a.close())
        .orElse(false); //Maybe is lazy - trigger action
   
 
 

Parameters:

key - : Adapter identifier

Returns:

selected Queue

futureStream

public Maybe<FutureStream<V>> futureStream(K key)

Create a FutureStream using default Parallelism from the Adapter identified by the provided key

Parameters:

key - : Adapter identifier

Returns:

LazyFutureStream from selected Queue

See Also:

 {@code 
  Pipes bus = Pipes.of();
        bus.register("reactor", QueueFactories.boundedNonBlockingQueue(1000)
                                              .build());
        
        bus.publishTo("reactor",ReactiveSeq.of(10,20,30));
        
        bus.close("reactor");
        
        
        //on another thread
       List res =  bus.futureStream("reactor")
                              .get()
                              .map(i->"fan-out to handle blocking I/O:" + Thread.currentThread().getId() + ":"+i)
                               .toList();
       System.out.println(res);
       
        assertThat(res.size(),equalTo(3));
 
 
 }
 

futureStream

public Maybe<FutureStream<V>> futureStream(K key,
                                           LazyReact builder)

Create a FutureStream using the provided LazyReact futureStream builder from the Adapter identified by the provided Key

  
  Pipes<String, Integer> bus = Pipes.of();
        bus.register("reactor", QueueFactories.<Integer>boundedNonBlockingQueue(1000)
                                              .build());
        
        bus.publishTo("reactor",ReactiveSeq.of(10,20,30));
        
        bus.close("reactor");
        
        
        //on another thread
       List<String> res =  bus.futureStream("reactor", new LazyReact(10,10))
                              .get()
                              .map(i->"fan-out to handle blocking I/O:" + Thread.currentThread().getId() + ":"+i)
                               .toList();
       System.out.println(res);
       
        assertThat(res.size(),equalTo(3));
 
 
 
 

Parameters:

key - : Adapter identifier

builder - LazyReact futureStream builder

Returns:

LazyFutureStream from selected Queue

reactiveSeq

public Maybe<ReactiveSeq<V>> reactiveSeq(K key)

Create a ReactiveSeq from the Adapter identified by the provided Key

  
  Queue<String> q = new Queue<>();
        pipes.register("data-queue", q);
        pipes.push("data-queue", "world");
        
        //on a separate thread
        ReactiveSeq<String> stream = pipes.reactiveSeq("data-queue");
        stream.forEach(System.out::println);
        //"world"
       
      
        
 
 
 

Parameters:

key - : Adapter identifier

Returns:

ReactiveSeq from selected Queue

xValues

public ListX<V> xValues(K key,
                        long x)

Extract the next x values from the Adapter identified by the provided Key If the Adapter doesn't exist an empty List is returned

  
  Queue<String> q = new Queue<>();
        pipes.register("hello", q);
        pipes.push("hello", "world");
        pipes.push("hello", "world2");
        pipes.push("hello", "world3");
        pipes.push("hello", "world4");
        
        //on a separate thread
        pipes.xValues("hello",2) //ListX.of("world","world2")
        pipes.xValues("hello",2) //ListX.of("world3","world4")
 
 
 
 

Parameters:

key - : Adapter identifier

x - Number of elements to return

Returns:

List of the next x elements from the Adapter identified by the provided key

oneValue

public Maybe<V> oneValue(K key)

Extract one value from the selected pipe, if it exists

Parameters:

key - : Adapter identifier

Returns:

Maybe containing next value from the Adapter identified by the provided key

oneOrError

public Xor<java.lang.Throwable,V> oneOrError(K key)

Extact one value from the selected pipe or an error if it doesn't exist (NoSuchElementException).

  
  
  Queue<String> q = new Queue<>();
        pipes.register("hello", q);
        pipes.push("hello", "world");
        pipes.push("hello", "world2");
        
       pipes.oneOrError("hello")
            .get() //"world"
       
 
 

Parameters:

key - : Adapter identifier

Returns:

Xor containing either a NoSuchElementException an Adapter with the specified key does not exist, or the next value from that Adapter

oneValueOrError

@Deprecated
public <X extends java.lang.Throwable> Maybe<Try<V,X>> oneValueOrError(K key,
                                                                                   java.lang.Class<X>... classes)

Deprecated.

Extact one value from the selected pipe or an empty Maybe if it doesn't exist. Currently only Adapter's and not Publishers are managed by Pipes so Publisher errors are not propagated (@see oneValue(Object) or @see oneOrError(Object) is better at the moment.

   
  Queue<String> q = new Queue<>();
        pipes.register("hello", q);
        pipes.push("hello", "world");
        pipes.push("hello", "world2");
      
        
        pipes.oneValueOrError("hello",Throwable.class).get(); //Try["world"]
       
  
  

Parameters:

key -

classes -

Returns:

oneValueOrError

@Deprecated
public Maybe<Try<V,java.lang.Throwable>> oneValueOrError(K key)

Deprecated.

Extact one value from the selected pipe or an empty Maybe if it doesn't exist. Currently only Adapter's and not Publishers are managed by Pipes so Publisher errors are not propagated (@see oneValue(Object) or @see oneOrError(Object) is better at the moment.

   
  Queue<String> q = new Queue<>();
        pipes.register("hello", q);
        pipes.push("hello", "world");
        pipes.push("hello", "world2");
      
        
        pipes.oneValueOrError("hello").get(); //Try["world"]
       
  
  

Parameters:

key - : Adapter identifier

Returns:

oneOrErrorAsync

public Future<V> oneOrErrorAsync(K key,
                                 java.util.concurrent.Executor ex)

Asynchronously extract a value from the Adapter identified by the provided Key

  
  Queue<String> q = new Queue<>();
        pipes.register("hello", q);
        pipes.push("hello", "world");
        pipes.push("hello", "world2");
       
        pipes.oneOrErrorAsync("hello", ex) // Future.ofResult("world")
 
 
 

Parameters:

key - : Adapter identifier

ex - Executor to extract value from Adapter from on

Returns:

Future containing either next value or NoSuchElementException

nextValue

public Eval<Maybe<V>> nextValue(K key)

Return an Eval that allows retrieval of the next value from the attached pipe when get() is called, can be used as an Iterator over the future & present values in the Adapter Maybe.some is returned if a value is present, Maybe.none is returned if the publisher is complete or an error occurs

  
  Queue<String> q = new Queue<>();
        pipes.register("hello", q);
        pipes.push("hello", "world");
        pipes.push("hello", "world2");
        q.close();
        Eval<Maybe<String>> nextValue = pipes.nextValue("hello");
        int values = 0;
        while(nextValue.get().isPresent()){
            System.out.println(values++);
            
        }
            
        assertThat(values,equalTo(2));
 
 
 
 

Parameters:

key - : Adapter identifier

Returns:

Eval that can lazily extract the next Value from the Adapter identified by the provided key once triggered

nextOrNull

public Eval<V> nextOrNull(K key)

Return an Eval that allows retrieval of the next value from the attached pipe when get() is called A value is returned if a value is present, otherwise null is returned if the publisher is complete or an error occurs

  
  Queue<String> q = new Queue<>();
        pipes.register("hello", q);
        pipes.push("hello", "world");
        pipes.push("hello", "world2");
        q.close();
        Eval<String> nextValue = pipes.nextOrNull("hello");
        int values = 0;
        while(nextValue.get()!=null){
            System.out.println(values++);
            
        }
            
        assertThat(values,equalTo(2));
 
 
 
 

Parameters:

key - : Adapter identifier

Returns:

Eval that can lazily extract the next Value from the Adapter identified by the provided key once triggered

register

public void register(K key,
                     Adapter<V> adapter)

Register a Queue, and get back a listening LazyFutureStream that runs on a single thread (not the calling thread)

 
 Pipes.register("test", QueueFactories.
    										<String>boundedNonBlockingQueue(100)
    											.build());
    	LazyFutureStream<String> stream =  PipesToLazyStreams.cpuBoundStream("test");
    	stream.filter(it->it!=null).peek(System.out::println).run();
 
 

Parameters:

key - : Adapter identifier

adapter -

clear

public void clear()

Clear all managed Adapters (without closing them or performing any other operation on them)

subscribeTo

public void subscribeTo(K key,
                        org.reactivestreams.Subscriber<V> subscriber)

Subscribe synchronously to a pipe

Parameters:

key - for registered simple-react async.Adapter

subscriber - Reactive Streams subscriber for data on this pipe

subscribeTo

public void subscribeTo(K key,
                        org.reactivestreams.Subscriber<V> subscriber,
                        java.util.concurrent.Executor subscribeOn)

Subscribe asynchronously to a pipe

   
  SeqSubscriber<String> subscriber = SeqSubscriber.subscriber();
        Queue<String> queue = new Queue();
        pipes.register("hello", queue);
        pipes.subscribeTo("hello",subscriber,ForkJoinPool.commonPool());
        queue.offer("world");
        queue.close();
       
        assertThat(subscriber.stream().findAny().get(),equalTo("world"));
  
  
  
  

Parameters:

key - for registered simple-react async.Adapter

subscriber - Reactive Streams subscriber for data on this pipe

publishTo

public void publishTo(K key,
                      org.reactivestreams.Publisher<V> publisher)

Synchronously publish data to the Adapter specified by the provided Key, blocking the current thread

Parameters:

key - for registered cylops-react async.Adapter

publisher - Reactive Streams publisher to push data onto this pipe

publishToAsync

public void publishToAsync(K key,
                           org.reactivestreams.Publisher<V> publisher)

Asynchronously publish data to the Adapter specified by the provided Key

  
  Pipes<String,Integer> pipes = Pipes.of();
        Queue<Integer> queue = new Queue();
        pipes.register("hello", queue);
        
        pipes.publishToAsync("hello",ReactiveSeq.of(1,2,3));
        
        Thread.sleep(100);
        queue.offer(4);
        queue.close();
       
        assertThat(queue.stream().toList(),equalTo(Arrays.asList(1,2,3,4)));
 
 
 

Parameters:

key - for registered simple-react async.Adapter

publisher - Reactive Streams publisher to push data onto this pipe

close

public void close(java.lang.String key)

Close the Adapter identified by the provided Key if it exists

Parameters:

key - : Adapter identifier