reactor.core.publisher

Class Operators

java.lang.Object

reactor.core.publisher.Operators

public abstract class Operators
extends java.lang.Object

An helper to support "Operator" writing, handle noop subscriptions, validate request size and to cap concurrent additive operations to Long.MAX_VALUE, which is generic to Subscription.request(long) handling. Combine utils available to operator implementations, @see http://github.com/reactor/reactive-streams-commons

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Operators.DeferredSubscription Base class for Subscribers that will receive their Subscriptions at any time yet they need to be cancelled or requested at any time.
static class	Operators.MonoSubscriber<I,O> A Subscriber/Subscription barrier that holds a single value at most and properly gates asynchronous behaviors resulting from concurrent request or cancel and onXXX signals.
static class	Operators.SubscriberAdapter<I,O> A Subscriber with an asymetric typed wrapped subscriber.

Method Summary

Modifier and Type	Method and Description
static <T> long	addAndGet(java.util.concurrent.atomic.AtomicLongFieldUpdater<T> updater, T instance, long n) Concurrent addition bound to Long.MAX_VALUE.
static long	addAndGet(java.util.concurrent.atomic.AtomicLong current, long toAdd) Concurrent addition bound to Long.MAX_VALUE.
static long	addCap(long a, long b) Cap an addition to Long.MAX_VALUE
static <T> Fuseable.QueueSubscription<T>	as(org.reactivestreams.Subscription s) Returns the subscription as QueueSubscription if possible or null.
static org.reactivestreams.Subscription	cancelledSubscription() A singleton Subscription that represents a cancelled subscription instance and should not be leaked to clients as it represents a terminal state.
static void	checkRequest(long n) Throws an exception if request is 0 or negative as specified in rule 3.09 of Reactive Streams
static boolean	checkRequest(long n, org.reactivestreams.Subscriber<?> subscriber) Throws an exception if request is 0 or negative as specified in rule 3.09 of Reactive Streams
static void	complete(org.reactivestreams.Subscriber<?> s) Calls onSubscribe on the target Subscriber with the empty instance followed by a call to onComplete.
static org.reactivestreams.Subscription	emptySubscription() A singleton enumeration that represents a no-op Subscription instance that can be freely given out to clients.
static void	error(org.reactivestreams.Subscriber<?> s, java.lang.Throwable e) Calls onSubscribe on the target Subscriber with the empty instance followed by a call to onError with the supplied error.
static <T> long	getAndAddCap(java.util.concurrent.atomic.AtomicLongFieldUpdater<T> updater, T instance, long toAdd) Concurrent addition bound to Long.MAX_VALUE.
static long	multiplyCap(long a, long b) Cap a multiplication to Long.MAX_VALUE
static void	onErrorDropped(java.lang.Throwable e) Take an unsignalled exception that is masking anowher one due to callback failure.
static void	onErrorDropped(java.lang.Throwable e, java.lang.Throwable root) Take an unsignalled exception that is masking anowher one due to callback failure.
static <T> void	onNextDropped(T t) An unexpected event is about to be dropped.
static java.lang.Throwable	onOperatorError(org.reactivestreams.Subscription subscription, java.lang.Throwable error) Map an "operator" error given an operator parent Subscription.
static java.lang.Throwable	onOperatorError(org.reactivestreams.Subscription subscription, java.lang.Throwable error, java.lang.Object dataSignal) Map an "operator" error given an operator parent Subscription.
static java.lang.Throwable	onOperatorError(java.lang.Throwable error) Map an "operator" error.
static <T> long	produced(java.util.concurrent.atomic.AtomicLongFieldUpdater<T> updater, T instance, long toSub) Concurrent substraction bound to 0.
static <F> boolean	replace(java.util.concurrent.atomic.AtomicReferenceFieldUpdater<F,org.reactivestreams.Subscription> field, F instance, org.reactivestreams.Subscription s) A generic utility to atomically replace a subscription or cancel if marked by a singleton subscription.
static void	reportBadRequest(long n) Throw IllegalArgumentException
static void	reportMoreProduced() Throw IllegalStateException
static void	reportSubscriptionSet() Log reportedSubscriptions
static <T> org.reactivestreams.Subscription	scalarSubscription(org.reactivestreams.Subscriber<? super T> subscriber, T value) Represents a fuseable Subscription that emits a single constant value synchronously to a Subscriber or consumer.
static <T> org.reactivestreams.Subscriber<T>	serialize(org.reactivestreams.Subscriber<? super T> subscriber) Safely gate a Subscriber by a serializing Subscriber.
static <F> boolean	set(java.util.concurrent.atomic.AtomicReferenceFieldUpdater<F,org.reactivestreams.Subscription> field, F instance, org.reactivestreams.Subscription s) A generic utility to atomically replace a subscription or cancel if marked by a singleton subscription or concurrently set before.
static <F> boolean	setOnce(java.util.concurrent.atomic.AtomicReferenceFieldUpdater<F,org.reactivestreams.Subscription> field, F instance, org.reactivestreams.Subscription s) Sets the given subscription once and returns true if successful, false if the field has a subscription already or has been cancelled.
static long	subOrZero(long a, long b) Cap a substraction to 0
static <F> boolean	terminate(java.util.concurrent.atomic.AtomicReferenceFieldUpdater<F,org.reactivestreams.Subscription> field, F instance)
static boolean	validate(long n) Evaluate if a request is strictly positive otherwise reportBadRequest(long)
static boolean	validate(org.reactivestreams.Subscription current, org.reactivestreams.Subscription next) Check Subscription current state and cancel new Subscription if different null, returning true if ready to subscribe.

