Java Code Examples for reactor.core.Fuseable#ASYNC

@Override
public void onNext(T t) {
	if (done) {
		if (t != null) {
			Operators.onNextDropped(t, currentContext());
		}
		return;
	}
	if (sourceMode == Fuseable.ASYNC) {
		drain();
		return;
	}

	if (!queue.offer(t)) {
		Throwable ex = Operators.onOperatorError(s,
				Exceptions.failWithOverflow(Exceptions.BACKPRESSURE_ERROR_QUEUE_FULL), t, currentContext());
		if (!Exceptions.addThrowable(ERROR, this, ex)) {
			Operators.onErrorDroppedMulticast(ex);
			return;
		}
		done = true;
	}
	drain();
}
 

@Override
public void onNext(T t) {
	if (this.mode == Fuseable.ASYNC) {
		actual.onNext(null);
		return;
	}

	if (done) {
		recordMalformed(commonTags, registry);
		Operators.onNextDropped(t, actual.currentContext());
		return;
	}

	//record the delay since previous onNext/onSubscribe. This also records the count.
	long last = this.lastNextEventNanos;
	this.lastNextEventNanos = clock.monotonicTime();
	this.onNextIntervalTimer.record(lastNextEventNanos - last, TimeUnit.NANOSECONDS);

	actual.onNext(t);
}
 

@Override
public void onSubscribe(Subscription s) {
	if (Operators.setOnce(S, this, s)) {
		if (s instanceof Fuseable.QueueSubscription) {
			@SuppressWarnings("unchecked") Fuseable.QueueSubscription<R> f =
					(Fuseable.QueueSubscription<R>) s;
			int m = f.requestFusion(Fuseable.ANY | Fuseable.THREAD_BARRIER);
			if (m == Fuseable.SYNC) {
				sourceMode = Fuseable.SYNC;
				queue = f;
				done = true;
				parent.drain(null);
				return;
			}
			if (m == Fuseable.ASYNC) {
				sourceMode = Fuseable.ASYNC;
				queue = f;
			}
			// NONE is just fall-through as the queue will be created on demand
		}
		s.request(Operators.unboundedOrPrefetch(prefetch));
	}
}
 

@Override
public void onNext(T t) {
	if (done) {
		Operators.onNextDropped(t, context);
		return;
	}

	if (sourceMode != Fuseable.ASYNC) {
		if (!queue.offer(t)) {
			onError(Operators.onOperatorError(s,
					Exceptions.failWithOverflow(Exceptions.BACKPRESSURE_ERROR_QUEUE_FULL),
					t,
					context));
			return;
		}
	}
	drain();
}
 

boolean serializeDrainAndSubscriptionEvent() {
	int missed = WIP.incrementAndGet(this);
	if (missed != 1) {
		return true;
	}
	for (; ; ) {
		if(onSubscriptionLoop()){
			return true;
		}
		if(establishedFusionMode == Fuseable.ASYNC) {
			drainAsyncLoop();
		}
		missed = WIP.addAndGet(this, -missed);
		if (missed == 0) {
			break;
		}
	}
	return false;
}
 

/**
 * Assert that the fusion mode was granted.
 *
 * @return this
 */
public final AssertSubscriber<T> assertFusionEnabled() {
	if (establishedFusionMode != Fuseable.SYNC && establishedFusionMode != Fuseable.ASYNC) {
		throw new AssertionError("Fusion was not enabled");
	}
	return this;
}
 

@Override
@SuppressWarnings("unchecked")
public void onNext(T t) {
	if (done) {
		Operators.onNextDropped(t, currentContext());
		return;
	}

	if (sourceMode == Fuseable.ASYNC) {
		drain();
		return;
	}

	Objects.requireNonNull(t, "onNext");

	Queue<T> q = queue;

	if (q == null) {
		if (Operators.setOnce(S, this, Operators.emptySubscription())) {
			q = Queues.<T>get(prefetch).get();
			queue = q;
		}
		else {
			for (; ; ) {
				if (isDisposed()) {
					return;
				}
				q = queue;
				if (q != null) {
					break;
				}
			}
		}
	}

	while (!q.offer(t)) {
		LockSupport.parkNanos(10);
	}
	drain();
}
 

@Override
public int requestFusion(int requestedMode) {
	if ((requestedMode & Fuseable.ASYNC) != 0) {
		outputFused = true;
		return Fuseable.ASYNC;
	}
	return Fuseable.NONE;
}
 

