org.reactivestreams.Subscription - java examples

Here are the examples of the java api org.reactivestreams.Subscription taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

155 Examples 7

19 View Complete Implementation : FullArbiterSubscriber.java
Copyright Apache License 2.0
Author : akarnokd
/**
 * Subscriber that communicates with a FullArbiter.
 *
 * @param <T> the value type
 */
public final clreplaced FullArbiterSubscriber<T> implements RelaxedSubscriber<T> {

    final FullArbiter<T> arbiter;

    Subscription s;

    public FullArbiterSubscriber(FullArbiter<T> arbiter) {
        this.arbiter = arbiter;
    }

    @Override
    public void onSubscribe(Subscription s) {
        if (SubscriptionHelper.validate(this.s, s)) {
            this.s = s;
            arbiter.setSubscription(s);
        }
    }

    @Override
    public void onNext(T t) {
        arbiter.onNext(t, s);
    }

    @Override
    public void onError(Throwable t) {
        arbiter.onError(t, s);
    }

    @Override
    public void onComplete() {
        arbiter.onComplete(s);
    }
}

19 View Complete Implementation : FutureSubscriber.java
Copyright Apache License 2.0
Author : akarnokd
@Override
public void onSubscribe(Subscription s) {
    if (SubscriptionHelper.setOnce(this.s, s)) {
        s.request(Long.MAX_VALUE);
    }
}

19 View Complete Implementation : EventLoopProcessor.java
Copyright Apache License 2.0
Author : reactor
@Override
final public void onSubscribe(final Subscription s) {
    if (Operators.validate(upstreamSubscription, s)) {
        this.upstreamSubscription = s;
        try {
            if (s != Operators.emptySubscription()) {
                requestTask(s);
            }
        } catch (Throwable t) {
            onError(Operators.onOperatorError(s, t, currentContext()));
        }
    }
}

19 View Complete Implementation : DelegateProcessor.java
Copyright Apache License 2.0
Author : reactor
@Override
public void onSubscribe(Subscription s) {
    upstream.onSubscribe(s);
}

19 View Complete Implementation : SubscriptionArbiter.java
Copyright Apache License 2.0
Author : akarnokd
@Override
public final void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        if (unbounded) {
            return;
        }
        if (get() == 0 && compareAndSet(0, 1)) {
            long r = requested;
            if (r != Long.MAX_VALUE) {
                r = BackpressureHelper.addCap(r, n);
                requested = r;
                if (r == Long.MAX_VALUE) {
                    unbounded = true;
                }
            }
            Subscription a = actual;
            if (decrementAndGet() != 0) {
                drainLoop();
            }
            if (a != null) {
                a.request(n);
            }
            return;
        }
        BackpressureHelper.add(missedRequested, n);
        drain();
    }
}

19 View Complete Implementation : BaseSubscriber.java
Copyright Apache License 2.0
Author : reactor
/**
 * Hook for further processing of onSubscribe's Subscription. Implement this method
 * to call {@link #request(long)} as an initial request. Values other than the
 * unbounded {@code Long.MAX_VALUE} imply that you'll also call request in
 * {@link #hookOnNext(Object)}.
 * <p> Defaults to request unbounded Long.MAX_VALUE as in {@link #requestUnbounded()}
 *
 * @param subscription the subscription to optionally process
 */
protected void hookOnSubscribe(Subscription subscription) {
    subscription.request(Long.MAX_VALUE);
}

19 View Complete Implementation : FullArbiterSubscriber.java
Copyright Apache License 2.0
Author : akarnokd
@Override
public void onSubscribe(Subscription s) {
    if (SubscriptionHelper.validate(this.s, s)) {
        this.s = s;
        arbiter.setSubscription(s);
    }
}

19 View Complete Implementation : PerfSubscriber.java
Copyright Apache License 2.0
Author : akarnokd
@Override
public void onSubscribe(Subscription s) {
    s.request(Long.MAX_VALUE);
}

