@Override public boolean isDisposed() { return subscription == Operators.cancelledSubscription(); }
void cancelMain() { Subscription s = main; if (s != Operators.cancelledSubscription()) { s = MAIN.getAndSet(this, Operators.cancelledSubscription()); if (s != null && s != Operators.cancelledSubscription()) { s.cancel(); } } }
void cancelOther() { Subscription s = other; if (s != Operators.cancelledSubscription()) { s = OTHER.getAndSet(this, Operators.cancelledSubscription()); if (s != null && s != Operators.cancelledSubscription()) { s.cancel(); } } }
@Override public void onNext(T t) { if (s != Operators.cancelledSubscription()) { value = t; parent.innerNext(); } }
@Override public void onError(Throwable t) { if (s != Operators.cancelledSubscription()) { parent.innerError(this, t); } }
/** * Indicates whether this {@code MonoProcessor} has been interrupted via cancellation. * * @return {@code true} if this {@code MonoProcessor} is cancelled, {@code false} * otherwise. */ public boolean isCancelled() { return subscription == Operators.cancelledSubscription() && !isTerminated(); }
@Override @Nullable public Object scanUnsafe(Attr key) { if (key == Attr.PARENT) return s; if (key == Attr.ACTUAL) return parent; if (key == Attr.CANCELLED) return s == Operators.cancelledSubscription(); if (key == Attr.PREFETCH) return prefetch; return null; } }
@Override @Nullable public Object scanUnsafe(Attr key) { if (key == Attr.PARENT) return s; if (key == Attr.ACTUAL) return parent; if (key == Attr.CANCELLED) return s == Operators.cancelledSubscription(); return null; }
@Override @Nullable public Object scanUnsafe(Attr key) { if (key == Attr.CANCELLED) return s == Operators.cancelledSubscription(); if (key == Attr.PARENT) return s; if (key == Attr.TERMINATED) return done; if (key == Attr.ACTUAL) return parent; if (key == Attr.BUFFERED) return value != null ? 1 : 0; if (key == Attr.PREFETCH) return Integer.MAX_VALUE; return null; }
@Override @Nullable public Object scanUnsafe(Attr key) { if (key == Attr.TERMINATED) return done; if (key == Attr.PARENT) return s; if (key == Attr.CANCELLED) return s == Operators.cancelledSubscription(); if (key == Attr.PREFETCH) return batchSize; if (key == Attr.ERROR) return error; return null; } }
@Override public void dispose() { Subscription s = S.getAndSet(this, Operators.cancelledSubscription()); if (s != null && s != Operators.cancelledSubscription()) { s.cancel(); } } }
@Override @Nullable public Object scanUnsafe(Attr key) { if (key == Attr.PARENT) return subscription; if (key == Attr.ACTUAL) return parent; if (key == Attr.TERMINATED) return done && (queue == null || queue.isEmpty()); if (key == Attr.CANCELLED) return subscription == Operators.cancelledSubscription(); if (key == Attr.BUFFERED) return queue == null ? 0 : queue.size(); if (key == Attr.PREFETCH) return prefetch; return null; }
@Override @Nullable public Object scanUnsafe(Attr key) { if (key == Attr.PARENT) return s; if (key == Attr.ACTUAL) return parent; if (key == Attr.TERMINATED) return done && (queue == null || queue.isEmpty()); if (key == Attr.CANCELLED) return s == Operators.cancelledSubscription(); if (key == Attr.BUFFERED) return queue == null ? 0 : queue.size(); if (key == Attr.PREFETCH) return prefetch; return null; } }
@Override public void onSubscribe(Subscription s) { if (!MAIN.compareAndSet(this, null, s)) { s.cancel(); if (main != Operators.cancelledSubscription()) { Operators.reportSubscriptionSet(); } return; } s.request(Long.MAX_VALUE); }
@Override public void onError(Throwable t) { if (subscription != Operators.cancelledSubscription()) { SUBSCRIPTION.lazySet(this, Operators.cancelledSubscription()); parent.boundaryError(this, t); } else { Operators.onErrorDropped(t, parent.ctx); } }
@Override public void onComplete() { SUBSCRIPTION.lazySet(this, Operators.cancelledSubscription()); parent.openComplete(this); }
@Override @Nullable public Object scanUnsafe(Attr key) { if (key == Attr.PARENT) return main; if (key == Attr.CANCELLED) return main == Operators.cancelledSubscription(); return InnerOperator.super.scanUnsafe(key); }
@Override @Nullable public Object scanUnsafe(Attr key) { if (key == Attr.PARENT) return s; if (key == Attr.CANCELLED) return s == Operators.cancelledSubscription(); if (key == Attr.TERMINATED) return done; return super.scanUnsafe(key); }
@Nullable final Subscription cancel() { Subscription s = this.getAndSet(Operators.cancelledSubscription()); if (s != null && s != Operators.cancelledSubscription()) { s.cancel(); if(establishedFusionMode == Fuseable.ASYNC) { qs.clear(); } } return s; }
@Test public void scanMainCancelled() { EmitterProcessor test = EmitterProcessor.create(); test.onSubscribe(Operators.cancelledSubscription()); assertThat(test.scan(CANCELLED)).isTrue(); assertThat(test.isCancelled()).isTrue(); }