@Override
public int requestFusion(int requestedMode) {
	if ((requestedMode & Fuseable.ASYNC) != 0) {
		enableAsyncFusion = true;
		return Fuseable.ASYNC;
	}
	return Fuseable.NONE;
}
 

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

		if (s instanceof QueueSubscription) {
			@SuppressWarnings("unchecked") QueueSubscription<T> f =
					(QueueSubscription<T>) s;

			int m = f.requestFusion(Fuseable.ANY | Fuseable.THREAD_BARRIER);

			if (m == Fuseable.SYNC) {
				sourceMode = Fuseable.SYNC;
				queue = f;
				done = true;

				actual.onSubscribe(this);
				return;
			}
			if (m == Fuseable.ASYNC) {
				sourceMode = Fuseable.ASYNC;
				queue = f;

				actual.onSubscribe(this);

				s.request(Operators.unboundedOrPrefetch(prefetch));

				return;
			}
		}

		queue = queueSupplier.get();

		actual.onSubscribe(this);

		s.request(Operators.unboundedOrPrefetch(prefetch));
	}
}
 

@Override
public int requestFusion(int requestedMode) {
	if ((requestedMode & Fuseable.ASYNC) != 0) {
		enableOperatorFusion = true;
		return Fuseable.ASYNC;
	}
	return Fuseable.NONE;
}
 

@Override
public int requestFusion(int requestedMode) {
	if ((requestedMode & Fuseable.ASYNC) != 0) {
		outputFused = true;
		return Fuseable.ASYNC;
	}
	return Fuseable.NONE;
}
 

static String formatFusionMode(int m) {
	switch (m) {
		case Fuseable.ANY:
			return "(any)";
		case Fuseable.SYNC:
			return "(sync)";
		case Fuseable.ASYNC:
			return "(async)";
		case Fuseable.NONE:
			return "none";
		case Fuseable.THREAD_BARRIER:
			return "(thread-barrier)";
	}
	return "" + m;
}
 

@Override
@Nullable
public T poll() {
	if (done) {
		return null;
	}
	long r = remaining;
	T v = qs.poll();
	if (r == 0L) {
		done = true;
		if (inputMode == Fuseable.ASYNC) {
			qs.cancel();
			actual.onComplete();
		}
		return null;
	}


	if (v != null) {
		remaining = --r;
		if (r == 0L) {
			if (!done) {
				done = true;
				if (inputMode == Fuseable.ASYNC) {
					qs.cancel();
					actual.onComplete();
				}
			}
		}
	}

	return v;
}
 

@Override
public void onNext(T t) {
	if (sourceMode == Fuseable.ASYNC) {
		drain();
	}
	else if (!queue.offer(t)) {
		Context ctx = actual.currentContext();
		onError(Operators.onOperatorError(s, Exceptions.failWithOverflow(Exceptions.BACKPRESSURE_ERROR_QUEUE_FULL), t,
				ctx));
		Operators.onDiscard(t, ctx);
	}
	else {
		drain();
	}
}
 

@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));
	}
}
 

@Override
public int requestFusion(int requestedMode) {
    if ((requestedMode & Fuseable.ASYNC) != 0) {
        outputFused = OUTPUT_NO_VALUE;
        return Fuseable.ASYNC;
    }
    return Fuseable.NONE;
}
 

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

		if (s instanceof Fuseable.QueueSubscription) {
			@SuppressWarnings("unchecked")
			Fuseable.QueueSubscription<T> qs = (Fuseable.QueueSubscription<T>) s;
			
			int m = qs.requestFusion(Fuseable.ANY | Fuseable.THREAD_BARRIER);
			
			if (m == Fuseable.SYNC) {
				sourceMode = m;
				queue = qs;
				done = true;
				setupSubscribers();
				drain();
				return;
			} else
			if (m == Fuseable.ASYNC) {
				sourceMode = m;
				queue = qs;
				
				setupSubscribers();
				
				s.request(Operators.unboundedOrPrefetch(prefetch));
				
				return;
			}
		}
		
		queue = queueSupplier.get();
		
		setupSubscribers();
		
		s.request(Operators.unboundedOrPrefetch(prefetch));
	}
}
 

/**
 * Assert that the fusion mode was granted.
 *
 * @return this
 */
public final AssertSubscriber<T> assertFusionEnabled() {
    if (establishedFusionMode != Fuseable.SYNC && establishedFusionMode != Fuseable.ASYNC) {
        throw new AssertionError("Fusion was not enabled");
    }
    return this;
}
 

@Override
public int requestFusion(int requestedMode) {
    if ((requestedMode & Fuseable.ASYNC) != 0) {
        outputFused = true;
        return Fuseable.ASYNC;
    }
    return Fuseable.NONE;
}