Methods inherited from class java.lang.Object

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

Method Detail

addAndGet

public static long addAndGet(java.util.concurrent.atomic.AtomicLong current,
                             long toAdd)

Concurrent addition bound to Long.MAX_VALUE. Any concurrent write will "happen" before this operation.

Parameters:

current - current atomic to update

toAdd - delta to add

Returns:

Addition result or Long.MAX_VALUE

addAndGet

public static <T> long addAndGet(java.util.concurrent.atomic.AtomicLongFieldUpdater<T> updater,
                                 T instance,
                                 long n)

Concurrent addition bound to Long.MAX_VALUE. Any concurrent write will "happen" before this operation.

Type Parameters:

T - the parent instance type

Parameters:

updater - current field updater

instance - current instance to update

n - delta to add

Returns:

Addition result or Long.MAX_VALUE

addCap

public static long addCap(long a,
                          long b)

Cap an addition to Long.MAX_VALUE

Parameters:

a - left operand

b - right operand

Returns:

Addition result or Long.MAX_VALUE if overflow

as

public static <T> Fuseable.QueueSubscription<T> as(org.reactivestreams.Subscription s)

Returns the subscription as QueueSubscription if possible or null.

Type Parameters:

T - the value type of the QueueSubscription.

Parameters:

s - the source subscription to try to convert.

Returns:

the QueueSubscription instance or null

cancelledSubscription

public static org.reactivestreams.Subscription cancelledSubscription()

A singleton Subscription that represents a cancelled subscription instance and should not be leaked to clients as it represents a terminal state.
If algorithms need to hand out a subscription, replace this with a singleton subscription because there is no standard way to tell if a Subscription is cancelled or not otherwise.

Returns:

a singleton noop Subscription

checkRequest

public static void checkRequest(long n)
                         throws java.lang.IllegalArgumentException

Throws an exception if request is 0 or negative as specified in rule 3.09 of Reactive Streams

Parameters:

n - demand to check

Throws:

java.lang.IllegalArgumentException

checkRequest

public static boolean checkRequest(long n,
                                   org.reactivestreams.Subscriber<?> subscriber)

Throws an exception if request is 0 or negative as specified in rule 3.09 of Reactive Streams

Parameters:

n - demand to check

subscriber - Subscriber to onError if non strict positive n

Returns:

true if valid or false if specification exception occured

Throws:

java.lang.IllegalArgumentException - if subscriber is null and demand is negative or 0.

complete

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

Calls onSubscribe on the target Subscriber with the empty instance followed by a call to onComplete.

Parameters:

s -

emptySubscription

public static org.reactivestreams.Subscription emptySubscription()

A singleton enumeration that represents a no-op Subscription instance that can be freely given out to clients.

The enum also implements Fuseable.QueueSubscription so operators expecting a QueueSubscription from a Fuseable source don't have to double-check their Subscription received in onSubscribe.

Returns:

a singleton noop Subscription

error

public static void error(org.reactivestreams.Subscriber<?> s,
                         java.lang.Throwable e)

Calls onSubscribe on the target Subscriber with the empty instance followed by a call to onError with the supplied error.

Parameters:

s - target Subscriber to error

e - the actual error

getAndAddCap

public static <T> long getAndAddCap(java.util.concurrent.atomic.AtomicLongFieldUpdater<T> updater,
                                    T instance,
                                    long toAdd)

Concurrent addition bound to Long.MAX_VALUE. Any concurrent write will "happen" before this operation.

Type Parameters:

T - the parent instance type

Parameters:

updater - current field updater

instance - current instance to update

toAdd - delta to add

Returns:

value before addition or Long.MAX_VALUE

produced

public static <T> long produced(java.util.concurrent.atomic.AtomicLongFieldUpdater<T> updater,
                                T instance,
                                long toSub)

Concurrent substraction bound to 0. Any concurrent write will "happen" before this operation.

Type Parameters:

T - the parent instance type

Parameters:

updater - current field updater

instance - current instance to update

toSub - delta to sub

Returns:

value after subscription or zero

multiplyCap

public static long multiplyCap(long a,
                               long b)

Cap a multiplication to Long.MAX_VALUE

Parameters:

a - left operand

b - right operand

Returns:

Product result or Long.MAX_VALUE if overflow

onErrorDropped

public static void onErrorDropped(java.lang.Throwable e,
                                  java.lang.Throwable root)

Take an unsignalled exception that is masking anowher one due to callback failure.

Parameters:

e - the exception to handle

root - the optional root cause to suppress

onErrorDropped

