Java Code Examples for reactor.core.publisher.Operators#cancelledSubscription()

@Override
public void onComplete() {
  final Subscription s = this.s;
  final T value = this.value;

  if (s == Operators.cancelledSubscription() || !S.compareAndSet(this, s, null)) {
    this.doFinally();
    return;
  }

  final ResolvingInner<T> p = this.parent;
  if (value == null) {
    p.terminate(new IllegalStateException("Source completed empty"));
  } else {
    p.complete(value);
  }
}
 

final void doFinally() {
  if (WIP.getAndIncrement(this) != 0) {
    return;
  }

  int m = 1;
  T value;

  for (; ; ) {
    value = this.value;
    if (value != null && this.s == Operators.cancelledSubscription()) {
      this.value = null;
      this.parent.doOnValueExpired(value);
      return;
    }

    m = WIP.addAndGet(this, -m);
    if (m == 0) {
      return;
    }
  }
}
 

/**
 * Sets the Subscription once but does not request anything.
 *
 * @param s the Subscription to set
 * @return true if successful, false if the current subscription is not null
 */
protected final boolean setWithoutRequesting(Subscription s) {
  Objects.requireNonNull(s, "s");
  for (; ; ) {
    Subscription a = this.s;
    if (a == Operators.cancelledSubscription()) {
      s.cancel();
      return false;
    }
    if (a != null) {
      s.cancel();
      Operators.reportSubscriptionSet();
      return false;
    }

    if (S.compareAndSet(this, null, s)) {
      return true;
    }
  }
}
 

/**
 * Sets the Subscription once but does not request anything.
 * @param s the Subscription to push
 * @return true if successful, false if the current subscription is not null
 */
protected final boolean setWithoutRequesting(Subscription s) {
    Objects.requireNonNull(s, "s");
    for (;;) {
        Subscription a = this.s;
        if (a == Operators.cancelledSubscription()) {
            s.cancel();
            return false;
        }
        if (a != null) {
            s.cancel();
            Operators.reportSubscriptionSet();
            return false;
        }

        if (S.compareAndSet(this, null, s)) {
            return true;
        }
    }
}
 

/**
 * Sets the Subscription once but does not request anything.
 * @param s the Subscription to set
 * @return true if successful, false if the current subscription is not null
 */
protected final boolean setWithoutRequesting(Subscription s) {
	Objects.requireNonNull(s, "s");
	for (;;) {
		Subscription a = this.s;
		if (a == Operators.cancelledSubscription()) {
			s.cancel();
			return false;
		}
		if (a != null) {
			s.cancel();
			Operators.reportSubscriptionSet();
			return false;
		}

		if (S.compareAndSet(this, null, s)) {
			return true;
		}
	}
}
 

/**
 * Atomically sets the single subscription and requests the missed amount from it.
 *
 * @param s
 * @return false if this arbiter is cancelled or there was a subscription already set
 */
protected final boolean set(Subscription s) {
	Objects.requireNonNull(s, "s");
	Subscription a = this.s;
	if (a == Operators.cancelledSubscription()) {
		s.cancel();
		return false;
	}
	if (a != null) {
		s.cancel();
		Operators.reportSubscriptionSet();
		return false;
	}

	if (S.compareAndSet(this, null, s)) {

		long r = REQUESTED.getAndSet(this, 0L);

		if (r != 0L) {
			s.request(r);
		}

		return true;
	}

	a = this.s;

	if (a != Operators.cancelledSubscription()) {
		s.cancel();
		return false;
	}

	Operators.reportSubscriptionSet();
	return false;
}
 

@Override
public void cancel() {
	Subscription a = s;
	if (a != Operators.cancelledSubscription()) {
		a = S.getAndSet(this, Operators.cancelledSubscription());
		if (a != null && a != Operators.cancelledSubscription()) {
			a.cancel();
		}
	}
}
 

