BlockingSink (reactor-core 3.0.3.RELEASE API)

java.lang.Object
- reactor.core.publisher.BlockingSink<E>

Type Parameters:

E - the element type

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable, java.util.function.Consumer<E>, org.reactivestreams.Subscription, Producer, Trackable
```
public final class BlockingSink<E>
extends java.lang.Object
implements Producer, org.reactivestreams.Subscription, Trackable, java.util.function.Consumer<E>, java.io.Closeable
```
A "hot" sequence source to decorate any Subscriber or Processor. The BlockingSink keeps track of the decorated Subscriber demand. Therefore any emission can be safely sent to the delegate Subscriber by using submit(E) to block on backpressure (missing demand) or emit(E) to never block and return instead an BlockingSink.Emission status. The emitter is itself a Subscriber that will request an unbounded value if subscribed.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class BlockingSink.Emission
An acknowledgement signal returned by emit(E).

Nested Classes
Modifier and Type	Class and Description
`static class`	`BlockingSink.Emission` An acknowledgement signal returned by `emit(E)`.

Field Summary
- Fields inherited from interface reactor.core.Trackable
  UNSPECIFIED

Constructor Summary

Constructors
Modifier Constructor and Description

protected BlockingSink(org.reactivestreams.Subscriber<? super E> actual)

Constructors
Modifier	Constructor and Description
`protected`	`BlockingSink(org.reactivestreams.Subscriber<? super E> actual)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`accept(E e)`
`void`	`cancel()`
`void`	`close()`
`void`	`complete()`
`static <E> BlockingSink<E>`	`create(org.reactivestreams.Subscriber<? super E> subscriber)` Create a `BlockingSink` to safely signal a target `Subscriber` or `Processor`.
`static <E> BlockingSink<E>`	`create(org.reactivestreams.Subscriber<? super E> subscriber, boolean autostart)` Create a `BlockingSink` to safely signal a target `Subscriber` or `Processor`.
`org.reactivestreams.Subscriber<? super E>`	`downstream()` Return the direct data receiver.
`BlockingSink.Emission`	`emit(E data)` A non-blocking `Subscriber.onNext(Object)` that will return a status `BlockingSink.Emission`.
`void`	`error(java.lang.Throwable error)` Try calling `Subscriber.onError(Throwable)` on the delegate `Subscriber`.
`BlockingSink.Emission`	`finish()` Try emitting `complete()` to the decorated `Subscriber`.
`long`	`getCapacity()` Return defined element capacity
`java.lang.Throwable`	`getError()` Current error if any, default to null
`boolean`	`hasFailed()`
`boolean`	`hasRequested()`
`boolean`	`isCancelled()`
`void`	`next(E t)` Try emitting, might throw an unchecked exception.
`void`	`request(long n)`
`long`	`requestedFromDownstream()` Return defined element capacity, used to drive new `Subscription` request needs.
`void`	`start()` Subscribe the decorated actual `Subscriber.onSubscribe(Subscription)`.
`void`	`stop()` Marks the emitter as terminated without completing downstream
`long`	`submit(E data)` Blocking `Subscriber.onNext(Object)` call with an infinite wait on backpressure.
`long`	`submit(E data, long timeout)` Blocking `Subscriber.onNext(Object)` call with a timed wait on backpressure.
`long`	`submit(E data, long timeout, java.util.function.Predicate<E> dropPredicate)` Blocking `Subscriber.onNext(Object)` call with a timed wait on backpressure.
`long`	`submit(E data, long timeout, java.util.concurrent.TimeUnit unit)` Blocking `Subscriber.onNext(Object)` call with a timed wait on backpressure.
`long`	`submit(E data, long timeout, java.util.concurrent.TimeUnit unit, java.util.function.Predicate<E> dropPredicate)` Blocking `Subscriber.onNext(Object)` call with a timed wait on backpressure.
`java.lang.String`	`toString()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface reactor.core.Trackable
expectedFromUpstream, getPending, isStarted, isTerminated, limit

