Java Code Examples for org.reactivestreams.Subscription#cancel()

void otherComplete() {
	Subscription s = S.getAndSet(this, Operators.cancelledSubscription());
	if(s != Operators.cancelledSubscription()) {
		C b;
		synchronized (this) {
			b = buffer;
			buffer = null;
		}

		if(s != null){
			s.cancel();
		}

		if (b != null && !b.isEmpty()) {
			if (emit(b)) {
				actual.onComplete();
			} //failed emit will discard buffer content
		}
		else {
			actual.onComplete();
		}
	}
}
 

@Override
public void onSubscribe(Subscription s) {
    if (upstream.compareAndSet(null, s)) {
        try {
            downstream.onSubscribe(this);
        } catch (Throwable e) {
            done = true;
            // can't call onError because the actual's state may be corrupt at this point
            try {
                s.cancel();
            } catch (Throwable e1) {
                // ignore it, nothing we can do.
            }
        }
    } else {
        s.cancel();
    }
}
 

private void handleCancelFrame(int streamId) {
  Subscription subscription = sendingSubscriptions.remove(streamId);
  Processor<Payload, Payload> processor = channelProcessors.remove(streamId);

  if (processor != null) {
    try {
      processor.onError(new CancellationException("Disposed"));
    } catch (Exception e) {
      // ignore
    }
  }

  if (subscription != null) {
    subscription.cancel();
  }
}
 

public static boolean validate(Subscription current, Subscription next) {
  if (next == null) {
    RxJavaPlugins.onError(new NullPointerException("next is null"));
    return false;
  }
  if (current != null) {
    next.cancel();
    RxJavaPlugins.onError(new ProtocolViolationException("Subscription already set!"));
    return false;
  }
  return true;
}
 

@Override
public void onSubscribe(Subscription s) {
	if (Operators.validate(ref.getAndSet(s), s)) {
		s.request(Long.MAX_VALUE);
	}
	else {
		s.cancel();
	}
}
 

@Override
public void onSubscribe(Subscription subscription) {
    Objects.requireNonNull(subscription);
    if (subscribed.compareAndSet(false, true)) {
        source.onSubscribe(
                new WrappedSubscription(subscription, () -> future.completeExceptionally(new CancellationException())));
    } else {
        subscription.cancel();
    }
}
 

@Override
public void onSubscribe(Subscription s) {
	if (buffer.isDone()) {
		s.cancel();
	}
	else if (Operators.validate(subscription, s)) {
		subscription = s;
		s.request(Long.MAX_VALUE);
	}
}
 

@Override
public void onNext(T t) {
	Subscription s = ref.getAndSet(null);
	if (s != null) {
		complete(t);
		if (cancelSourceOnNext) {
			s.cancel();
		}
	}
	else {
		Operators.onNextDropped(t, currentContext());
	}
}
 

@Override
public void cancel() {
    Subscription sub = upstream.getAndSet(Subscriptions.CANCELLED);
    if (sub != null && sub != Subscriptions.CANCELLED) {
        sub.cancel();
    }
}
 

void setOther(Subscription s) {
	if (!OTHER.compareAndSet(this, null, s)) {
		s.cancel();
		if (other != Operators.cancelledSubscription()) {
			Operators.reportSubscriptionSet();
		}
	}
}
 

@Override
public void onSubscribe(Subscription s) {
    Objects.requireNonNull(s, "s");
    if (subscribers != TERMINATED) {
        s.request(Long.MAX_VALUE);
    } else {
        s.cancel();
    }
}
 

@Override
public void onSubscribe(Subscription subscription) {
    if (upstream.compareAndSet(null, subscription)) {
        doOnSubscribe();
        downstream.onSubscribe(this);
    } else {
        subscription.cancel();
    }
}
 

/**
 * A generic utility to atomically replace a subscription or cancel the replacement
 * if the current subscription is marked as already cancelled (as in
 * {@link #cancelledSubscription()}).
 *
 * @param field The Atomic container
 * @param instance the instance reference
 * @param s the subscription
 * @param <F> the instance type
 *
 * @return true if replaced
 */
public static <F> boolean replace(AtomicReferenceFieldUpdater<F, Subscription> field,
		F instance,
		Subscription s) {
	for (; ; ) {
		Subscription a = field.get(instance);
		if (a == CancelledSubscription.INSTANCE) {
			s.cancel();
			return false;
		}
		if (field.compareAndSet(instance, a, s)) {
			return true;
		}
	}
}
 

@Override
public void onSubscribe(Subscription subscription) {
    this.subscription = subscription;
    if (cancelled) {
        subscription.cancel();
        return;
    }
    if (deferredInitialMessageRequest > 0) {
        request(deferredInitialMessageRequest);
    }
}
 

@Override
public void cancel() {
	Subscription s = this.subscription;
	if (s != null) {
		this.subscription = null;
		try {
			s.cancel();
		}
		finally {
			releaseCachedItem();
		}
	}
}
 

void setOther(Subscription s) {
    if (!OTHER.compareAndSet(this, null, s)) {
        s.cancel();
        if (other != SubscriptionHelper.cancelled()) {
            SubscriptionHelper.reportSubscriptionSet();
        }
    }
}
 

@Override
public void cancel() {
    Subscription actual = subscription.get();
    if (actual != CANCELLED) {
        actual = subscription.getAndSet(CANCELLED);
        if (actual != null && actual != CANCELLED) {
            actual.cancel();
        }
    }
}
 

@Override
public void onSubscribe(Subscription s) {
	if (Operators.setOnce(S, this, s)) {
		s.request(Long.MAX_VALUE);
	} else {
		s.cancel();
	}
}
 

@Override
public final void onSubscribe(Subscription s) {
    if (SubscriptionHelper.validate(this.s, s)) {
        this.s = s;
        if (!cancelled) {
            s.request(Long.MAX_VALUE);
            if (cancelled) {
                this.s = SubscriptionHelper.CANCELLED;
                s.cancel();
            }
        }
    }
}
 

void setOtherSubscription(Subscription s) {
    if (other.compareAndSet(null, s)) {
        s.request(1);
    } else {
        s.cancel();
    }
}