@Override
public void cancel() {
  Subscription a = s;
  if (a != Operators.cancelledSubscription()) {
    a = S.getAndSet(this, Operators.cancelledSubscription());
    if (a != null && a != Operators.cancelledSubscription()) {
      a.cancel();
    }
  }
}
 

@Override
@SuppressWarnings("rawtypes")
public Object scanUnsafe(Attr key) {
	if (key == Attr.PARENT) return s;
	if (key == Attr.ACTUAL) return actual;
	if (key == Attr.REQUESTED_FROM_DOWNSTREAM) return requested;
	if (key == Attr.CANCELLED) return Operators.cancelledSubscription() == s;
	if (key == Attr.TERMINATED) return terminalSignal != null;
	if (key == Attr.BUFFERED) return queue != null ? queue.size() : 0;
	if (key == Attr.ERROR) return !hasOnComplete() ? terminalSignal : null;
	if (key == Attr.PREFETCH) return MAX_SIZE;
	return null;
}
 

@Override
public void cancel() {
    Subscription a = s;
    if (a != Operators.cancelledSubscription()) {
        a = S.getAndSet(this, Operators.cancelledSubscription());
        if (a != null && a != Operators.cancelledSubscription()) {
            a.cancel();
        }
    }
}
 

@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 onComplete() {
    if (S.getAndSet(this, Operators.cancelledSubscription()) != Operators
        .cancelledSubscription()) {
        //we're sure it has not been concurrently cancelled
        try {
            hookOnComplete();
        } catch (Throwable throwable) {
            //onError itself will short-circuit due to the CancelledSubscription being push above
            hookOnError(Operators.onOperatorError(throwable, currentContext()));
        } finally {
            safeHookFinally(SignalType.ON_COMPLETE);
        }
    }
}
 

@Override
public void onNext(T value) {
  if (this.s == Operators.cancelledSubscription()) {
    this.parent.doOnValueExpired(value);
    return;
  }

  this.value = value;
  // volatile write and check on racing
  this.doFinally();
}
 

@Override
public void onNext(RSocket value) {
  if (this.s == Operators.cancelledSubscription()) {
    this.doOnValueExpired(value);
    return;
  }

  this.value = value;
  // volatile write and check on racing
  this.doFinally();
}
 

@Override
public void onComplete() {
    if (S.getAndSet(this, Operators.cancelledSubscription()) != Operators
        .cancelledSubscription()) {
        //we're sure it has not been concurrently cancelled
        try {
            hookOnComplete();
        } catch (Throwable throwable) {
            //onError itself will short-circuit due to the CancelledSubscription being push above
            hookOnError(Operators.onOperatorError(throwable, currentContext()));
        } finally {
            safeHookFinally(SignalType.ON_COMPLETE);
        }
    }
}
 

@Override
public void onError(Throwable t) {
    Objects.requireNonNull(t, "onError");

    if (S.getAndSet(this, Operators.cancelledSubscription()) == Operators
        .cancelledSubscription()) {
        // Already cancelled concurrently

        // Workaround for Sentinel BlockException:
        // Here we add a predicate method to decide whether exception should be dropped implicitly
        // or call the {@code onErrorDropped} hook.
        if (shouldCallErrorDropHook()) {
            Operators.onErrorDropped(t, currentContext());
        }

        return;
    }

    try {
        hookOnError(t);
    } catch (Throwable e) {
        e = Exceptions.addSuppressed(e, t);
        Operators.onErrorDropped(e, currentContext());
    } finally {
        safeHookFinally(SignalType.ON_ERROR);
    }
}
 

final boolean isCancelled() {
    return s == Operators.cancelledSubscription();
}
 

final boolean isCancelled() {
  return s == Operators.cancelledSubscription();
}
 

boolean isCancelled() {
	return get() == Operators.cancelledSubscription();
}
 

@Override
public boolean isDisposed() {
    return subscription == Operators.cancelledSubscription();
}