/** * Create an Subscriber for Observable style asynchronous push based Streams. * Streams generated from AsyncSubscribers are not backpressure aware (in cases * where backpressue is not needed they may perform better). * For backpressure aware Streams see {@link Spouts#reactiveSubscriber} * * @param <T> Stream data type * @return Async Stream Subscriber */ static <T> AsyncSubscriber<T> asyncSubscriber(){ return new AsyncSubscriber<T>(); }
public static <T> ValueSubscriber<T> subscriber() { return new ValueSubscriber<>( () -> { }); }
/** * Create a QueueBasedSubscriber, backed by a JDK LinkedBlockingQueue * * @param counter Counter for tracking connections to the queue and data volumes * @param maxConcurrency Maximum number of subscriptions * @return QueueBasedSubscriber */ public static <T> QueueBasedSubscriber<T> subscriber(final Counter counter, final int maxConcurrency) { return new QueueBasedSubscriber<>( counter, maxConcurrency); }
static <T> ReactiveSeq<T> enqueuedAll(Consumer<? super Subscriber<T>>... subs){ final Counter c = new Counter(); c.active.set(subs.length); QueueBasedSubscriber<T> s = QueueBasedSubscriber.subscriber(c,subs.length); for(Consumer<? super Subscriber<T>> next : subs) next.accept(s); s.close(); return s.reactiveSeq(); } static <T> ReactiveSeq<T> enqueued(Queue<T> q,Consumer<? super Subscriber<T>> sub){
static <T> ReactiveSeq<T> enqueued(Queue<T> q,Consumer<? super Subscriber<T>> sub){ final Counter c = new Counter(); c.active.set(1); QueueBasedSubscriber<T> s = QueueBasedSubscriber.subscriber(q,c,1); sub.accept(s); return s.reactiveSeq(); } static <T> ReactiveSeq<T> enqueued(QueueFactory<T> factory, Consumer<? super Subscriber<T>>... subs){
@Override public Subscriber<Long> createSubscriber() { return new QueueBasedSubscriber(new QueueBasedSubscriber.Counter(),500); }
@Override public void onComplete() { PushSubscriber.this.onComplete(); } };
@Override public void onNext(T t) { PushSubscriber.this.onNext(t); }
@Override default <X extends Throwable> Subscription forEachSubscribe(Consumer<? super T> consumer, Consumer<? super Throwable> consumerError){ Subscription result = ReactiveStreamsTerminalOperations.super.forEachSubscribe(consumer,consumerError,()->{}); return result; }
/** * Request all elements to be processed from the processing Stream */ public void requestAll() { request(Long.MAX_VALUE); }
/** * Request all elements to be processed asynchronously in the processing stream * * @return New ReactiveTask that references the execution of the new async task */ public ReactiveTask requestAllAsync() { return requestAsync(Long.MAX_VALUE); }
@Override public void onError(Throwable t) { PushSubscriber.this.onError(t); }
/** * The recommended way to connect a Spout to a Publisher is via Spouts#from * Create an Subscriber for Observable style asynchronous push based Streams, * that implements backpressure internally via the reactive-streams spec. * * Subscribers signal demand via their subscription and publishers push data to subscribers * synchronously or asynchronously, never exceeding signalled demand * * @param <T> Stream data type * @return An async Stream Subscriber that supports efficient backpressure via reactive-streams */ static <T> ReactiveSubscriber<T> reactiveSubscriber(){ return new ReactiveSubscriber<T>(); }
@Override public void onNext(Long aLong) { probe.registerOnNext(aLong); super.onNext(aLong); }
@Override public void onComplete() { probe.registerOnComplete(); super.onComplete(); } };
static <T> ReactiveSeq<T> enqueued(QueueFactory<T> factory, Consumer<? super Subscriber<T>>... subs){ final Counter c = new Counter(); c.active.set(subs.length); QueueBasedSubscriber<T> s = QueueBasedSubscriber.subscriber(factory,c,subs.length); for(Consumer<? super Subscriber<T>> next : subs) next.accept(s); return s.reactiveSeq(); }
/** * Create a QueueBasedSubscriber, backed by the provided Queue * * @param q Queue backing the reactiveSubscriber * @param counter Counter for tracking connections to the queue and data volumes * @param maxConcurrency Maximum number of subscriptions * @return QueueBasedSubscriber */ public static <T> QueueBasedSubscriber<T> subscriber(final Queue<T> q, final Counter counter, final int maxConcurrency) { return new QueueBasedSubscriber<>( q, counter, maxConcurrency); }
public static <T> ValueSubscriber<T> subscriber(final Runnable onComplete) { return new ValueSubscriber<>( onComplete); }
@Override default <X extends Throwable> Subscription forEachSubscribe(Consumer<? super T> consumer, Consumer<? super Throwable> consumerError, Runnable onComplete){ Subscription result = ReactiveStreamsTerminalOperations.super.forEachSubscribe(consumer,consumerError,onComplete); return result; } @Override
/** * Create a QueueBasedSubscriber, backed by a Queue that will be created with the provided QueueFactory * * @param factory QueueFactory * @param counter Counter for tracking connections to the queue and data volumes * @param maxConcurrency Maximum number of subscriptions * @return QueueBasedSubscriber */ public static <T> QueueBasedSubscriber<T> subscriber(final QueueFactory<T> factory, final Counter counter, final int maxConcurrency) { return new QueueBasedSubscriber<>( factory, counter, maxConcurrency); }