19 View Complete Implementation : MaxRequestSubscription.java
Copyright Apache License 2.0
Author : akarnokd
@Override
public void accept(Subscription t) throws Exception {
    t.request(Long.MAX_VALUE);
}

19 View Complete Implementation : EventLoopProcessor.java
Copyright Apache License 2.0
Author : reactor
final void decrementSubscribers() {
    Subscription subscription = upstreamSubscription;
    int subs = SUBSCRIBER_COUNT.decrementAndGet(this);
    if (subs == 0) {
        if (subscription != null && autoCancel) {
            upstreamSubscription = null;
            cancel();
        }
    }
}

19 View Complete Implementation : ResourceSubscriber.java
Copyright Apache License 2.0
Author : akarnokd
@Override
public final void onSubscribe(Subscription s) {
    if (EndSubscriberHelper.setOnce(this.s, s, getClreplaced())) {
        long r = missedRequested.getAndSet(0L);
        if (r != 0L) {
            s.request(r);
        }
        onStart();
    }
}

19 View Complete Implementation : BlockingOptionalMonoSubscriber.java
Copyright Apache License 2.0
Author : reactor
@Override
public final void onSubscribe(Subscription s) {
    this.s = s;
    if (!cancelled) {
        s.request(Long.MAX_VALUE);
    }
}

19 View Complete Implementation : FutureStreamUtils.java
Copyright Apache License 2.0
Author : aol
/**
 * Perform a forEach operation over the Stream  without closing it,  capturing any elements and errors in the supplied consumers, but only consuming
 * the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription,
 * when the entire Stream has been processed an onComplete event will be recieved.
 *
 * <pre>
 * {@code
 *     Subscription next = Streams.forEach(Stream.of(()->1,()->2,()->throw new RuntimeException(),()->4)
 *                                  .map(Supplier::getValue) ,System.out::println, e->e.printStackTrace(),()->System.out.println("the take!"));
 *
 *     System.out.println("First batch processed!");
 *
 *     next.request(2);
 *
 *      System.out.println("Second batch processed!");
 *
 *     //prints
 *     1
 *     2
 *     First batch processed!
 *
 *     RuntimeException Stack Trace on System.err
 *
 *     4
 *     Second batch processed!
 *     The take!
 * }
 * </pre>
 * @param stream - the Stream to consume data from
 * @param x To consume from the Stream at this time
 * @param consumerElement To accept incoming elements from the Stream
 * @param consumerError To accept incoming processing errors from the Stream
 * @param onComplete To run after an onComplete event
 * @return Subscription so that further processing can be continued or cancelled.
 */
public static <T, X extends Throwable> Tuple3<CompletableFuture<Subscription>, Runnable, CompletableFuture<Boolean>> forEachXEvents(final Stream<T> stream, final long x, final Consumer<? super T> consumerElement, final Consumer<? super Throwable> consumerError, final Runnable onComplete) {
    final CompletableFuture<Boolean> streamCompleted = new CompletableFuture<>();
    final Subscription s = new Subscription() {

        Iterator<T> it = stream.iterator();

        volatile boolean running = true;

        @Override
        public void request(final long n) {
            for (int i = 0; i < n && running; i++) {
                try {
                    if (it.hasNext()) {
                        consumerElement.accept(it.next());
                    } else {
                        try {
                            onComplete.run();
                        } finally {
                            streamCompleted.complete(true);
                            break;
                        }
                    }
                } catch (final Throwable t) {
                    consumerError.accept(t);
                }
            }
        }

        @Override
        public void cancel() {
            running = false;
        }
    };
    final CompletableFuture<Subscription> subscription = CompletableFuture.completedFuture(s);
    return tuple(subscription, () -> {
        s.request(x);
    }, streamCompleted);
}

19 View Complete Implementation : MonoProcessor.java
Copyright Apache License 2.0
Author : reactor
@Override
public final void onSubscribe(Subscription subscription) {
    if (Operators.setOnce(UPSTREAM, this, subscription)) {
        subscription.request(Long.MAX_VALUE);
    }
}