Methods inherited from interface java.util.function.Consumer
andThen

- Constructor Detail
  - BlockingSink
```
protected BlockingSink(org.reactivestreams.Subscriber<? super E> actual)
```
- Method Detail
  - create
```
public static <E> BlockingSink<E> create(org.reactivestreams.Subscriber<? super E> subscriber,
                                         boolean autostart)
```
    Create a BlockingSink to safely signal a target Subscriber or Processor. The subscriber will be immediately started only if the autostart property is true. via Subscriber.onSubscribe(Subscription) as the result of this call.
    
    Type Parameters:
    
    E - the reified Subscriber type
    
    Parameters:
    
    subscriber - the decorated Subscriber
    
    autostart - true if Subscriber.onSubscribe(Subscription) is invoked during this call
    
    Returns:
    
    a new BlockingSink
  - create
```
public static <E> BlockingSink<E> create(org.reactivestreams.Subscriber<? super E> subscriber)
```
    Create a BlockingSink to safely signal a target Subscriber or Processor. The actual will be immediately started via Subscriber.onSubscribe(Subscription) as the result of this call.
    
    Type Parameters:
    
    E - the reified Subscriber type
    
    Parameters:
    
    subscriber - the decorated Subscriber
    
    Returns:
    
    a new pre-subscribed BlockingSink
  - accept
```
public void accept(E e)
```
    Specified by:
    
    accept in interface java.util.function.Consumer<E>
  - cancel
```
public void cancel()
```
    Specified by:
    
    cancel in interface org.reactivestreams.Subscription
  - close
```
public void close()
           throws java.io.IOException
```
    Specified by:
    
    close in interface java.io.Closeable
    
    Specified by:
    
    close in interface java.lang.AutoCloseable
    
    Throws:
    
    java.io.IOException
  - downstream
```
public org.reactivestreams.Subscriber<? super E> downstream()
```
    Description copied from interface: Producer
    
    Return the direct data receiver.
    
    Specified by:
    
    downstream in interface Producer
    
    Returns:
    
    the direct data receiver
  - next
```
public void next(E t)
```
    Try emitting, might throw an unchecked exception.
    
    Parameters:
    
    t - the value to emit, not null
    
    Throws:
    
    java.lang.RuntimeException - the unchecked exception in case of error (eg. IllegalStateException if emission has failed)
    
    See Also:
    
    Subscriber.onNext(Object)
  - emit
```
public BlockingSink.Emission emit(E data)
```
    A non-blocking Subscriber.onNext(Object) that will return a status BlockingSink.Emission. The status will indicate if the decorated actual is backpressuring this BlockingSink and if it has previously been terminated successfully or not.
    
    Parameters:
    
    data - the data to signal
    
    Returns:
    
    an BlockingSink.Emission status
  - error
```
public void error(java.lang.Throwable error)
```
    Try calling Subscriber.onError(Throwable) on the delegate Subscriber. This method might fail itself with an unchecked exception if an error has already been recorded or it has previously been terminated via cancel(), finish() or complete().
    
    Parameters:
    
    error - the exception to signal
  - finish
```
public BlockingSink.Emission finish()
```
    Try emitting complete() to the decorated Subscriber. The completion might not return a successful BlockingSink.Emission.isOk() if this BlockingSink was previously terminated or the delegate failed consuming the signal.
    
    Returns:
    
    an BlockingSink.Emission status
  - getCapacity
```
public long getCapacity()
```
    Description copied from interface: Trackable
    
    Return defined element capacity
    
    Specified by:
    
    getCapacity in interface Trackable
    
    Returns:
    
    long capacity
  - getError
```
public java.lang.Throwable getError()
```
    Description copied from interface: Trackable
    
    Current error if any, default to null
    
    Specified by:
    
    getError in interface Trackable
    
    Returns:
    
    Current error if any, default to null
  - hasFailed
```
public boolean hasFailed()
```
    Returns:
    
    true if the BlockingSink has observed any error
  - hasRequested
