io.reactivex.internal.subscriptions.SubscriptionHelper Java Examples

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        if (BackpressureHelper.add(this, n) == 0) {
            long requested = n;
            long emitted = 0;
            do {
                emitted = requested;
                while (requested-- > 0 && !cancelled && (count == -1 || counter-- > 0)) {
                    child.onNext(value);
                }
            } while ((requested = this.addAndGet(-emitted)) > 0);
            if (count >= 0 && !cancelled) {
                child.onComplete();
            }
        }
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        // modify request to upstream to account for inserted values
        // use a CAS loop because request can be called from any thread
        while (true) {
            long ins = inserted.get();
            long d = Math.min(ins, n);
            if (inserted.compareAndSet(ins, ins - d)) {
                if (n - d > 0) {
                    upstream.request(n - d);
                }
                break;
            }
        }
        drain();
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        // modify request to upstream to account for inserted values
        // use a CAS loop because request can be called from any thread
        while (true) {
            long ins = inserted.get();
            long d = Math.min(ins, n);
            if (inserted.compareAndSet(ins, ins - d)) {
                if (n - d > 0) {
                    upstream.request(n - d);
                }
                break;
            }
        }
        drain();
    }
}
 

@Override
protected void subscribeActual(Subscriber<? super T> child) {

    Flowable<T> f;
    try {
        f = transform.apply(source);
    } catch (Exception e) {
        Exceptions.throwIfFatal(e);
        child.onSubscribe(SubscriptionHelper.CANCELLED);
        child.onError(e);
        return;
    }
    AtomicReference<Chain<T>> chainRef = new AtomicReference<Chain<T>>();
    DestinationSerializedSubject<T> destination = new DestinationSerializedSubject<T>(child,
            chainRef);
    Chain<T> chain = new Chain<T>(transform, destination, maxIterations, maxChained, tester);
    chainRef.set(chain);
    // destination is not initially subscribed to the chain but will be when
    // tester function result completes
    destination.subscribe(child);
    ChainedReplaySubject<T> sub = ChainedReplaySubject.create(destination, chain, tester);
    chain.initialize(sub);
    f.onTerminateDetach() //
            .subscribe(sub);
}
 

@Override
public void request(long n) {
    debug(this + " request " + n);
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        while (true) {
            Subscription p = parent.get();
            long d = deferredRequests.get();
            if (d == -1) {
                // parent exists so can request of it
                debug(this + " requesting from parent " + n);
                p.request(n);
                break;
            } else {
                long d2 = d + n;
                if (d2 < 0) {
                    d2 = Long.MAX_VALUE;
                }
                if (deferredRequests.compareAndSet(d, d2)) {
                    break;
                }
            }
        }
        drain();
    }
}
 

@Override
public void onError(Throwable t) {
    if (SubscriptionHelper.cancel(subscription)) {
        hookOnError(t);
        downstreamSubscriber.onError(t);
    }
}
 

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

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

        actual.onSubscribe(this);

        s.request(bufferSize);
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        schedule();
    }
}
 

@Override
public void close() throws IOException {
    SubscriptionHelper.cancel(upstream);
    synchronized (this) {
        notifyAll();
    }
}
 

byte[] awaitBufferIfNecessary() throws IOException {
    byte[] a = bytes;
    if (a == null) {
        synchronized (this) {
            for (;;) {
                boolean d = done;
                a = bytes;
                if (a != null) {
                    break;
                }
                if (d || upstream.get() == SubscriptionHelper.CANCELLED) {
                    break;
                }
                try {
                    wait();
                } catch (InterruptedException ex) {
                    if (upstream.get() != SubscriptionHelper.CANCELLED) {
                        InterruptedIOException exc = new InterruptedIOException();
                        exc.initCause(ex);
                        throw exc;
                    }
                    break;
                }
            } 
        }
    }
    return a;
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        parent.request(n);
        drain();
    }
}
 

@Override
public void onSubscribe(Subscription parent) {
    if (SubscriptionHelper.validate(this.parent, parent)) {
        this.parent = parent;
        child.onSubscribe(this);
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        drain();
    }
}
 

@Override
public void onSubscribe(Subscription parent) {
    if (SubscriptionHelper.validate(this.parent, parent)) {
        this.parent = parent;
        child.onSubscribe(this);
    }
}
 