19 View Complete Implementation : ForEachWhileSubscriber.java
Copyright Apache License 2.0
Author : akarnokd
@Override
public void onSubscribe(Subscription s) {
    if (SubscriptionHelper.setOnce(this, s)) {
        s.request(Long.MAX_VALUE);
    }
}

19 View Complete Implementation : AsyncSubscription.java
Copyright Apache License 2.0
Author : akarnokd
/**
 * Sets the given subscription if there isn't any subscription held.
 * @param s the first and only subscription to set
 */
public void setSubscription(Subscription s) {
    SubscriptionHelper.deferredSetOnce(actual, this, s);
}

19 View Complete Implementation : StrictSubscriber.java
Copyright Apache License 2.0
Author : reactor
@Override
public void request(long n) {
    if (n <= 0) {
        cancel();
        onError(new IllegalArgumentException("§3.9 violated: positive request amount required but it was " + n));
        return;
    }
    Subscription a = s;
    if (a != null) {
        a.request(n);
    } else {
        Operators.addCap(REQUESTED, this, n);
        a = s;
        if (a != null) {
            long r = REQUESTED.getAndSet(this, 0L);
            if (r != 0L) {
                a.request(n);
            }
        }
    }
}

19 View Complete Implementation : PerfConsumer.java
Copyright Apache License 2.0
Author : akarnokd
@Override
public void onSubscribe(Subscription s) {
    s.request(Long.MAX_VALUE);
}

19 View Complete Implementation : PerfAsyncConsumer.java
Copyright Apache License 2.0
Author : akarnokd
@Override
public void onSubscribe(Subscription s) {
    s.request(Long.MAX_VALUE);
}

19 View Complete Implementation : DefaultSubscriber.java
Copyright Apache License 2.0
Author : akarnokd
@Override
public final void onSubscribe(Subscription s) {
    if (EndSubscriberHelper.validate(this.s, s, getClreplaced())) {
        this.s = s;
        onStart();
    }
}

19 View Complete Implementation : BlockingSubscriber.java
Copyright Apache License 2.0
Author : akarnokd
@Override
public void onSubscribe(Subscription s) {
    if (SubscriptionHelper.setOnce(this, s)) {
        queue.offer(NotificationLite.subscription(this));
    }
}

19 View Complete Implementation : BaseSubscriber.java
Copyright Apache License 2.0
Author : reactor
@Override
public final void request(long n) {
    if (Operators.validate(n)) {
        Subscription s = this.subscription;
        if (s != null) {
            s.request(n);
        }
    }
}

19 View Complete Implementation : BaseSubscriber.java
Copyright Apache License 2.0
Author : reactor
@Override
public final void onSubscribe(Subscription s) {
    if (Operators.setOnce(S, this, s)) {
        try {
            hookOnSubscribe(s);
        } catch (Throwable throwable) {
            onError(Operators.onOperatorError(s, throwable, currentContext()));
        }
    }
}

19 View Complete Implementation : WorkQueueProcessor.java
Copyright Apache License 2.0
Author : reactor
@Override
protected void requestTask(Subscription s) {
    requestTaskExecutor.execute(createRequestTask(s, this, null, ringBuffer::getMinimumGatingSequence));
}

19 View Complete Implementation : AsyncSubscriber.java
Copyright Apache License 2.0
Author : aol
@Override
public void onSubscribe(final Subscription s) {
}

19 View Complete Implementation : InnerQueuedSubscriber.java
Copyright Apache License 2.0
Author : akarnokd
@Override
public void onSubscribe(Subscription s) {
    if (SubscriptionHelper.setOnce(this, s)) {
        if (s instanceof FusedQueueSubscription) {
            @SuppressWarnings("unchecked")
            FusedQueueSubscription<T> qs = (FusedQueueSubscription<T>) s;
            int m = qs.requestFusion(FusedQueueSubscription.ANY);
            if (m == FusedQueueSubscription.SYNC) {
                fusionMode = m;
                queue = qs;
                done = true;
                parent.innerComplete(this);
                return;
            }
            if (m == FusedQueueSubscription.ASYNC) {
                fusionMode = m;
                queue = qs;
                QueueDrainHelper.request(s, prefetch);
                return;
            }
        }
        queue = QueueDrainHelper.createQueue(prefetch);
        QueueDrainHelper.request(s, prefetch);
    }
}

