Package reactor.core.publisher

Class SinkOneSerialized<T>

java.lang.Object

reactor.core.publisher.SinkOneSerialized<T>

All Implemented Interfaces:

Sinks.Empty<T>, Sinks.One<T>, Scannable

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	Description
SinkOneSerialized(Sinks.One<T> sinkOne, reactor.core.publisher.ContextHolder contextHolder)

Method Summary

Modifier and Type	Method	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()
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)
@Nullable Object	scanUnsafe(Scannable.Attr key)	This method is used internally by components to define their key-value mappings in a single place.
final Sinks.EmitResult	tryEmitEmpty()	Try to complete the Mono without a value, generating only an onComplete signal.
final Sinks.EmitResult	tryEmitError(Throwable t)	Try to fail the Mono, generating only an onError signal.
Sinks.EmitResult	tryEmitValue(@Nullable 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.Scannable

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

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

asMono, currentSubscriberCount, tryEmitEmpty, tryEmitError

Constructor Details

SinkOneSerialized

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

Method Details

tryEmitValue

public Sinks.EmitResult tryEmitValue(@Nullable 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 Sinks.One.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, ...).

Specified by:

tryEmitValue in interface Sinks.One<T>

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

default void emitValue(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

default 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

default 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

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 Sinks.Empty.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.

Specified by:

tryEmitEmpty in interface Sinks.Empty<T>

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 Sinks.Empty.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.

Specified by:

tryEmitError in interface Sinks.Empty<T>

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.

Specified by:

currentSubscriberCount in interface Sinks.Empty<T>

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.

Specified by:

asMono in interface Sinks.Empty<T>

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)

Specified by:

inners in interface Scannable

Returns:

a Stream of referenced inners (flatmap, multicast etc)

scanUnsafe

public @Nullable 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.

Specified by:

scanUnsafe in interface Scannable

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()