```
public boolean hasRequested()
```
    Returns:
    
    true if the decorated Subscriber is actively demanding
  - isCancelled
```
public boolean isCancelled()
```
    Specified by:
    
    isCancelled in interface Trackable
    
    Returns:
    
    has the downstream "cancelled" and interrupted its consuming ?
  - complete
```
public void complete()
```
    See Also:
    
    Subscriber.onComplete()
  - request
```
public void request(long n)
```
    Specified by:
    
    request in interface org.reactivestreams.Subscription
  - requestedFromDownstream
```
public long requestedFromDownstream()
```
    Description copied from interface: Trackable
    
    Return defined element capacity, used to drive new Subscription request needs. This is the maximum in-flight data allowed to transit to this elements.
    
    Specified by:
    
    requestedFromDownstream in interface Trackable
    
    Returns:
    
    long capacity
  - start
```
public void start()
```
    Subscribe the decorated actual Subscriber.onSubscribe(Subscription). If called twice, the current BlockingSink might be cancelled as per Reactive Streams Specification enforce.
  - stop
```
public void stop()
```
    Marks the emitter as terminated without completing downstream
  - submit
```
public long submit(E data)
```
    Blocking Subscriber.onNext(Object) call with an infinite wait on backpressure.
    
    Parameters:
    
    data - the data to signal
    
    Returns:
    
    the emission latency in milliseconds or -1 if emission failed.
  - submit
```
public long submit(E data,
                   long timeout)
```
    Blocking Subscriber.onNext(Object) call with a timed wait on backpressure.
    
    Parameters:
    
    data - the data to signal
    
    timeout - the maximum waiting time in milliseconds before giving up
    
    Returns:
    
    the emission latency in milliseconds or -1 if emission failed.
  - submit
```
public long submit(E data,
                   long timeout,
                   java.util.function.Predicate<E> dropPredicate)
```
    Blocking Subscriber.onNext(Object) call with a timed wait on backpressure. A retry predicate will evaluate when a timeout occurs, returning true will re-schedule an emission while false will drop the signal.
    
    Parameters:
    
    data - the data to signal
    
    timeout - the maximum waiting time in milliseconds before giving up
    
    dropPredicate - the dropped signal callback evaluating if retry should occur or not
    
    Returns:
    
    the emission latency in milliseconds or -1 if emission failed.
  - submit
```
public long submit(E data,
                   long timeout,
                   java.util.concurrent.TimeUnit unit)
```
    Blocking Subscriber.onNext(Object) call with a timed wait on backpressure.
    
    Parameters:
    
    data - the data to signal
    
    timeout - the maximum waiting time in given unit before giving up
    
    unit - the waiting time unit
    
    Returns:
    
    the emission latency in milliseconds or -1 if emission failed.
  - submit
```
public long submit(E data,
                   long timeout,
                   java.util.concurrent.TimeUnit unit,
                   java.util.function.Predicate<E> dropPredicate)
```
    Blocking Subscriber.onNext(Object) call with a timed wait on backpressure. A retry predicate will evaluate when a timeout occurs, returning true will re-schedule an emission while false will drop the signal.
    
    Parameters:
    
    data - the data to signal
    
    timeout - the maximum waiting time in given unit before giving up
    
    unit - the waiting time unit
    
    dropPredicate - the dropped signal callback evaluating if retry should occur or not
    
    Returns:
    
    the emission latency in milliseconds or -1 if emission failed.
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class BlockingSink<E>

Nested Class Summary

Field Summary

Fields inherited from interface reactor.core.Trackable

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface reactor.core.Trackable

Methods inherited from interface java.util.function.Consumer

Constructor Detail

BlockingSink

Method Detail

create

create

accept

cancel

close

downstream

next

emit

error

finish

getCapacity

getError

hasFailed

hasRequested

isCancelled

complete

request

requestedFromDownstream

start

stop

submit

submit

submit

submit

submit

toString