19 View Complete Implementation : SerializedSubscriber.java
Copyright Apache License 2.0
Author : reactor
@Override
public void onSubscribe(Subscription s) {
    if (Operators.validate(this.s, s)) {
        this.s = s;
        actual.onSubscribe(this);
    }
}

19 View Complete Implementation : BufferingSinkOperator.java
Copyright Apache License 2.0
Author : aol
@Override
public StreamSubscription subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onComplete) {
    Subscription[] delegate = { null };
    StreamSubscription ss = new StreamSubscription() {

        @Override
        public void request(long n) {
            super.request(n);
            delegate[0].request(n);
            processQueue(this, onNext);
        }
    };
    sub.accept(new Subscriber<T>() {

        @Override
        public void onSubscribe(Subscription s) {
            delegate[0] = s;
        }

        @Override
        public void onNext(T t) {
            if (!q.offer(t)) {
                policy.match(t).map(v -> {
                    while (!q.offer(t)) {
                        Thread.yield();
                        processQueue(ss, onNext);
                    }
                    return v;
                });
            }
            processQueue(ss, onNext);
        }

        @Override
        public void onError(Throwable t) {
            onError.accept(t);
        }

        @Override
        public void onComplete() {
            onComplete.run();
        }
    });
    return ss;
}

19 View Complete Implementation : EventLoopProcessor.java
Copyright Apache License 2.0
Author : reactor
protected void requestTask(final Subscription s) {
// implementation might run a specific request task for the given subscription
}

19 View Complete Implementation : EmitterProcessor.java
Copyright Apache License 2.0
Author : reactor
@Override
public void onSubscribe(final Subscription s) {
    if (Operators.setOnce(S, this, s)) {
        if (s instanceof Fuseable.QueueSubscription) {
            @SuppressWarnings("unchecked")
            Fuseable.QueueSubscription<T> f = (Fuseable.QueueSubscription<T>) s;
            int m = f.requestFusion(Fuseable.ANY);
            if (m == Fuseable.SYNC) {
                sourceMode = m;
                queue = f;
                drain();
                return;
            } else if (m == Fuseable.ASYNC) {
                sourceMode = m;
                queue = f;
                s.request(Operators.unboundedOrPrefetch(prefetch));
                return;
            }
        }
        queue = Queues.<T>get(prefetch).get();
        s.request(Operators.unboundedOrPrefetch(prefetch));
    }
}

19 View Complete Implementation : TopicProcessor.java
Copyright Apache License 2.0
Author : reactor
@Override
protected void requestTask(Subscription s) {
    minimum.set(ringBuffer.getCursor());
    ringBuffer.addGatingSequence(minimum);
    requestTaskExecutor.execute(createRequestTask(s, this, minimum::set, () -> SUBSCRIBER_COUNT.get(TopicProcessor.this) == 0 ? minimum.getAsLong() : ringBuffer.getMinimumGatingSequence(minimum)));
}

19 View Complete Implementation : ValueSubscriber.java
Copyright Apache License 2.0
Author : aol
/**
 * A reactive-streams Subscriber that can take 1 value from a reactive-streams publisher and convert
 * it into various forms
 *
 * <pre>
 * {@code
 *    ValueSubscriber<Integer> anInt = ValueSubscriber.reactiveSubscriber();
 *    ReactiveSeq.of(1,2,3)
 *               .publish(anInt);
 *
 *    Xor<Throwable,Integer> either = anInt.toLazyEither();
 *    Try<Integer,Throwable> myTry = either.toTry();
 *    Maybe<Integer> maybe = myTry.toMaybe();
 *    Optional<Integer> maybe = maybe.toOptional();
 * }
 * </pre>
 *
 * @author johnmcclean
 *
 * @param <T> Subscriber type
 */
