reactor.core.composable

Class Deferred<T,C extends Composable<T>>

java.lang.Object

reactor.core.composable.Deferred<T,C>

Type Parameters:

T - The type of the values

C - The composable subclass through which the values can be consumed

All Implemented Interfaces:

Consumer<T>

public class Deferred<T,C extends Composable<T>>
extends java.lang.Object
implements Consumer<T>

A Deferred is used to provide a separate between supplying values and consuming values. Values and errors are supplied by calling accept(Object) and accept(Throwable) respectively. Values can be consumed using the read-only Composable subclass made available by compose().

Typical usage is to create a Deferred and store it internally, only providing the enclosed Composable to clients. This ensures that clients can only consume values and cannot break the contract by also supplying them.

Constructor Summary

Constructors

Constructor and Description
Deferred(C composable) Creates a new Deferred using the given Composable
Deferred(C head, C tail) Creates a new Deferred using decoupled given head and tail Composable

Method Summary

Modifier and Type	Method and Description
void	accept(T value) Accepts the given value such that it can be consumed by the underlying Composable.
void	accept(java.lang.Throwable error) Accepts the given error such that it can be consumed by the underlying Composable.
void	acceptEvent(Event<T> value) Accepts the given value such that it can be consumed by the underlying Composable.
BufferAction<T>	batcher() Return a Consumer that accepts a sequence of events before notifying the Composable whom must be a Stream
BufferAction<T>	batcher(int batchSize) Return a Consumer that accepts a sequence of events before notifying the Composable whom must be a Stream
C	compose() Returns the underlying Composable subclass from which values and errors can be consumed.
void	flush() Flush the Composable such that it can trigger batch operations.

Methods inherited from class java.lang.Object

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

Constructor Detail

Deferred

public Deferred(C composable)

Creates a new Deferred using the given Composable

Parameters:

composable - The composable that will provide access to values

Deferred

public Deferred(C head,
                C tail)

Creates a new Deferred using decoupled given head and tail Composable

Parameters:

head - The composable that will provide access to values

tail - The composable that will be used for consumption

Method Detail

accept

public void accept(java.lang.Throwable error)

Accepts the given error such that it can be consumed by the underlying Composable.

Parameters:

error - The error to accept

accept

public void accept(T value)

Accepts the given value such that it can be consumed by the underlying Composable.

Specified by:

accept in interface Consumer<T>

Parameters:

value - The value to accept

batcher

public BufferAction<T> batcher()

Return a Consumer that accepts a sequence of events before notifying the Composable whom must be a Stream

Returns:

a batch consumer ready to accept sequences

batcher

public BufferAction<T> batcher(int batchSize)

Return a Consumer that accepts a sequence of events before notifying the Composable whom must be a Stream

Parameters:

batchSize - the explicit batch size to use

Returns:

a batch consumer ready to accept sequences

acceptEvent

public void acceptEvent(Event<T> value)

Accepts the given value such that it can be consumed by the underlying Composable.

Parameters:

value - The value to accept

flush

public void flush()

Flush the Composable such that it can trigger batch operations.

compose

public C compose()

Returns the underlying Composable subclass from which values and errors can be consumed.

Returns:

The underlying composable