public static void onErrorDropped(java.lang.Throwable e)

Take an unsignalled exception that is masking anowher one due to callback failure.

Parameters:

e - the exception to handle

onNextDropped

public static <T> void onNextDropped(T t)

An unexpected event is about to be dropped.

Type Parameters:

T - the dropped value type

Parameters:

t - the dropping data

onOperatorError

public static java.lang.Throwable onOperatorError(java.lang.Throwable error)

Map an "operator" error. The result error will be passed via onError to the operator downstream after checking for fatal error via Exceptions.throwIfFatal(Throwable).

Parameters:

error - the callback or operator error

Returns:

mapped Throwable

onOperatorError

public static java.lang.Throwable onOperatorError(org.reactivestreams.Subscription subscription,
                                                  java.lang.Throwable error)

Map an "operator" error given an operator parent Subscription. The result error will be passed via onError to the operator downstream. Subscription will be cancelled after checking for fatal error via Exceptions.throwIfFatal(Throwable).

Parameters:

subscription - the linked operator parent Subscription

error - the callback or operator error

Returns:

mapped Throwable

onOperatorError

public static java.lang.Throwable onOperatorError(org.reactivestreams.Subscription subscription,
                                                  java.lang.Throwable error,
                                                  java.lang.Object dataSignal)

Map an "operator" error given an operator parent Subscription. The result error will be passed via onError to the operator downstream. Subscription will be cancelled after checking for fatal error via Exceptions.throwIfFatal(Throwable).

Parameters:

subscription - the linked operator parent Subscription

error - the callback or operator error

dataSignal - the value (onNext or onError) signal processed during failure

Returns:

mapped Throwable

replace

public static <F> boolean replace(java.util.concurrent.atomic.AtomicReferenceFieldUpdater<F,org.reactivestreams.Subscription> field,
                                  F instance,
                                  org.reactivestreams.Subscription s)

A generic utility to atomically replace a subscription or cancel if marked by a singleton subscription.

Type Parameters:

F - the instance type

Parameters:

field - The Atomic container

instance - the instance reference

s - the subscription

Returns:

true if replaced

reportBadRequest

public static void reportBadRequest(long n)

Throw IllegalArgumentException

Parameters:

n - the demand to evaluate

reportMoreProduced

public static void reportMoreProduced()

Throw IllegalStateException

reportSubscriptionSet

public static void reportSubscriptionSet()

Log reportedSubscriptions

set

public static <F> boolean set(java.util.concurrent.atomic.AtomicReferenceFieldUpdater<F,org.reactivestreams.Subscription> field,
                              F instance,
                              org.reactivestreams.Subscription s)

A generic utility to atomically replace a subscription or cancel if marked by a singleton subscription or concurrently set before.

Type Parameters:

F - the instance type

Parameters:

field - The Atomic container

instance - the instance reference

s - the subscription

Returns:

true if replaced

setOnce

public static <F> boolean setOnce(java.util.concurrent.atomic.AtomicReferenceFieldUpdater<F,org.reactivestreams.Subscription> field,
                                  F instance,
                                  org.reactivestreams.Subscription s)

Sets the given subscription once and returns true if successful, false if the field has a subscription already or has been cancelled.

Type Parameters:

F - the instance type containing the field

Parameters:

field - the field accessor

instance - the parent instance

s - the subscription to set once

Returns:

true if successful, false if the target was not empty or has been cancelled

subOrZero

public static long subOrZero(long a,
                             long b)

Cap a substraction to 0

Parameters:

a - left operand

b - right operand

Returns:

Subscription result or 0 if overflow

terminate

public static <F> boolean terminate(java.util.concurrent.atomic.AtomicReferenceFieldUpdater<F,org.reactivestreams.Subscription> field,
                                    F instance)

validate

public static boolean validate(org.reactivestreams.Subscription current,
                               org.reactivestreams.Subscription next)

Check Subscription current state and cancel new Subscription if different null, returning true if ready to subscribe.

Parameters:

current - current Subscription, expected to be null

next - new Subscription

Returns:

true if Subscription can be used

validate

public static boolean validate(long n)

Evaluate if a request is strictly positive otherwise reportBadRequest(long)

Parameters:

n - the request value

Returns:

true if valid

scalarSubscription

public static <T> org.reactivestreams.Subscription scalarSubscription(org.reactivestreams.Subscriber<? super T> subscriber,
                                                                      T value)

Represents a fuseable Subscription that emits a single constant value synchronously to a Subscriber or consumer.

Type Parameters:

T - the value type

Parameters:

subscriber - the delegate Subscriber that will be requesting the value

value - the single value to be emitted

Returns:

a new scalar Subscription

serialize

public static <T> org.reactivestreams.Subscriber<T> serialize(org.reactivestreams.Subscriber<? super T> subscriber)

Safely gate a Subscriber by a serializing Subscriber. Serialization uses thread-stealing and a potentially unbounded queue that might starve a calling thread if races are too important and Subscriber is slower.

Type Parameters:

T - the relayed type

Parameters:

subscriber - the subscriber to wrap

Returns:

a serializing Subscriber