public clreplaced ValueSubscriber<T> implements Subscriber<T>, Value<T> {

    private final Object UNSET = new Object();

    private final AtomicReference firstValue = new AtomicReference(UNSET);

    private final AtomicReference firstError = new AtomicReference(UNSET);

    private final Runnable onComplete;

    private volatile Subscription s;

    private final Runnable requestOne = Memoize.memoizeRunnable(() -> this.s.request(1l));

    private ValueSubscriber(final Runnable onComplete) {
        super();
        this.onComplete = onComplete;
    }

    public static <T> ValueSubscriber<T> subscriber(final Runnable onComplete) {
        return new ValueSubscriber<>(onComplete);
    }

    public static <T> ValueSubscriber<T> subscriber() {
        return new ValueSubscriber<>(() -> {
        });
    }

    @Override
    public void onSubscribe(final Subscription s) {
        Objects.requireNonNull(s);
        if (this.s == null) {
            this.s = s;
            s.request(1);
        } else
            s.cancel();
    }

    @Override
    public void onNext(final T t) {
        Objects.requireNonNull(t);
        firstValue.compareAndSet(UNSET, t);
    }

    @Override
    public void onError(final Throwable t) {
        Objects.requireNonNull(t);
        firstError.compareAndSet(UNSET, t);
    }

    @Override
    public void onComplete() {
        this.onComplete.run();
        if (firstValue.get() == UNSET && firstError.get() == UNSET) {
            firstError.set(new NoSuchElementException("publisher has no elements"));
        }
    }

    public void requestOne() {
        firstValue.set(UNSET);
        firstError.set(UNSET);
        this.s.request(1);
    }

    @Override
    public T orElse(T alt) {
        while (firstValue.get() == UNSET && firstError.get() == UNSET) LockSupport.parkNanos(1000000l);
        if (firstValue.get() == UNSET)
            return alt;
        return (T) firstValue.get();
    }

    @Override
    public T orElseGet(Supplier<? extends T> alt) {
        while (firstValue.get() == UNSET && firstError.get() == UNSET) LockSupport.parkNanos(1000000l);
        if (firstValue.get() == UNSET)
            return alt.get();
        return (T) firstValue.get();
    }

    public Either<Throwable, T> toEither() {
        if (orElse(null) == null && firstError.get() != UNSET) {
            return Either.left((Throwable) firstError.get());
        }
        return Either.right(orElse(null));
    }

    private T throwingGet() {
        while (firstValue.get() == UNSET && firstError.get() == UNSET) LockSupport.parkNanos(1000000l);
        if (firstValue.get() == UNSET)
            throw ExceptionSoftener.throwSoftenedException((Throwable) firstError.get());
        return (T) firstValue.get();
    }

    public <X extends Throwable> Try<T, X> toTry(final Clreplaced<X>... clreplacedes) {
        return Try.withCatch(() -> throwingGet(), clreplacedes);
    }

    public Ior<Throwable, T> toIor() {
        orElse(null);
        Ior<Throwable, T> secondary = null;
        Ior<Throwable, T> primary = null;
        if (firstError.get() != UNSET) {
            secondary = Ior.<Throwable, T>left((Throwable) firstError.get());
        }
        if (firstValue.get() != UNSET) {
            primary = Ior.<Throwable, T>right((T) firstValue.get());
        }
        if (secondary != null && primary != null)
            return Ior.both((Throwable) firstError.get(), (T) firstValue.get());
        if (primary != null)
            return primary;
        return secondary;
    }

    @Override
    public <R> R fold(Function<? super T, ? extends R> present, Supplier<? extends R> absent) {
        while (firstValue.get() == UNSET && firstError.get() == UNSET) LockSupport.parkNanos(1000000l);
        if (firstValue.get() == UNSET)
            return absent.get();
        return present.apply((T) firstValue.get());
    }

    public Future<T> toFutureAsync(final Executor ex) {
        return Future.of(() -> orElse(null), ex);
    }
}

