reactor.core.publisher

Class SinkOneSerialized<T>

java.lang.Object

reactor.core.publisher.SinkOneSerialized<T>

public class SinkOneSerialized<T>
extends Object

Nested Class Summary

Nested classes/interfaces inherited from interface reactor.core.Scannable

Scannable.Attr<T>

Field Summary

Fields inherited from interface reactor.core.Scannable

OPERATOR_NAME_UNRELATED_WORDS_PATTERN

Constructor Summary

Constructors

Constructor and Description
SinkOneSerialized(Sinks.One<T> sinkOne, reactor.core.publisher.ContextHolder contextHolder)

Method Summary

Modifier and Type	Method and Description
Mono<T>	asMono() Return a Mono view of this sink.
Context	currentContext() Request a Context from dependent components which can include downstream operators during subscribing or a terminal Subscriber.
Context	currentContext() Request a Context from dependent components which can include downstream operators during subscribing or a terminal Subscriber.
int	currentSubscriberCount() Get how many Subscribers are currently subscribed to the sink.
default void	emitEmpty(Sinks.EmitFailureHandler failureHandler) A simplified attempt at completing via the Sinks.Empty.tryEmitEmpty() API, generating an onComplete signal.
default void	emitError(Throwable error, Sinks.EmitFailureHandler failureHandler) A simplified attempt at failing the sequence via the Sinks.Empty.tryEmitError(Throwable) API, generating an onError signal.
default void	emitValue(T value, Sinks.EmitFailureHandler failureHandler) A simplified attempt at emitting a non-null element via the Sinks.One.tryEmitValue(Object) API, generating an onNext signal immediately followed by an Subscriber.onComplete() signal.
Stream<? extends Scannable>	inners() Return a Stream of referenced inners (flatmap, multicast etc)
Object	scanUnsafe(Scannable.Attr key) This method is used internally by components to define their key-value mappings in a single place.
Sinks.EmitResult	tryEmitEmpty() Try to complete the Mono without a value, generating only an onComplete signal.
Sinks.EmitResult	tryEmitError(Throwable t) Try to fail the Mono, generating only an onError signal.
Sinks.EmitResult	tryEmitValue(T t) Try to complete the Mono with an element, generating an onNext signal immediately followed by an onComplete signal.

Methods inherited from class java.lang.Object

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

Methods inherited from interface reactor.core.publisher.Sinks.Empty

asMono, currentSubscriberCount, tryEmitEmpty, tryEmitError

Methods inherited from interface reactor.core.Scannable

actuals, from, inners, isScanAvailable, name, parents, scan, scanOrDefault, scanUnsafe, stepName, steps, tags, tagsDeduplicated

Constructor Detail

SinkOneSerialized

public SinkOneSerialized(Sinks.One<T> sinkOne,
                         reactor.core.publisher.ContextHolder contextHolder)

Method Detail

tryEmitValue

public Sinks.EmitResult tryEmitValue(T t)

Description copied from interface: Sinks.One

Try to complete the Mono with an element, generating an onNext signal immediately followed by an onComplete signal. A null value will only trigger the onComplete. The result of the attempt is represented as an Sinks.EmitResult, which possibly indicates error cases.

See the list of failure Sinks.EmitResult in #emitValue(Object, EmitFailureHandler) javadoc for an example of how each of these can be dealt with, to decide if the emit API would be a good enough fit instead.

Might throw an unchecked exception as a last resort (eg. in case of a fatal error downstream which cannot be propagated to any asynchronous handler, a bubbling exception, ...).

Parameters:

t - the value to emit and complete with, or null to only trigger an onComplete

Returns:

an Sinks.EmitResult, which should be checked to distinguish different possible failures

See Also:

Sinks.One.emitValue(Object, Sinks.EmitFailureHandler), Subscriber.onNext(Object), Subscriber.onComplete()

emitValue

public void emitValue(@Nullable
                      T value,
                      Sinks.EmitFailureHandler failureHandler)

Description copied from interface: Sinks.One

A simplified attempt at emitting a non-null element via the Sinks.One.tryEmitValue(Object) API, generating an onNext signal immediately followed by an Subscriber.onComplete() signal. If the result of the attempt is not a success, implementations SHOULD retry the Sinks.One.tryEmitValue(Object) call IF the provided Sinks.EmitFailureHandler returns true. Otherwise, failures are dealt with in a predefined way that might depend on the actual sink implementation (see below for the vanilla reactor-core behavior).

Generally, Sinks.One.tryEmitValue(Object) is preferable since it allows a custom handling of error cases, although this implies checking the returned Sinks.EmitResult and correctly acting on it. This API is intended as a good default for convenience.

When the Sinks.EmitResult is not a success, vanilla reactor-core operators have the following behavior:

• Sinks.EmitResult.FAIL_ZERO_SUBSCRIBER: no particular handling. should ideally discard the value but at that point there's no Subscriber from which to get a contextual discard handler.
• Sinks.EmitResult.FAIL_OVERFLOW: discard the value (Operators.onDiscard(Object, Context)) then call Sinks.Empty.emitError(Throwable, Sinks.EmitFailureHandler) with a Exceptions.failWithOverflow(String) exception.
• Sinks.EmitResult.FAIL_CANCELLED: discard the value (Operators.onDiscard(Object, Context)).
• Sinks.EmitResult.FAIL_TERMINATED: drop the value (Operators.onNextDropped(Object, Context)).
• Sinks.EmitResult.FAIL_NON_SERIALIZED: throw an Sinks.EmissionException mentioning RS spec rule 1.3. Note that Sinks.unsafe() never trigger this result. It would be possible for an Sinks.EmitFailureHandler to busy-loop and optimistically wait for the contention to disappear to avoid this case for safe sinks...

Might throw an unchecked exception as a last resort (eg. in case of a fatal error downstream which cannot be propagated to any asynchronous handler, a bubbling exception, a Sinks.EmitResult.FAIL_NON_SERIALIZED as described above, ...).

Specified by:

emitValue in interface Sinks.One<T>

Parameters:

value - the value to emit and complete with, a null is actually acceptable to only trigger an onComplete

failureHandler - the failure handler that allows retrying failed Sinks.EmitResult.

See Also:

Sinks.One.tryEmitValue(Object), Subscriber.onNext(Object), Subscriber.onComplete()

emitEmpty

public void emitEmpty(Sinks.EmitFailureHandler failureHandler)

Description copied from interface: Sinks.Empty

A simplified attempt at completing via the Sinks.Empty.tryEmitEmpty() API, generating an onComplete signal. If the result of the attempt is not a success, implementations SHOULD retry the Sinks.Empty.tryEmitEmpty() call IF the provided Sinks.EmitFailureHandler returns true. Otherwise, failures are dealt with in a predefined way that might depend on the actual sink implementation (see below for the vanilla reactor-core behavior).

Generally, Sinks.Empty.tryEmitEmpty() is preferable since it allows a custom handling of error cases, although this implies checking the returned Sinks.EmitResult and correctly acting on it. This API is intended as a good default for convenience.

When the Sinks.EmitResult is not a success, vanilla reactor-core operators have the following behavior:

• Sinks.EmitResult.FAIL_OVERFLOW: irrelevant as onComplete is not driven by backpressure.
• Sinks.EmitResult.FAIL_ZERO_SUBSCRIBER: the completion can be ignored since nobody is listening. Note that most vanilla reactor sinks never trigger this result for onComplete, replaying the terminal signal to later subscribers instead (to the exception of Sinks.UnicastSpec.onBackpressureError()).
• Sinks.EmitResult.FAIL_CANCELLED: the completion can be ignored since nobody is interested.
• Sinks.EmitResult.FAIL_TERMINATED: the extra completion is basically ignored since there was a previous termination signal, but there is nothing interesting to log.
• Sinks.EmitResult.FAIL_NON_SERIALIZED: throw an Sinks.EmissionException mentioning RS spec rule 1.3. Note that Sinks.unsafe() never trigger this result. It would be possible for an Sinks.EmitFailureHandler to busy-loop and optimistically wait for the contention to disappear to avoid this case in safe sinks...

Might throw an unchecked exception as a last resort (eg. in case of a fatal error downstream which cannot be propagated to any asynchronous handler, a bubbling exception, a Sinks.EmitResult.FAIL_NON_SERIALIZED as described above, ...).

Specified by:

emitEmpty in interface Sinks.Empty<T>

Parameters:

failureHandler - the failure handler that allows retrying failed Sinks.EmitResult.

See Also:

Sinks.Empty.tryEmitEmpty(), Subscriber.onComplete()

emitError

public void emitError(Throwable error,
                      Sinks.EmitFailureHandler failureHandler)

Description copied from interface: Sinks.Empty

A simplified attempt at failing the sequence via the Sinks.Empty.tryEmitError(Throwable) API, generating an onError signal. If the result of the attempt is not a success, implementations SHOULD retry the Sinks.Empty.tryEmitError(Throwable) call IF the provided Sinks.EmitFailureHandler returns true. Otherwise, failures are dealt with in a predefined way that might depend on the actual sink implementation (see below for the vanilla reactor-core behavior).

Generally, Sinks.Empty.tryEmitError(Throwable) is preferable since it allows a custom handling of error cases, although this implies checking the returned Sinks.EmitResult and correctly acting on it. This API is intended as a good default for convenience.

