Package io.vertx.mutiny.core.streams

Interface WriteStream<T>

All Superinterfaces:

StreamBase

All Known Subinterfaces:

WebSocketBase

All Known Implementing Classes:

AmqpSender, AsyncFile, 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 Mutiny-ified interface using Vert.x codegen.

Method Summary

Modifier and Type	Method	Description
WriteStream<T>	drainHandler(Runnable handler)
io.smallrye.mutiny.Uni<Void>	end()	Same as end() but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	end(T data)	Same as but with an handler called when the operation completes
Void	endAndAwait()	Blocking variant of end().
Void	endAndAwait(T data)	Blocking variant of io.vertx.mutiny.core.streams.WriteStream#end(T).
void	endAndForget()	Variant of end() that ignores the result of the operation.
void	endAndForget(T data)	Variant of io.vertx.mutiny.core.streams.WriteStream#end(T) that ignores the result of the operation.
WriteStream<T>	exceptionHandler(Consumer<Throwable> handler)
io.vertx.core.streams.WriteStream	getDelegate()
static <T> WriteStream<T>	newInstance(io.vertx.core.streams.WriteStream arg)
static <T> WriteStream<T>	newInstance(io.vertx.core.streams.WriteStream arg, TypeArg<T> __typeArg_T)
WriteStream<T>	setWriteQueueMaxSize(int maxSize)
io.smallrye.mutiny.Uni<Void>	write(T data)	Same as but with an handler called when the operation completes
Void	writeAndAwait(T data)	Blocking variant of io.vertx.mutiny.core.streams.WriteStream#write(T).
void	writeAndForget(T data)	Variant of io.vertx.mutiny.core.streams.WriteStream#write(T) that ignores the result of the operation.
boolean	writeQueueFull()

Method Detail

getDelegate

io.vertx.core.streams.WriteStream getDelegate()

Specified by:

getDelegate in interface StreamBase

exceptionHandler

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

Specified by:

exceptionHandler in interface StreamBase

Parameters:

handler - the exception handler

Returns:

write

io.smallrye.mutiny.Uni<Void> write(T data)

Same as but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Parameters:

data -

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writeAndAwait

Void writeAndAwait(T data)

Blocking variant of io.vertx.mutiny.core.streams.WriteStream#write(T).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Parameters:

data -

Returns:

the Void instance produced by the operation.

writeAndForget

void writeAndForget(T data)

Variant of io.vertx.mutiny.core.streams.WriteStream#write(T) that ignores the result of the operation.

This method subscribes on the result of io.vertx.mutiny.core.streams.WriteStream#write(T), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.core.streams.WriteStream#write(T) but you don't need to compose it with other operations.

Parameters:

data -

end

io.smallrye.mutiny.Uni<Void> end()

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

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

endAndAwait

Void endAndAwait()

Blocking variant of end().

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Returns:

the Void instance produced by the operation.

endAndForget

void endAndForget()

Variant of end() that ignores the result of the operation.

This method subscribes on the result of end(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from end() but you don't need to compose it with other operations.

end

io.smallrye.mutiny.Uni<Void> end(T data)

Same as but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Parameters:

data -

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

endAndAwait

Void endAndAwait(T data)

Blocking variant of io.vertx.mutiny.core.streams.WriteStream#end(T).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Parameters:

data -

Returns:

the Void instance produced by the operation.

endAndForget

void endAndForget(T data)

Variant of io.vertx.mutiny.core.streams.WriteStream#end(T) that ignores the result of the operation.

This method subscribes on the result of io.vertx.mutiny.core.streams.WriteStream#end(T), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.core.streams.WriteStream#end(T) but you don't need to compose it with other operations.

Parameters:

data -

setWriteQueueMaxSize

WriteStream<T> setWriteQueueMaxSize(int maxSize)

Parameters:

maxSize - the max size of the write stream

Returns:

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

writeQueueFull

boolean writeQueueFull()

Returns:

true if write queue is full

drainHandler

WriteStream<T> drainHandler(Runnable handler)

Parameters:

handler - the handler

Returns:

newInstance

static <T> WriteStream<T> newInstance(io.vertx.core.streams.WriteStream arg)

newInstance

static <T> WriteStream<T> newInstance(io.vertx.core.streams.WriteStream arg,
                                      TypeArg<T> __typeArg_T)