Package io.vertx.mutiny.core.streams

Class Pipe<T>

  • public class Pipe<T>
extends Object
    Pipe 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 pipe 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 Mutiny-ified interface using Vert.x codegen.

    • Field Detail

      • __TYPE_ARG

        public static final TypeArg<Pipe> __TYPE_ARG

      • __typeArg_0

        public final TypeArg<T> __typeArg_0

    • Constructor Detail

      • Pipe

        public Pipe​(io.vertx.core.streams.Pipe delegate)

      • Pipe

        public Pipe​(io.vertx.core.streams.Pipe delegate,
            TypeArg<T> typeArg_0)

    • Method Detail

      • getDelegate

        public io.vertx.core.streams.Pipe getDelegate()

      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object

      • endOnFailure

        public Pipe<T> endOnFailure​(boolean end)
        Parameters:
        end - true to end the stream on a source ReadStream failure
        Returns:
        a reference to this, so the API can be used fluently

      • endOnSuccess

        public Pipe<T> endOnSuccess​(boolean end)
        Parameters:
        end - true to end the stream on a source ReadStream success
        Returns:
        a reference to this, so the API can be used fluently

      • endOnComplete

        public Pipe<T> endOnComplete​(boolean end)
        Parameters:
        end - true to end the stream on a source ReadStream completion
        Returns:
        a reference to this, so the API can be used fluently

      • to

        public io.smallrye.mutiny.Uni<Void> to​(WriteStream<T> dst)
        Start to pipe the elements to the destination WriteStream.

        When the operation fails with a write error, the source stream is resumed.

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

        Parameters:
        dst - the destination write stream
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • toAndAwait

        public Void toAndAwait​(WriteStream<T> dst)
        Blocking variant of io.vertx.mutiny.core.streams.Pipe#to(io.vertx.mutiny.core.streams.WriteStream).

        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:
        dst - the destination write stream
        Returns:
        the Void instance produced by the operation.

      • toAndForget

        public void toAndForget​(WriteStream<T> dst)
        Variant of io.vertx.mutiny.core.streams.Pipe#to(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.

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

        Parameters:
        dst - the destination write stream

      • close

        public void close()

      • newInstance

        public static <T> Pipe<T> newInstance​(io.vertx.core.streams.Pipe arg)

      • newInstance

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