io.smallrye.mutiny.helpers

Class Subscriptions

java.lang.Object

io.smallrye.mutiny.helpers.Subscriptions

public class Subscriptions
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Subscriptions.CancelledSubscriber<X>
static class	Subscriptions.DeferredSubscription
static class	Subscriptions.EmptySubscription

Field Summary

Fields

Modifier and Type	Field and Description
static Subscriptions.EmptySubscription	CANCELLED This instance must not be shared.
static Throwable	TERMINATED

Method Summary

Modifier and Type	Method and Description
static long	add(AtomicLong requested, long requests) Atomically adds the positive value n to the requested value in the AtomicLong and caps the result at Long.MAX_VALUE and returns the previous value.
static long	add(long a, long b) Adds two long values and caps the sum at Long.MAX_VALUE.
static boolean	addFailure(AtomicReference<Throwable> failures, Throwable failure)
static void	cancel(AtomicReference<org.reactivestreams.Subscription> reference)
static void	complete(org.reactivestreams.Subscriber<?> subscriber) Invokes onSubscribe on the given Subscriber with the cancelled subscription instance followed immediately by a call to onComplete.
static void	deferredRequest(AtomicReference<org.reactivestreams.Subscription> field, AtomicLong requested, long requests) Atomically requests from the Subscription in the field if not null, otherwise accumulates the request amount in the requested field to be requested once the field is set to non-null.
static org.reactivestreams.Subscription	empty()
static void	fail(org.reactivestreams.Subscriber<?> subscriber, Throwable failure) Invokes onSubscribe on the given Subscriber with the cancelled subscription instance followed immediately by a call to onError with the given failure.
static void	fail(org.reactivestreams.Subscriber<?> subscriber, Throwable failure, org.reactivestreams.Publisher<?> upstream)
static IllegalArgumentException	getInvalidRequestException()
static Throwable	markFailureAsTerminated(AtomicReference<Throwable> failures)
static long	multiply(long n, long times) Cap a multiplication to Long.MAX_VALUE
static long	produced(AtomicLong requested, long amount) Concurrent subtraction bound to 0, mostly used to decrement a request tracker by the amount produced by the operator.
static <T> io.smallrye.mutiny.helpers.Subscriptions.SingleItemSubscription<T>	single(org.reactivestreams.Subscriber<T> downstream, T item)
static long	subOrZero(long a, long b) Cap a subtraction to 0
static long	subtract(AtomicLong requested, long emitted) Atomically subtract the given number (positive, not validated) from the target field unless it contains Long.MAX_VALUE.
static Throwable	terminate(AtomicReference<Throwable> failure)
static void	terminateAndPropagate(AtomicReference<Throwable> failures, org.reactivestreams.Subscriber<?> subscriber)
static int	unboundedOrLimit(int prefetch)
static long	unboundedOrMaxConcurrency(int concurrency)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

TERMINATED

public static final Throwable TERMINATED

CANCELLED

public static final Subscriptions.EmptySubscription CANCELLED

This instance must not be shared. Calling Subscription.cancel() is a no-op.

Method Detail

getInvalidRequestException

public static IllegalArgumentException getInvalidRequestException()

empty

public static org.reactivestreams.Subscription empty()

complete

public static void complete(org.reactivestreams.Subscriber<?> subscriber)

Invokes onSubscribe on the given Subscriber with the cancelled subscription instance followed immediately by a call to onComplete.

Parameters:

subscriber - the subscriber, must not be null

fail

public static void fail(org.reactivestreams.Subscriber<?> subscriber,
                        Throwable failure)

Invokes onSubscribe on the given Subscriber with the cancelled subscription instance followed immediately by a call to onError with the given failure.

Parameters:

subscriber - the subscriber, must not be null

failure - the failure, must not be null

fail

public static void fail(org.reactivestreams.Subscriber<?> subscriber,
                        Throwable failure,
                        org.reactivestreams.Publisher<?> upstream)

add

public static long add(long a,
                       long b)

Adds two long values and caps the sum at Long.MAX_VALUE.

Parameters:

a - the first value

b - the second value

Returns:

the sum capped at Long.MAX_VALUE

add

public static long add(AtomicLong requested,
                       long requests)

Atomically adds the positive value n to the requested value in the AtomicLong and caps the result at Long.MAX_VALUE and returns the previous value.

Parameters:

requested - the AtomicLong holding the current requested value

requests - the value to add, must be positive (not verified)

Returns:

the original value before the add

subtract

public static long subtract(AtomicLong requested,
                            long emitted)

Atomically subtract the given number (positive, not validated) from the target field unless it contains Long.MAX_VALUE.

Parameters:

requested - the target field holding the current requested amount

emitted - the produced element count, positive (not validated)

Returns:

the new amount

unboundedOrLimit

public static int unboundedOrLimit(int prefetch)

unboundedOrMaxConcurrency

public static long unboundedOrMaxConcurrency(int concurrency)

addFailure

public static boolean addFailure(AtomicReference<Throwable> failures,
                                 Throwable failure)

cancel

public static void cancel(AtomicReference<org.reactivestreams.Subscription> reference)

markFailureAsTerminated

public static Throwable markFailureAsTerminated(AtomicReference<Throwable> failures)

terminateAndPropagate

public static void terminateAndPropagate(AtomicReference<Throwable> failures,
                                         org.reactivestreams.Subscriber<?> subscriber)

multiply

public static long multiply(long n,
                            long times)

Cap a multiplication to Long.MAX_VALUE

Parameters:

n - left operand

times - right operand

Returns:

n * times or Long.MAX_VALUE

deferredRequest

public static void deferredRequest(AtomicReference<org.reactivestreams.Subscription> field,
                                   AtomicLong requested,
                                   long requests)

Atomically requests from the Subscription in the field if not null, otherwise accumulates the request amount in the requested field to be requested once the field is set to non-null.

Parameters:

field - the target field that may already contain a Subscription

requested - the current requested amount

requests - the request amount, positive (verified)

terminate

public static Throwable terminate(AtomicReference<Throwable> failure)

produced

public static long produced(AtomicLong requested,
                            long amount)

Concurrent subtraction bound to 0, mostly used to decrement a request tracker by the amount produced by the operator.

Parameters:

requested - the atomic long keeping track of requests

amount - delta to subtract

Returns:

value after subtraction or zero

subOrZero

public static long subOrZero(long a,
                             long b)

Cap a subtraction to 0

Parameters:

a - left operand

b - right operand

Returns:

Subtraction result or 0 if overflow

single

public static <T> io.smallrye.mutiny.helpers.Subscriptions.SingleItemSubscription<T> single(org.reactivestreams.Subscriber<T> downstream,
                                                                                            T item)