@Override
public void close() throws IOException {
    SubscriptionHelper.cancel(upstream);
    synchronized (this) {
        notifyAll();
    }
}
 

@Override
public void onSubscribe(Subscription upstream) {
    // this method is responsible for notifying downstream
    // where to send requests and cancellation by calling
    // downstream.onSubscribe with a Subscription object
    // (we reuse `this`)

    if (SubscriptionHelper.validate(this.upstream, upstream)) {
        downstream.onSubscribe(this);
    }
}
 

@Override
public void request(long n) {
    // requests received from downstream are passed to upstream

    // note that upstream is non-null because by specification
    // onSubscribe must terminate before request or cancel is
    // called on the Subscription passed into onSubscribe.
    if (SubscriptionHelper.validate(n)) {
        upstream.request(n);
    }
}
 

@Override
public void onComplete() {
    if (SubscriptionHelper.cancel(subscription)) {
        hookOnComplete();
        downstreamSubscriber.onComplete();
    }
}
 

@Override
public void onSubscribe(Subscription subscription) {
  Objects.requireNonNull(subscription, "subscription");
  if (!setSubscription(subscription)) {
    subscription.cancel();
    SubscriptionHelper.reportSubscriptionSet();
    return;
  }
  writeStream.exceptionHandler(t -> {
    if (!setDone()) {
      RxJavaPlugins.onError(t);
      return;
    }
    getSubscription().cancel();
    Consumer<? super Throwable> c;
    synchronized (this) {
      c = this.writeStreamExceptionHandler;
    }
    if (c != null) {
      try {
        c.accept(t);
      } catch (Exception e) {
        RxJavaPlugins.onError(e);
      }
    }
  });
  writeStream.drainHandler(v -> requestMore());
  requestMore();
}
 

void cancel() {
    while (true) {
        Subscription s = subscription.get();
        if (subscription.compareAndSet(s, SubscriptionHelper.CANCELLED)) {
            s.cancel();
            break;
        }
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        if (once.compareAndSet(false, true)) {
            sources.subscribe(this);
            subscription.request(maxConcurrent);
        }
        drain();
    }
}
 

@Override
public void onSubscribe(Subscription upstream) {
    if (SubscriptionHelper.validate(this.upstream, upstream)) {
        this.upstream = upstream;
        downstream.onSubscribe(this);
    }
}
 

@Override
public void request(long n) {
    debug(this + " request " + n);
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        while (true) {
            Requests<T> r = requests.get();
            Requests<T> r2;
            if (r.parent == null) {
                long d = r.deferred + n;
                if (d < 0) {
                    d = Long.MAX_VALUE;
                }
                r2 = new Requests<T>(r.parent, r.unreconciled, d, r.child);
                if (requests.compareAndSet(r, r2)) {
                    break;
                }
            } else {
                long x = n + r.deferred - r.unreconciled;
                long u = Math.max(0, -x);
                r2 = new Requests<T>(r.parent, u, 0, r.child);
                if (requests.compareAndSet(r, r2)) {
                    if (x > 0) {
                        r.parent.request(x);
                    }
                    break;
                }
            }
        }
        drain();
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        scheduleDrain();
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        parent.request(n);
        scheduleDrain();
    }
}
 

@Override
public void onSubscribe(Subscription parent) {
    if (SubscriptionHelper.validate(this.parent, parent)) {
        this.parent = parent;
        child.onSubscribe(this);
    }
}
 

@Override
public void onSubscribe(Subscription s) {
    if (SubscriptionHelper.setOnce(this, s)) {
        try {
            addObserver();
            downstream.onSubscribe(s);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            s.cancel();
            onError(ex);
        }
    }
}
 

byte[] awaitBufferIfNecessary() throws IOException {
    byte[] a = bytes;
    if (a == null) {
        synchronized (this) {
            for (;;) {
                boolean d = done;
                a = bytes;
                if (a != null) {
                    break;
                }
                if (d || upstream.get() == SubscriptionHelper.CANCELLED) {
                    break;
                }
                try {
                    wait();
                } catch (InterruptedException ex) {
                    if (upstream.get() != SubscriptionHelper.CANCELLED) {
                        InterruptedIOException exc = new InterruptedIOException();
                        exc.initCause(ex);
                        throw exc;
                    }
                    break;
                }
            } 
        }
    }
    return a;
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        drain();
    }
}