19 View Complete Implementation : BlockingSingleSubscriber.java
Copyright Apache License 2.0
Author : reactor
@Override
public final void onSubscribe(Subscription s) {
    this.s = s;
    if (!cancelled) {
        s.request(Long.MAX_VALUE);
    }
}

19 View Complete Implementation : DisposableSubscriber.java
Copyright Apache License 2.0
Author : akarnokd
@Override
public final void onSubscribe(Subscription s) {
    if (EndSubscriberHelper.setOnce(this.s, s, getClreplaced())) {
        onStart();
    }
}

19 View Complete Implementation : StrictSubscriber.java
Copyright Apache License 2.0
Author : reactor
@Override
public void onSubscribe(Subscription s) {
    if (Operators.validate(this.s, s)) {
        actual.onSubscribe(this);
        if (Operators.setOnce(S, this, s)) {
            long r = REQUESTED.getAndSet(this, 0L);
            if (r != 0L) {
                s.request(r);
            }
        }
    } else {
        onError(new IllegalStateException("§2.12 violated: onSubscribe must be called at most once"));
    }
}

19 View Complete Implementation : CapturingOperator.java
Copyright Apache License 2.0
Author : aol
public void setSubscription(Subscription s) {
    this.s = s;
}

19 View Complete Implementation : DefaultSubscriber.java
Copyright Apache License 2.0
Author : akarnokd
/**
 * Requests from the upstream Subscription.
 * @param n the request amount, positive
 */
protected final void request(long n) {
    Subscription s = this.s;
    if (s != null) {
        s.request(n);
    }
}

18 View Complete Implementation : AbstractOperatorTest.java
Copyright Apache License 2.0
Author : aol
@Test
public void subscribeOneMaxLong() throws Exception {
    Subscription sub = one.subscribe(values::add, errors::add, () -> onComplete = true);
    sub.request(Long.MAX_VALUE);
    replacedertThat(values.size(), equalTo(1));
    replacedertThat(errors.size(), equalTo(0));
    replacedertTrue(onComplete);
    sub.request(1l);
    replacedertThat("Values " + values, values.size(), equalTo(1));
    replacedertThat(errors.size(), equalTo(0));
    replacedertTrue(onComplete);
}

18 View Complete Implementation : AbstractOperatorTest.java
Copyright Apache License 2.0
Author : aol
@Test
public void subscribeTwoAndErrorMaxLong() throws Exception {
    Subscription sub = twoAndError.subscribe(values::add, errors::add, () -> onComplete = true);
    sub.request(Long.MAX_VALUE);
    replacedertThat(values.size(), equalTo(2));
    replacedertThat(errors.size(), equalTo(1));
    replacedertTrue(onComplete);
    sub.request(1l);
    replacedertThat("Values " + values, values.size(), equalTo(2));
    replacedertThat(errors.size(), equalTo(1));
    replacedertTrue(onComplete);
    sub.request(3l);
    replacedertThat("Values " + values, values.size(), equalTo(2));
    replacedertThat(errors.size(), equalTo(1));
    replacedertTrue(onComplete);
}

18 View Complete Implementation : SpoutsTest.java
Copyright Apache License 2.0
Author : aol
@Test
public void reactiveBuffer() throws InterruptedException {
    Subscription sub = Spouts.reactiveBuffer(16, s -> {
        s.onSubscribe(new Subscription() {

            @Override
            public void request(long n) {
                if (i == 0) {
                    Effect e = () -> {
                        s.onNext("hello " + i++);
                    };
                    e.cycle(30).runAsync();
                }
            }

            @Override
            public void cancel() {
            }
        });
    }).forEach(2, in -> count++);
    // count will be 2, buffer will be 16
    Thread.sleep(500);
    sub.request(30);
    replacedertThat(i, equalTo(30));
    replacedertThat(count, equalTo(18));
}

