io.vertx.rxjava3.core.streams

Interface WriteStream<T>

All Superinterfaces:

StreamBase

All Known Subinterfaces:

WebSocketBase

All Known Implementing Classes:

AmqpSender, AsyncFile, ClientWebSocket, GrpcClientRequest, GrpcServerResponse, GrpcWriteStream, HttpClientRequest, HttpServerResponse, KafkaProducer, NetSocket, ServerWebSocket, SockJSSocket, WebSocket

public interface WriteStream<T>
extends StreamBase

Represents a stream of data that can be written to.

Any class that implements this interface can be used by a Pipe to pipe data from a ReadStream to it.

NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.

Method Summary

Modifier and Type	Method and Description
WriteStream<T>	drainHandler(Handler<Void> handler) Set a drain handler on the stream.
Completable	end() Same as end() but with an handler called when the operation completes
Completable	end(T data) Same as but with an handler called when the operation completes
WriteStream<T>	exceptionHandler(Handler<Throwable> handler) Set an exception handler on the write stream.
WriteStream	getDelegate()
static <T> WriteStream<T>	newInstance(WriteStream arg)
static <T> WriteStream<T>	newInstance(WriteStream arg, io.vertx.lang.rx.TypeArg<T> __typeArg_T)
Completable	rxEnd() Same as end() but with an handler called when the operation completes
Completable	rxEnd(T data) Same as but with an handler called when the operation completes
Completable	rxWrite(T data) Same as but with an handler called when the operation completes
WriteStream<T>	setWriteQueueMaxSize(int maxSize) Set the maximum size of the write queue to maxSize.
WriteStreamObserver<T>	toObserver()
WriteStreamSubscriber<T>	toSubscriber()
Completable	write(T data) Same as but with an handler called when the operation completes
boolean	writeQueueFull() This will return true if there are more bytes in the write queue than the value set using setWriteQueueMaxSize(int)

Methods inherited from interface io.vertx.rxjava3.core.streams.StreamBase

newInstance

Method Detail

getDelegate

WriteStream getDelegate()

Specified by:

getDelegate in interface StreamBase

exceptionHandler

WriteStream<T> exceptionHandler(Handler<Throwable> handler)

Set an exception handler on the write stream.

Specified by:

exceptionHandler in interface StreamBase

Parameters:

handler - the exception handler

Returns:

a reference to this, so the API can be used fluently

write

Completable write(T data)

Same as but with an handler called when the operation completes

Parameters:

data -

Returns:

rxWrite

Completable rxWrite(T data)

Same as but with an handler called when the operation completes

Parameters:

data -

Returns:

end

Completable end()

Same as end() but with an handler called when the operation completes

Returns:

rxEnd

Completable rxEnd()

Same as end() but with an handler called when the operation completes

Returns:

end

Completable end(T data)

Same as but with an handler called when the operation completes

Parameters:

data -

Returns:

rxEnd

Completable rxEnd(T data)

Same as but with an handler called when the operation completes

Parameters:

data -

Returns:

setWriteQueueMaxSize

WriteStream<T> setWriteQueueMaxSize(int maxSize)

Set the maximum size of the write queue to maxSize. You will still be able to write to the stream even if there is more than maxSize items in the write queue. This is used as an indicator by classes such as Pipe to provide flow control.

The value is defined by the implementation of the stream, e.g in bytes for a NetSocket, etc...

Parameters:

maxSize - the max size of the write stream

Returns:

a reference to this, so the API can be used fluently

writeQueueFull

boolean writeQueueFull()

This will return true if there are more bytes in the write queue than the value set using setWriteQueueMaxSize(int)

Returns:

true if write queue is full

drainHandler

WriteStream<T> drainHandler(Handler<Void> handler)

Set a drain handler on the stream. If the write queue is full, then the handler will be called when the write queue is ready to accept buffers again. See Pipe for an example of this being used.

The stream implementation defines when the drain handler, for example it could be when the queue size has been reduced to maxSize / 2.

Parameters:

handler - the handler

Returns:

a reference to this, so the API can be used fluently

toObserver

WriteStreamObserver<T> toObserver()

toSubscriber

WriteStreamSubscriber<T> toSubscriber()

newInstance

static <T> WriteStream<T> newInstance(WriteStream arg)

newInstance

static <T> WriteStream<T> newInstance(WriteStream arg,
                                      io.vertx.lang.rx.TypeArg<T> __typeArg_T)