## Uses of Interface
io.vertx.rxjava.core.streams.WriteStream

- Packages that use WriteStream
  Package | Description
  --- | ---
  io.vertx.rxjava.amqp |
  io.vertx.rxjava.cassandra |
  io.vertx.rxjava.core |
  io.vertx.rxjava.core.datagram |
  io.vertx.rxjava.core.eventbus |
  io.vertx.rxjava.core.file |
  io.vertx.rxjava.core.http |
  io.vertx.rxjava.core.net |
  io.vertx.rxjava.core.parsetools |
  io.vertx.rxjava.core.streams |
  io.vertx.rxjava.ext.sql |
  io.vertx.rxjava.ext.unit.report |
  io.vertx.rxjava.ext.web.codec |
  io.vertx.rxjava.ext.web.handler.sockjs |
  io.vertx.rxjava.kafka.client.consumer |
  io.vertx.rxjava.kafka.client.producer |
  io.vertx.rxjava.pgclient.pubsub |
  io.vertx.rxjava.rabbitmq |
  io.vertx.rxjava.redis.client |
  io.vertx.rxjava.sqlclient |

- - ### Uses of WriteStream in io.vertx.rxjava.amqp

    Classes in io.vertx.rxjava.amqp that implement WriteStream
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AmqpSender` AMQP Sender interface used to send messages.

    Methods in io.vertx.rxjava.amqp that return WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<AmqpMessage>` | AmqpSender.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.

    Methods in io.vertx.rxjava.amqp with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | AmqpReceiver.`pipeTo(WriteStream<AmqpMessage> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | AmqpReceiver.`pipeTo(WriteStream<AmqpMessage> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Single<Void>` | AmqpReceiver.`rxPipeTo(WriteStream<AmqpMessage> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.cassandra

    Methods in io.vertx.rxjava.cassandra with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | CassandraRowStream.`pipeTo(WriteStream<com.datastax.driver.core.Row> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | CassandraRowStream.`pipeTo(WriteStream<com.datastax.driver.core.Row> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Single<Void>` | CassandraRowStream.`rxPipeTo(WriteStream<com.datastax.driver.core.Row> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.core

    Methods in io.vertx.rxjava.core with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | TimeoutStream.`pipeTo(WriteStream<Long> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | TimeoutStream.`pipeTo(WriteStream<Long> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Observable<Void>` | TimeoutStream.`pipeToObservable(WriteStream<Long> dst)` Deprecated. use `TimeoutStream.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<java.lang.Long>)` instead
    `Single<Void>` | TimeoutStream.`rxPipeTo(WriteStream<Long> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.core.datagram

    Methods in io.vertx.rxjava.core.datagram that return WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<Buffer>` | DatagramSocket.`sender(int port, String host)` Returns a `WriteStream` able to send to the `SocketAddress`.

    Methods in io.vertx.rxjava.core.datagram with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | DatagramSocket.`pipeTo(WriteStream<DatagramPacket> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | DatagramSocket.`pipeTo(WriteStream<DatagramPacket> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Observable<Void>` | DatagramSocket.`pipeToObservable(WriteStream<DatagramPacket> dst)` Deprecated. use `DatagramSocket.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.datagram.DatagramPacket>)` instead
    `Single<Void>` | DatagramSocket.`rxPipeTo(WriteStream<DatagramPacket> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.core.eventbus

    Classes in io.vertx.rxjava.core.eventbus that implement WriteStream
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MessageProducer<T>` Represents a stream of message that can be written to.

    Methods in io.vertx.rxjava.core.eventbus with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | MessageConsumer.`pipeTo(WriteStream<Message<T>> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | MessageConsumer.`pipeTo(WriteStream<Message<T>> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Observable<Void>` | MessageConsumer.`pipeToObservable(WriteStream<Message<T>> dst)` Deprecated. use `MessageConsumer.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.eventbus.Message<T>>)` instead
    `Single<Void>` | MessageConsumer.`rxPipeTo(WriteStream<Message<T>> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.core.file

    Classes in io.vertx.rxjava.core.file that implement WriteStream
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AsyncFile` Represents a file on the file-system which can be read from, or written to asynchronously.

    Methods in io.vertx.rxjava.core.file with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | AsyncFile.`pipeTo(WriteStream<Buffer> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | AsyncFile.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Observable<Void>` | AsyncFile.`pipeToObservable(WriteStream<Buffer> dst)` Deprecated. use `AsyncFile.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>)` instead
    `Single<Void>` | AsyncFile.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.core.http

    Subinterfaces of WriteStream in io.vertx.rxjava.core.http
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `WebSocketBase` Base WebSocket implementation.

    Classes in io.vertx.rxjava.core.http that implement WriteStream
    Modifier and Type | Class and Description
    --- | ---
    `class` | `HttpClientRequest` Represents a client-side HTTP request.
    `class` | `HttpServerResponse` Represents a server-side HTTP response.
    `class` | `ServerWebSocket` Represents a server side WebSocket.
    `class` | `WebSocket` Represents a client-side WebSocket.

    Methods in io.vertx.rxjava.core.http with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | HttpClientResponse.`pipeTo(WriteStream<Buffer> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | ServerWebSocket.`pipeTo(WriteStream<Buffer> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | WebSocket.`pipeTo(WriteStream<Buffer> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | HttpServerFileUpload.`pipeTo(WriteStream<Buffer> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | HttpServerRequest.`pipeTo(WriteStream<Buffer> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | WebSocketBase.`pipeTo(WriteStream<Buffer> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | HttpClientResponse.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | ServerWebSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | WebSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpServerFileUpload.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpServerRequest.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | WebSocketBase.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpClientRequest.`pipeTo(WriteStream<HttpClientResponse> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | HttpClientRequest.`pipeTo(WriteStream<HttpClientResponse> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Observable<Void>` | HttpClientResponse.`pipeToObservable(WriteStream<Buffer> dst)` Deprecated. use `HttpClientResponse.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>)` instead
    `Observable<Void>` | ServerWebSocket.`pipeToObservable(WriteStream<Buffer> dst)` Deprecated. use `ServerWebSocket.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>)` instead
    `Observable<Void>` | WebSocket.`pipeToObservable(WriteStream<Buffer> dst)` Deprecated. use `WebSocket.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>)` instead
    `Observable<Void>` | HttpServerFileUpload.`pipeToObservable(WriteStream<Buffer> dst)` Deprecated. use `HttpServerFileUpload.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>)` instead
    `Observable<Void>` | HttpServerRequest.`pipeToObservable(WriteStream<Buffer> dst)` Deprecated. use `HttpServerRequest.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>)` instead
    `Observable<Void>` | HttpClientRequest.`pipeToObservable(WriteStream<HttpClientResponse> dst)` Deprecated. use `HttpClientRequest.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.http.HttpClientResponse>)` instead
    `Single<Void>` | HttpClientResponse.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `Single<Void>` | ServerWebSocket.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `Single<Void>` | WebSocket.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `Single<Void>` | HttpServerFileUpload.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `Single<Void>` | HttpServerRequest.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `Single<Void>` | HttpClientRequest.`rxPipeTo(WriteStream<HttpClientResponse> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.core.net

    Classes in io.vertx.rxjava.core.net that implement WriteStream
    Modifier and Type | Class and Description
    --- | ---
    `class` | `NetSocket` Represents a socket-like interface to a TCP connection on either the client or the server side.

    Methods in io.vertx.rxjava.core.net with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | NetSocket.`pipeTo(WriteStream<Buffer> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | NetSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Observable<Void>` | NetSocket.`pipeToObservable(WriteStream<Buffer> dst)` Deprecated. use `NetSocket.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>)` instead
    `Single<Void>` | NetSocket.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.core.parsetools

    Methods in io.vertx.rxjava.core.parsetools with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | RecordParser.`pipeTo(WriteStream<Buffer> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | RecordParser.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | JsonParser.`pipeTo(WriteStream<JsonEvent> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | JsonParser.`pipeTo(WriteStream<JsonEvent> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Observable<Void>` | RecordParser.`pipeToObservable(WriteStream<Buffer> dst)` Deprecated. use `RecordParser.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>)` instead
    `Observable<Void>` | JsonParser.`pipeToObservable(WriteStream<JsonEvent> dst)` Deprecated. use `JsonParser.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.parsetools.JsonEvent>)` instead
    `Single<Void>` | RecordParser.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `Single<Void>` | JsonParser.`rxPipeTo(WriteStream<JsonEvent> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.core.streams

    Methods in io.vertx.rxjava.core.streams that return WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<T>` | WriteStream.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `WriteStream<T>` | WriteStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the write stream.
    `static <T> WriteStream<T>` | WriteStream.`newInstance(WriteStream arg)`
    `static <T> WriteStream<T>` | WriteStream.`newInstance(WriteStream arg, io.vertx.lang.rx.TypeArg<T> __typeArg_T)`
    `WriteStream<T>` | WriteStream.`setWriteQueueMaxSize(int maxSize)` Set the maximum size of the write queue to `maxSize`.
    `WriteStream<T>` | WriteStream.`write(T data)` Write some data to the stream.
    `WriteStream<T>` | WriteStream.`write(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

    Methods in io.vertx.rxjava.core.streams with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | ReadStream.`pipeTo(WriteStream<T> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | ReadStream.`pipeTo(WriteStream<T> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `static <T> Pump` | Pump.`pump(Observable<T> rs, WriteStream<T> ws)` Create a new `Pump` with the given `ReadStream` and `WriteStream`
    `static <T> Pump` | Pump.`pump(Observable<T> rs, WriteStream<T> ws, int writeQueueMaxSize)` Create a new `Pump` with the given `ReadStream` and `WriteStream` and `writeQueueMaxSize`
    `static <T> Pump` | Pump.`pump(ReadStream<T> rs, WriteStream<T> ws)` Create a new `Pump` with the given `ReadStream` and `WriteStream`
    `static <T> Pump` | Pump.`pump(ReadStream<T> rs, WriteStream<T> ws, int writeQueueMaxSize)` Create a new `Pump` with the given `ReadStream` and `WriteStream` and `writeQueueMaxSize`
    `Single<Void>` | Pipe.`rxTo(WriteStream<T> dst)` Start to pipe the elements to the destination `WriteStream`.
    `void` | Pipe.`to(WriteStream<T> dst)` Like `Pipe.to(io.vertx.rxjava.core.streams.WriteStream<T>)` but without a completion handler
    `void` | Pipe.`to(WriteStream<T> dst, Handler<AsyncResult<Void>> completionHandler)` Start to pipe the elements to the destination `WriteStream`.
    `Observable<Void>` | Pipe.`toObservable(WriteStream<T> dst)` Deprecated. use `Pipe.rxTo(io.vertx.rxjava.core.streams.WriteStream<T>)` instead

  - ### Uses of WriteStream in io.vertx.rxjava.ext.sql

    Methods in io.vertx.rxjava.ext.sql with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | SQLRowStream.`pipeTo(WriteStream<JsonArray> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | SQLRowStream.`pipeTo(WriteStream<JsonArray> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Observable<Void>` | SQLRowStream.`pipeToObservable(WriteStream<JsonArray> dst)` Deprecated. use `SQLRowStream.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.core.json.JsonArray>)` instead
    `Single<Void>` | SQLRowStream.`rxPipeTo(WriteStream<JsonArray> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.ext.unit.report

    Methods in io.vertx.rxjava.ext.unit.report with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | TestSuiteReport.`pipeTo(WriteStream<TestCaseReport> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | TestSuiteReport.`pipeTo(WriteStream<TestCaseReport> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Observable<Void>` | TestSuiteReport.`pipeToObservable(WriteStream<TestCaseReport> dst)` Deprecated. use `TestSuiteReport.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.ext.unit.report.TestCaseReport>)` instead
    `Single<Void>` | TestSuiteReport.`rxPipeTo(WriteStream<TestCaseReport> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.ext.web.codec

    Methods in io.vertx.rxjava.ext.web.codec with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `static BodyCodec<Void>` | BodyCodec.`pipe(WriteStream<Buffer> stream)` A body codec that pipes the body to a write stream.
    `static BodyCodec<Void>` | BodyCodec.`pipe(WriteStream<Buffer> stream, boolean close)` A body codec that pipes the body to a write stream.

  - ### Uses of WriteStream in io.vertx.rxjava.ext.web.handler.sockjs

    Classes in io.vertx.rxjava.ext.web.handler.sockjs that implement WriteStream
    Modifier and Type | Class and Description
    --- | ---
    `class` | `SockJSSocket` You interact with SockJS clients through instances of SockJS socket.

    Methods in io.vertx.rxjava.ext.web.handler.sockjs with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | SockJSSocket.`pipeTo(WriteStream<Buffer> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | SockJSSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Observable<Void>` | SockJSSocket.`pipeToObservable(WriteStream<Buffer> dst)` Deprecated. use `SockJSSocket.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>)` instead
    `Single<Void>` | SockJSSocket.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.kafka.client.consumer

    Methods in io.vertx.rxjava.kafka.client.consumer with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | KafkaConsumer.`pipeTo(WriteStream<KafkaConsumerRecord<K,V>> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | KafkaConsumer.`pipeTo(WriteStream<KafkaConsumerRecord<K,V>> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Single<Void>` | KafkaConsumer.`rxPipeTo(WriteStream<KafkaConsumerRecord<K,V>> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.kafka.client.producer

    Classes in io.vertx.rxjava.kafka.client.producer that implement WriteStream
    Modifier and Type | Class and Description
    --- | ---
    `class` | `KafkaProducer<K,V>` Vert.x Kafka producer.

  - ### Uses of WriteStream in io.vertx.rxjava.pgclient.pubsub

    Methods in io.vertx.rxjava.pgclient.pubsub with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | PgChannel.`pipeTo(WriteStream<String> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | PgChannel.`pipeTo(WriteStream<String> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Single<Void>` | PgChannel.`rxPipeTo(WriteStream<String> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.rabbitmq

    Methods in io.vertx.rxjava.rabbitmq with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | RabbitMQConsumer.`pipeTo(WriteStream<RabbitMQMessage> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | RabbitMQConsumer.`pipeTo(WriteStream<RabbitMQMessage> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Observable<Void>` | RabbitMQConsumer.`pipeToObservable(WriteStream<RabbitMQMessage> dst)` Deprecated. use `RabbitMQConsumer.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.rabbitmq.RabbitMQMessage>)` instead
    `Single<Void>` | RabbitMQConsumer.`rxPipeTo(WriteStream<RabbitMQMessage> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.redis.client

    Methods in io.vertx.rxjava.redis.client with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | RedisConnection.`pipeTo(WriteStream<Response> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | RedisConnection.`pipeTo(WriteStream<Response> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Observable<Void>` | RedisConnection.`pipeToObservable(WriteStream<Response> dst)` Deprecated. use `RedisConnection.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.redis.client.Response>)` instead
    `Single<Void>` | RedisConnection.`rxPipeTo(WriteStream<Response> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of WriteStream in io.vertx.rxjava.sqlclient

    Methods in io.vertx.rxjava.sqlclient with parameters of type WriteStream
    Modifier and Type | Method and Description
    --- | ---
    `void` | RowStream.`pipeTo(WriteStream<T> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | RowStream.`pipeTo(WriteStream<T> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Single<Void>` | RowStream.`rxPipeTo(WriteStream<T> dst)` Pipe this `ReadStream` to the `WriteStream`.

Copyright © 2020 Eclipse. All rights reserved.