When the Sinks.EmitResult is not a success, vanilla reactor-core operators have the following behavior:

• Sinks.EmitResult.FAIL_OVERFLOW: irrelevant as onError is not driven by backpressure.
• Sinks.EmitResult.FAIL_ZERO_SUBSCRIBER: the error is ignored since nobody is listening. Note that most vanilla reactor sinks never trigger this result for onError, replaying the terminal signal to later subscribers instead (to the exception of Sinks.UnicastSpec.onBackpressureError()).
• Sinks.EmitResult.FAIL_CANCELLED: the error can be ignored since nobody is interested.
• Sinks.EmitResult.FAIL_TERMINATED: the error unexpectedly follows another terminal signal, so it is dropped via Operators.onErrorDropped(Throwable, Context).
• Sinks.EmitResult.FAIL_NON_SERIALIZED: throw an Sinks.EmissionException mentioning RS spec rule 1.3. Note that Sinks.unsafe() never trigger this result. It would be possible for an Sinks.EmitFailureHandler to busy-loop and optimistically wait for the contention to disappear to avoid this case in safe sinks...

Might throw an unchecked exception as a last resort (eg. in case of a fatal error downstream which cannot be propagated to any asynchronous handler, a bubbling exception, a Sinks.EmitResult.FAIL_NON_SERIALIZED as described above, ...).

Specified by:

emitError in interface Sinks.Empty<T>

Parameters:

error - the exception to signal, not null

failureHandler - the failure handler that allows retrying failed Sinks.EmitResult.

See Also:

Sinks.Empty.tryEmitError(Throwable), Subscriber.onError(Throwable)

currentContext

public Context currentContext()

Request a Context from dependent components which can include downstream operators during subscribing or a terminal Subscriber.

Returns:

a resolved context

tryEmitEmpty

public final Sinks.EmitResult tryEmitEmpty()

Description copied from interface: Sinks.Empty

Try to complete the Mono without a value, generating only an onComplete signal. The result of the attempt is represented as an Sinks.EmitResult, which possibly indicates error cases.

See the list of failure Sinks.EmitResult in #emitEmpty(EmitFailureHandler) javadoc for an example of how each of these can be dealt with, to decide if the emit API would be a good enough fit instead.

Returns:

an Sinks.EmitResult, which should be checked to distinguish different possible failures

See Also:

Sinks.Empty.emitEmpty(Sinks.EmitFailureHandler), Subscriber.onComplete()

tryEmitError

public final Sinks.EmitResult tryEmitError(Throwable t)

Description copied from interface: Sinks.Empty

Try to fail the Mono, generating only an onError signal. The result of the attempt is represented as an Sinks.EmitResult, which possibly indicates error cases.

See the list of failure Sinks.EmitResult in #emitError(Throwable, EmitFailureHandler) javadoc for an example of how each of these can be dealt with, to decide if the emit API would be a good enough fit instead.

Parameters:

t - the exception to signal, not null

Returns:

an Sinks.EmitResult, which should be checked to distinguish different possible failures

See Also:

Sinks.Empty.emitError(Throwable, Sinks.EmitFailureHandler), Subscriber.onError(Throwable)

currentSubscriberCount

public int currentSubscriberCount()

Description copied from interface: Sinks.Empty

Get how many Subscribers are currently subscribed to the sink.

This is a best effort peek at the sink state, and a subsequent attempt at emitting to the sink might still return Sinks.EmitResult.FAIL_ZERO_SUBSCRIBER where relevant. Request (and lack thereof) isn't taken into account, all registered subscribers are counted.

Returns:

the number of active subscribers at the time of invocation

asMono

public Mono<T> asMono()

Description copied from interface: Sinks.Empty

Return a Mono view of this sink. Every call returns the same instance.

Returns:

the Mono view associated to this Sinks.One

inners

public Stream<? extends Scannable> inners()

Description copied from interface: Scannable

Return a Stream of referenced inners (flatmap, multicast etc)

Returns:

a Stream of referenced inners (flatmap, multicast etc)

scanUnsafe

public Object scanUnsafe(Scannable.Attr key)

Description copied from interface: Scannable

This method is used internally by components to define their key-value mappings in a single place. Although it is ignoring the generic type of the Scannable.Attr key, implementors should take care to return values of the correct type, and return null if no specific value is available.

For public consumption of attributes, prefer using Scannable.scan(Attr), which will return a typed value and fall back to the key's default if the component didn't define any mapping.

Parameters:

key - a Scannable.Attr to resolve for the component.

Returns:

the value associated to the key for that specific component, or null if none.

currentContext

public Context currentContext()

Request a Context from dependent components which can include downstream operators during subscribing or a terminal Subscriber.

Returns:

a resolved context