18 View Complete Implementation : LazyConcat.java
Copyright Apache License 2.0
Author : aol
public void nextSub(Operator<IN> op) {
    Subscription local = op.subscribe(this::onNext, this::onError, this::onComplete);
    if (processAll) {
        local.request(Long.MAX_VALUE);
        active.set(local);
        return;
    }
    if (wip.compareAndSet(0, 1)) {
        active.set(local);
        long r = requested.get();
        if (decrementAndCheckActive()) {
            this.addMissingRequests();
        }
        if (r > 0) {
            local.request(r);
        }
        return;
    }
    next.set(local);
    if (incrementAndCheckInactive()) {
        this.addMissingRequests();
        return;
    }
    return;
}

18 View Complete Implementation : AbstractOperatorTest.java
Copyright Apache License 2.0
Author : aol
@Test
public void subscribeThreeMaxLong() throws Exception {
    Subscription sub = three.subscribe(values::add, errors::add, () -> onComplete = true);
    sub.request(Long.MAX_VALUE);
    replacedertThat(values.size(), equalTo(3));
    replacedertThat(errors.size(), equalTo(0));
    replacedertTrue(onComplete);
    sub.request(1l);
    replacedertThat("Values " + values, values.size(), equalTo(3));
    replacedertThat(errors.size(), equalTo(0));
    replacedertTrue(onComplete);
    sub.request(3l);
    replacedertThat("Values " + values, values.size(), equalTo(3));
    replacedertThat(errors.size(), equalTo(0));
    replacedertTrue(onComplete);
}

18 View Complete Implementation : AbstractOperatorTest.java
Copyright Apache License 2.0
Author : aol
@Test
public void subscribeOne() throws Exception {
    Subscription sub = one.subscribe(values::add, errors::add, () -> onComplete = true);
    sub.request(1l);
    replacedertThat(values.size(), equalTo(1));
    replacedertThat(errors.size(), equalTo(0));
    sub.request(1l);
    replacedertThat("Values " + values, values.size(), equalTo(1));
    replacedertThat(errors.size(), equalTo(0));
    replacedertTrue(onComplete);
}

18 View Complete Implementation : SpoutsTest.java
Copyright Apache License 2.0
Author : aol
@Test
public void reactiveBufferCycle() throws InterruptedException {
    counter = new AtomicInteger(0);
    Subscription sub = Spouts.reactiveBuffer(10, s -> {
        s.onSubscribe(new Subscription() {

            @Override
            public void request(long n) {
                if (counter.get() == 0) {
                    Effect e = () -> {
                        s.onNext("hello " + counter.incrementAndGet());
                    };
                    e.cycleAsync(30, ex).run();
                }
            }

            @Override
            public void cancel() {
            }
        });
    }).forEach(2, in -> count++);
    Thread.sleep(510);
    sub.request(30);
    replacedertThat(counter.get(), equalTo(30));
    replacedertThat(count, equalTo(18));
}

18 View Complete Implementation : AbstractOperatorTest.java
Copyright Apache License 2.0
Author : aol
@Test
public void subscribeThreeErrorsMaxLong() throws Exception {
    Subscription sub = threeErrors.subscribe(values::add, errors::add, () -> onComplete = true);
    sub.request(Long.MAX_VALUE);
    replacedertThat(values.size(), equalTo(0));
    replacedertThat(errors.size(), equalTo(3));
    replacedertTrue(onComplete);
    sub.request(1l);
    replacedertThat("Values " + values, values.size(), equalTo(0));
    replacedertThat(errors.size(), equalTo(3));
    replacedertTrue(onComplete);
    sub.request(3l);
    replacedertThat("Values " + values, values.size(), equalTo(0));
    replacedertThat(errors.size(), equalTo(3));
    replacedertTrue(onComplete);
}

