io.vertx.reactivex.core.streams

## Class Pump

- java.lang.Object
- - io.vertx.reactivex.core.streams.Pump

-     public class Pump
      extends Object

  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.

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

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static io.vertx.lang.rx.TypeArg<Pump>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Pump(Object delegate)`
    `Pump(Pump delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `equals(Object o)`
    `Pump` | `getDelegate()`
    `int` | `hashCode()`
    `static Pump` | `newInstance(Pump arg)`
    `int` | `numberPumped()` Return the total number of items pumped by this pump.
    `static <T> Pump` | `pump(Flowable<T> rs, WriteStream<T> ws)` Create a new `Pump` with the given `ReadStream` and `WriteStream`
    `static <T> Pump` | `pump(Flowable<T> rs, WriteStream<T> ws, int writeQueueMaxSize)` Create a new `Pump` with the given `ReadStream` and `WriteStream` and `writeQueueMaxSize`
    `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.
    `String` | `toString()`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final io.vertx.lang.rx.TypeArg<Pump> __TYPE_ARG

  - ### Constructor Detail

    - #### Pump

          public Pump(Pump delegate)

    - #### Pump

          public Pump(Object delegate)

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### getDelegate

          public Pump getDelegate()

    - #### pump

          public 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

          public static <T> Pump pump(Flowable<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

          public 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

    - #### pump

          public static <T> Pump pump(Flowable<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

          public 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

          public 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

          public 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

          public int numberPumped()

      Return the total number of items pumped by this pump.
      Returns:

    - #### newInstance

          public static Pump newInstance(Pump arg)

Copyright © 2021 Eclipse. All rights reserved.