io.vertx.core.streams

## Interface Pump

-     public interface Pump

  Pumps data from a `ReadStream` to a `WriteStream` and performs flow control where necessary to prevent the write stream buffer from getting overfull.

  Instances of this class read items from a `ReadStream` and write them to a `WriteStream`. If data can be read faster than it can be written this could result in the write queue of the `WriteStream` growing without bound, eventually causing it to exhaust all available RAM.

  To prevent this, after each write, instances of this class check whether the write queue of the `WriteStream` is full, and if so, the `ReadStream` is paused, and a `drainHandler` is set on the `WriteStream`.

  When the `WriteStream` has processed half of its backlog, the `drainHandler` will be called, which results in the pump resuming the `ReadStream`.

  This class can be used to pump from any `ReadStream` to any `WriteStream`, e.g. from an `HttpServerRequest` to an `AsyncFile`, or from `NetSocket` to a `WebSocket`.

  Please see the documentation for more information.

  Author:
    Tim Fox

- - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `numberPumped()` Return the total number of items pumped by this pump.
    `static <T> Pump` | `pump(ReadStream<T> rs, WriteStream<T> ws)` Create a new `Pump` with the given `ReadStream` and `WriteStream`
    `static <T> Pump` | `pump(ReadStream<T> rs, WriteStream<T> ws, int writeQueueMaxSize)` Create a new `Pump` with the given `ReadStream` and `WriteStream` and `writeQueueMaxSize`
    `Pump` | `setWriteQueueMaxSize(int maxSize)` Set the write queue max size to `maxSize`
    `Pump` | `start()` Start the Pump.
    `Pump` | `stop()` Stop the Pump.

- - ### Method Detail

    - #### pump

          static <T> Pump pump(ReadStream<T> rs,
                               WriteStream<T> ws)

      Create a new `Pump` with the given `ReadStream` and `WriteStream`
      Parameters:
        `rs` - the read stream
        `ws` - the write stream
      Returns:
        the pump

    - #### pump

          static <T> Pump pump(ReadStream<T> rs,
                               WriteStream<T> ws,
                               int writeQueueMaxSize)

      Create a new `Pump` with the given `ReadStream` and `WriteStream` and `writeQueueMaxSize`
      Parameters:
        `rs` - the read stream
        `ws` - the write stream
        `writeQueueMaxSize` - the max size of the write queue
      Returns:
        the pump

    - #### setWriteQueueMaxSize

          Pump setWriteQueueMaxSize(int maxSize)

      Set the write queue max size to `maxSize`
      Parameters:
        `maxSize` - the max size
      Returns:
        a reference to this, so the API can be used fluently

    - #### start

          Pump start()

      Start the Pump. The Pump can be started and stopped multiple times.
      Returns:
        a reference to this, so the API can be used fluently

    - #### stop

          Pump stop()

      Stop the Pump. The Pump can be started and stopped multiple times.
      Returns:
        a reference to this, so the API can be used fluently

    - #### numberPumped

          int numberPumped()

      Return the total number of items pumped by this pump.

Copyright © 2021 Eclipse. All rights reserved.