18 View Complete Implementation : Concat.java
Copyright Apache License 2.0
Author : aol
public boolean subscribeNext() {
    if (index == operators.size()) {
        if (!finished) {
            finished = true;
            onComplete.run();
        }
        return true;
    }
    Subscription local = operators.getOrElse(index, null).subscribe(this::onNext, this::onError, this::onComplete);
    if (processAll) {
        local.request(Long.MAX_VALUE);
        active.set(local);
        return false;
    }
    if (wip.compareAndSet(0, 1)) {
        active.set(local);
        long r = requested.get();
        if (decrementAndCheckActive()) {
            this.addMissingRequests();
        }
        if (r > 0)
            local.request(r);
        return false;
    }
    next.set(local);
    if (incrementAndCheckInactive()) {
        this.addMissingRequests();
        return false;
    }
    return false;
}

18 View Complete Implementation : AbstractOperatorTest.java
Copyright Apache License 2.0
Author : aol
@Test
public void subscribeThreeErrors() throws Exception {
    Subscription sub = threeErrors.subscribe(values::add, errors::add, () -> onComplete = true);
    sub.request(1l);
    replacedertThat(values.size(), equalTo(0));
    replacedertThat(errors.size(), equalTo(1));
    replacedertFalse(onComplete);
    sub.request(1l);
    replacedertThat("Values " + values, values.size(), equalTo(0));
    replacedertThat(errors.size(), equalTo(2));
    replacedertFalse(onComplete);
    sub.request(1l);
    replacedertThat("Values " + values, values.size(), equalTo(0));
    replacedertThat(errors.size(), equalTo(3));
    sub.request(1l);
    replacedertThat("Values " + values, values.size(), equalTo(0));
    replacedertThat(errors.size(), equalTo(3));
    replacedertTrue(onComplete);
}

18 View Complete Implementation : AbstractOperatorTest.java
Copyright Apache License 2.0
Author : aol
@Test
public void subscribeThree() throws Exception {
    Subscription sub = three.subscribe(values::add, errors::add, () -> onComplete = true);
    sub.request(1l);
    replacedertThat(values.size(), equalTo(1));
    replacedertThat(errors.size(), equalTo(0));
    replacedertFalse(onComplete);
    sub.request(1l);
    replacedertThat("Values " + values, values.size(), equalTo(2));
    replacedertThat(errors.size(), equalTo(0));
    replacedertFalse(onComplete);
    sub.request(3l);
    replacedertThat("Values " + values, values.size(), equalTo(3));
    replacedertThat(errors.size(), equalTo(0));
    replacedertTrue(onComplete);
}

18 View Complete Implementation : SpoutsTest.java
Copyright Apache License 2.0
Author : aol
@Test
public void reactiveBufferBlock() throws InterruptedException {
    Subscription sub = Spouts.reactiveBufferBlock(10, s -> {
        s.onSubscribe(new Subscription() {

            @Override
            public void request(long n) {
                if (i == 0) {
                    Effect e = () -> {
                        s.onNext("hello " + i++);
                    };
                    e.cycle(30).runAsync();
                }
            }

            @Override
            public void cancel() {
            }
        });
    }).forEach(2, in -> count++);
    Thread.sleep(500);
    sub.request(30);
    Thread.sleep(500);
    replacedertThat(i, equalTo(30));
    replacedertThat(count, equalTo(30));
}

18 View Complete Implementation : AbstractOperatorTest.java
Copyright Apache License 2.0
Author : aol
@Test
public void subscribeEmpty() throws Exception {
    Subscription sub = empty.subscribe(values::add, errors::add, () -> onComplete = true);
    sub.request(1l);
    replacedertThat(values.size(), equalTo(0));
    replacedertThat(errors.size(), equalTo(0));
    sub.request(1l);
    replacedertThat(values.size(), equalTo(0));
    replacedertThat(errors.size(), equalTo(0));
    replacedertTrue(onComplete);
}