Package io.vertx.mutiny.core.net

Class QuicStream

java.lang.Object
io.vertx.mutiny.core.net.QuicStream
All Implemented Interfaces:
MutinyDelegate, StreamChannel, ReadStream<io.vertx.core.buffer.Buffer>, StreamBase, WriteStream<io.vertx.core.buffer.Buffer>
public class QuicStream extends Object implements StreamChannel, MutinyDelegate
A Quic stream.

NOTE: This class has been automatically generated from the original non Mutiny-ified interface.

Author:
Julien Viet
See Also:
  • QuicStream

  • Nested Class Summary

    Nested classes/interfaces inherited from interface io.vertx.mutiny.core.streams.ReadStream

    ReadStream.ReadStreamImpl<T>

    Nested classes/interfaces inherited from interface io.vertx.mutiny.core.streams.StreamBase

    StreamBase.StreamBaseImpl

    Nested classes/interfaces inherited from interface io.vertx.mutiny.core.net.StreamChannel

    StreamChannel.StreamChannelImpl

    Nested classes/interfaces inherited from interface io.vertx.mutiny.core.streams.WriteStream

    WriteStream.WriteStreamImpl<T>

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final TypeArg<QuicStream>
    __TYPE_ARG
     

  • Constructor Summary

    Constructors
    Constructor
    Description
    QuicStream(io.vertx.core.net.QuicStream delegate)
    Create a new instance of QuicStream delegating to the given (non-null) instance of QuicStream.
    QuicStream(Object delegate)
     

  • Method Summary

    Modifier and Type
    Method
    Description
    io.smallrye.mutiny.Uni<Void>
    abort(int error)
    Instruct the remote peer that this part of the stream is no longer interested in received data and wants it to cease transmission, a STOP_SENDING frame is sent to the remote peer.
    void
    abortAndAwait(int error)
    Instruct the remote peer that this part of the stream is no longer interested in received data and wants it to cease transmission, a STOP_SENDING frame is sent to the remote peer.
    QuicStream
    abortAndForget(int error)
    Instruct the remote peer that this part of the stream is no longer interested in received data and wants it to cease transmission, a STOP_SENDING frame is sent to the remote peer.
    io.smallrye.mutiny.Uni<Void>
    close()
    Close the channel
    void
    closeAndAwait()
    Close the channel
    QuicStream
    closeAndForget()
    Close the channel
    QuicStream
    closeHandler(Runnable handler)
    Set a handler called when the stream is closed.
    QuicConnection
    connection()
     
    QuicStream
    drainHandler(Runnable handler)
    Set a drain handler on the stream.
    io.smallrye.mutiny.Uni<Void>
    end()
    Calls close()
    io.smallrye.mutiny.Uni<Void>
    end(io.vertx.core.buffer.Buffer arg0)
    Same as end() but writes some data to the stream before ending.
    void
    endAndAwait()
    Calls close()
    void
    endAndAwait(io.vertx.core.buffer.Buffer arg0)
    Same as end() but writes some data to the stream before ending.
    QuicStream
    endAndForget()
    Calls close()
    QuicStream
    endAndForget(io.vertx.core.buffer.Buffer arg0)
    Same as end() but writes some data to the stream before ending.
    QuicStream
    endHandler(Runnable endHandler)
    Set an end handler.
    boolean
    equals(Object o)
     
    QuicStream
    exceptionHandler(Consumer<Throwable> handler)
    Set an exception handling, catching stream exceptions.
    QuicStream
    fetch(long amount)
    Fetch the specified amount of elements.
    io.vertx.core.net.QuicStream
    getDelegate()
    Get the delegate instance.
    QuicStream
    handler(Consumer<io.vertx.core.buffer.Buffer> handler)
    Set the handler signaled with the data events the remote peer has sent.
    int
    hashCode()
     
    long
    id()
     
    boolean
    isBidirectional()
     
    boolean
    isLocalCreated()
     
    static QuicStream
    newInstance(io.vertx.core.net.QuicStream delegate)
    Creates a new instance of the QuicStream.
    QuicStream
    pause()
    Pause the ReadStream, it sets the buffer in fetch mode and clears the actual demand.
    Pipe<io.vertx.core.buffer.Buffer>
    pipe()
    Pause this stream and return a Pipe to transfer the elements of this stream to a destination WriteStream.
    io.smallrye.mutiny.Uni<Void>
    pipeTo(WriteStream<io.vertx.core.buffer.Buffer> arg0)
    Pipe this ReadStream to the WriteStream.
    void
    pipeToAndAwait(WriteStream<io.vertx.core.buffer.Buffer> arg0)
    Pipe this ReadStream to the WriteStream.
    QuicStream
    pipeToAndForget(WriteStream<io.vertx.core.buffer.Buffer> arg0)
    Pipe this ReadStream to the WriteStream.
    io.smallrye.mutiny.Uni<Void>
    reset(int error)
    Abruptly terminate the sending part of the stream with the specified application protocol error code argument, a RESET frame is sent to the remote peer.
    void
    resetAndAwait(int error)
    Abruptly terminate the sending part of the stream with the specified application protocol error code argument, a RESET frame is sent to the remote peer.
    QuicStream
    resetAndForget(int error)
    Abruptly terminate the sending part of the stream with the specified application protocol error code argument, a RESET frame is sent to the remote peer.
    QuicStream
    resetHandler(Consumer<Long> handler)
    Set a handler called upon stream reset: when a stream receives a reset frame from its peer, this handler is called.
    QuicStream
    resume()
    Resume reading, and sets the buffer in flowing mode.
    io.smallrye.mutiny.Uni<Void>
    sendFile(String arg0)
    Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    io.smallrye.mutiny.Uni<Void>
    sendFile(String arg0, long arg1)
    Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    io.smallrye.mutiny.Uni<Void>
    sendFile(String arg0, long arg1, long arg2)
    Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    void
    sendFileAndAwait(String arg0)
    Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    void
    sendFileAndAwait(String arg0, long arg1)
    Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    void
    sendFileAndAwait(String arg0, long arg1, long arg2)
    Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    QuicStream
    sendFileAndForget(String arg0)
    Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    QuicStream
    sendFileAndForget(String arg0, long arg1)
    Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    QuicStream
    sendFileAndForget(String arg0, long arg1, long arg2)
    Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    QuicStream
    setWriteQueueMaxSize(int maxSize)
    Set the maximum size of the write queue to maxSize.
    QuicStream
    shutdownHandler(Consumer<Duration> handler)
    Set a handler called when the stream is shutdown or closed
    Iterable<io.vertx.core.buffer.Buffer>
    toBlockingIterable()
     
    Stream<io.vertx.core.buffer.Buffer>
    toBlockingStream()
     
    io.smallrye.mutiny.Multi<io.vertx.core.buffer.Buffer>
    toMulti()
     
    String
    toString()
     
    Flow.Subscriber<io.vertx.core.buffer.Buffer>
    toSubscriber()
    Converts the current write stream to a subscriber.
    io.smallrye.mutiny.Uni<Void>
    write(io.vertx.core.buffer.Buffer arg0)
    Write some data to the stream.
    io.smallrye.mutiny.Uni<Void>
    write(String arg0)
    Write a String to the connection, encoded in UTF-8.
    io.smallrye.mutiny.Uni<Void>
    write(String arg0, String arg1)
    Write a String to the connection, encoded using the encoding enc.
    void
    writeAndAwait(io.vertx.core.buffer.Buffer arg0)
    Write some data to the stream.
    void
    writeAndAwait(String arg0)
    Write a String to the connection, encoded in UTF-8.
    void
    writeAndAwait(String arg0, String arg1)
    Write a String to the connection, encoded using the encoding enc.
    QuicStream
    writeAndForget(io.vertx.core.buffer.Buffer arg0)
    Write some data to the stream.
    QuicStream
    writeAndForget(String arg0)
    Write a String to the connection, encoded in UTF-8.
    QuicStream
    writeAndForget(String arg0, String arg1)
    Write a String to the connection, encoded using the encoding enc.
    boolean
    writeQueueFull()
    This will return true if there are more bytes in the write queue than the value set using setWriteQueueMaxSize(int)

    Methods inherited from class java.lang.Object

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

  • Field Details

  • Constructor Details

    • QuicStream

      public QuicStream(io.vertx.core.net.QuicStream delegate)
      Create a new instance of QuicStream delegating to the given (non-null) instance of QuicStream.

    • QuicStream

      public QuicStream(Object delegate)

  • Method Details

    • getDelegate

      public io.vertx.core.net.QuicStream getDelegate()
      Get the delegate instance.

      This method returns the instance on which this shim is delegating the calls. And so, give you access to the bare API.

      Specified by:
      getDelegate in interface MutinyDelegate
      Specified by:
      getDelegate in interface ReadStream<io.vertx.core.buffer.Buffer>
      Specified by:
      getDelegate in interface StreamBase
      Specified by:
      getDelegate in interface StreamChannel
      Specified by:
      getDelegate in interface WriteStream<io.vertx.core.buffer.Buffer>
      Returns:
      the delegate instance

    • reset

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> reset(int error)
      Abruptly terminate the sending part of the stream with the specified application protocol error code argument, a RESET frame is sent to the remote peer.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      error - the application protocol error code
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • QuicStream.reset(int)

    • resetAndAwait

      public void resetAndAwait(int error)
      Abruptly terminate the sending part of the stream with the specified application protocol error code argument, a RESET frame is sent to the remote peer.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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:
      error - the application protocol error code
      See Also:
      • QuicStream.reset(int)

    • resetAndForget

      public QuicStream resetAndForget(int error)
      Abruptly terminate the sending part of the stream with the specified application protocol error code argument, a RESET frame is sent to the remote peer.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      error - the application protocol error code
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • QuicStream.reset(int)

    • abort

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> abort(int error)
      Instruct the remote peer that this part of the stream is no longer interested in received data and wants it to cease transmission, a STOP_SENDING frame is sent to the remote peer.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      error - the error code
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • QuicStream.abort(int)

    • abortAndAwait

      public void abortAndAwait(int error)
      Instruct the remote peer that this part of the stream is no longer interested in received data and wants it to cease transmission, a STOP_SENDING frame is sent to the remote peer.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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:
      error - the error code
      See Also:
      • QuicStream.abort(int)

    • abortAndForget

      public QuicStream abortAndForget(int error)
      Instruct the remote peer that this part of the stream is no longer interested in received data and wants it to cease transmission, a STOP_SENDING frame is sent to the remote peer.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      error - the error code
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • QuicStream.abort(int)

    • pipeTo

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> pipeTo(WriteStream<io.vertx.core.buffer.Buffer> arg0)
      Pipe this ReadStream to the WriteStream.

      Elements emitted by this stream will be written to the write stream until this stream ends or fails.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      pipeTo in interface ReadStream<io.vertx.core.buffer.Buffer>
      Specified by:
      pipeTo in interface StreamChannel
      Parameters:
      dst - the destination write stream
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.net.QuicStream#pipeTo(WriteStream)

    • pipeToAndAwait

      public void pipeToAndAwait(WriteStream<io.vertx.core.buffer.Buffer> arg0)
      Pipe this ReadStream to the WriteStream.

      Elements emitted by this stream will be written to the write stream until this stream ends or fails.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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
      See Also:
      • io.vertx.core.net.QuicStream#pipeTo(WriteStream)

    • pipeToAndForget

      public QuicStream pipeToAndForget(WriteStream<io.vertx.core.buffer.Buffer> arg0)
      Pipe this ReadStream to the WriteStream.

      Elements emitted by this stream will be written to the write stream until this stream ends or fails.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      dst - the destination write stream
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.net.QuicStream#pipeTo(WriteStream)

    • sendFile

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> sendFile(String arg0, long arg1)
      Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system. This is a very efficient way to stream files.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      sendFile in interface StreamChannel
      Parameters:
      filename - file name of the file to send
      offset - offset
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • StreamChannel.sendFile(String, long)

    • sendFileAndAwait

      public void sendFileAndAwait(String arg0, long arg1)
      Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system. This is a very efficient way to stream files.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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:
      filename - file name of the file to send
      offset - offset
      See Also:
      • StreamChannel.sendFile(String, long)

    • sendFileAndForget

      public QuicStream sendFileAndForget(String arg0, long arg1)
      Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system. This is a very efficient way to stream files.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      filename - file name of the file to send
      offset - offset
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • StreamChannel.sendFile(String, long)

    • end

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> end()
      Calls close()

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      end in interface StreamChannel
      Specified by:
      end in interface WriteStream<io.vertx.core.buffer.Buffer>
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • StreamChannel.end()

    • endAndAwait

      public void endAndAwait()
      Calls close()

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      See Also:
      • StreamChannel.end()

    • endAndForget

      public QuicStream endAndForget()
      Calls close()

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • StreamChannel.end()

    • end

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> end(io.vertx.core.buffer.Buffer arg0)
      Same as end() but writes some data to the stream before ending.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      end in interface StreamChannel
      Specified by:
      end in interface WriteStream<io.vertx.core.buffer.Buffer>
      Parameters:
      data - the data to write
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • WriteStream.end(T)

    • endAndAwait

      public void endAndAwait(io.vertx.core.buffer.Buffer arg0)
      Same as end() but writes some data to the stream before ending.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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 - the data to write
      See Also:
      • WriteStream.end(T)

    • endAndForget

      public QuicStream endAndForget(io.vertx.core.buffer.Buffer arg0)
      Same as end() but writes some data to the stream before ending.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      data - the data to write
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • WriteStream.end(T)

    • write

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> write(io.vertx.core.buffer.Buffer arg0)
      Write some data to the stream.

      The data is usually put on an internal write queue, and the write actually happens asynchronously. To avoid running out of memory by putting too much on the write queue, check the writeQueueFull() method before writing. This is done automatically if using a Pipe.

      When the data is moved from the queue to the actual medium, the returned Future will be completed with the write result, e.g the uni is succeeded when a server HTTP response buffer is written to the socket and failed if the remote client has closed the socket while the data was still pending for write.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      write in interface StreamChannel
      Specified by:
      write in interface WriteStream<io.vertx.core.buffer.Buffer>
      Parameters:
      data - the data to write
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • StreamChannel.write(T)

    • writeAndAwait

      public void writeAndAwait(io.vertx.core.buffer.Buffer arg0)
      Write some data to the stream.

      The data is usually put on an internal write queue, and the write actually happens asynchronously. To avoid running out of memory by putting too much on the write queue, check the writeQueueFull() method before writing. This is done automatically if using a Pipe.

      When the data is moved from the queue to the actual medium, the returned Future will be completed with the write result, e.g the underlying uni is succeeded when a server HTTP response buffer is written to the socket and failed if the remote client has closed the socket while the data was still pending for write.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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 - the data to write
      See Also:
      • StreamChannel.write(T)

    • writeAndForget

      public QuicStream writeAndForget(io.vertx.core.buffer.Buffer arg0)
      Write some data to the stream.

      The data is usually put on an internal write queue, and the write actually happens asynchronously. To avoid running out of memory by putting too much on the write queue, check the writeQueueFull() method before writing. This is done automatically if using a Pipe.

      When the data is moved from the queue to the actual medium, the returned Future will be completed with the write result, e.g the underlying uni is succeeded when a server HTTP response buffer is written to the socket and failed if the remote client has closed the socket while the data was still pending for write.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      data - the data to write
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • StreamChannel.write(T)

    • write

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> write(String arg0)
      Write a String to the connection, encoded in UTF-8.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      write in interface StreamChannel
      Parameters:
      str - the string to write
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • StreamChannel.write(String)

    • writeAndAwait

      public void writeAndAwait(String arg0)
      Write a String to the connection, encoded in UTF-8.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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:
      str - the string to write
      See Also:
      • StreamChannel.write(String)

    • writeAndForget

      public QuicStream writeAndForget(String arg0)
      Write a String to the connection, encoded in UTF-8.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      str - the string to write
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • StreamChannel.write(String)

    • close

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> close()
      Close the channel

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      close in interface StreamChannel
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • StreamChannel.close()

    • closeAndAwait

      public void closeAndAwait()
      Close the channel

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      See Also:
      • StreamChannel.close()

    • closeAndForget

      public QuicStream closeAndForget()
      Close the channel

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • StreamChannel.close()

    • sendFile

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> sendFile(String arg0, long arg1, long arg2)
      Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system. This is a very efficient way to stream files.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      sendFile in interface StreamChannel
      Parameters:
      filename - file name of the file to send
      offset - offset
      length - length
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • StreamChannel.sendFile(String, long, long)

    • sendFileAndAwait

      public void sendFileAndAwait(String arg0, long arg1, long arg2)
      Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system. This is a very efficient way to stream files.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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:
      filename - file name of the file to send
      offset - offset
      length - length
      See Also:
      • StreamChannel.sendFile(String, long, long)

    • sendFileAndForget

      public QuicStream sendFileAndForget(String arg0, long arg1, long arg2)
      Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system. This is a very efficient way to stream files.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      filename - file name of the file to send
      offset - offset
      length - length
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • StreamChannel.sendFile(String, long, long)

    • sendFile

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> sendFile(String arg0)
      Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system. This is a very efficient way to stream files.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      sendFile in interface StreamChannel
      Parameters:
      filename - file name of the file to send
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • StreamChannel.sendFile(String)

    • sendFileAndAwait

      public void sendFileAndAwait(String arg0)
      Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system. This is a very efficient way to stream files.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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:
      filename - file name of the file to send
      See Also:
      • StreamChannel.sendFile(String)

    • sendFileAndForget

      public QuicStream sendFileAndForget(String arg0)
      Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system. This is a very efficient way to stream files.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      filename - file name of the file to send
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • StreamChannel.sendFile(String)

    • write

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> write(String arg0, String arg1)
      Write a String to the connection, encoded using the encoding enc.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      write in interface StreamChannel
      Parameters:
      str - the string to write
      enc - the encoding to use
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • StreamChannel.write(String, String)

    • writeAndAwait

      public void writeAndAwait(String arg0, String arg1)
      Write a String to the connection, encoded using the encoding enc.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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:
      str - the string to write
      enc - the encoding to use
      See Also:
      • StreamChannel.write(String, String)

    • writeAndForget

      public QuicStream writeAndForget(String arg0, String arg1)
      Write a String to the connection, encoded using the encoding enc.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      str - the string to write
      enc - the encoding to use
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • StreamChannel.write(String, String)

    • id

      public long id()

    • isBidirectional

      public boolean isBidirectional()
      Returns:
      whether the stream is unidirectional or bidirectional

    • isLocalCreated

      public boolean isLocalCreated()
      Returns:
      whether the stream was created by this connection

    • connection

      public QuicConnection connection()
      Returns:
      the Quic connection this streams belongs to

    • resetHandler

      public QuicStream resetHandler(Consumer<Long> handler)

      Set a handler called upon stream reset: when a stream receives a reset frame from its peer, this handler is called.

      When no such handler is set, the stream exception handler is called and then the stream is automatically closed. Setting this handler changes this behavior: the handler processes the reset event and the handler has the full responsibility of managing the stream. That means the sending part of this stream is left untouched and the application can continue sending data.

      Parameters:
      handler - the handler. Can be null.
      Returns:
      this instance of a stream

    • closeHandler

      public QuicStream closeHandler(Runnable handler)
      Set a handler called when the stream is closed.
      Specified by:
      closeHandler in interface StreamChannel
      Parameters:
      handler - the handler signaled with the stream close. Can be null.
      Returns:
      this instance of a stream

    • shutdownHandler

      public QuicStream shutdownHandler(Consumer<Duration> handler)
      Set a handler called when the stream is shutdown or closed
      Specified by:
      shutdownHandler in interface StreamChannel
      Parameters:
      handler - the handler signaled with the stream shutdown. Can be null.
      Returns:
      this instance of a stream

    • exceptionHandler

      public QuicStream exceptionHandler(Consumer<Throwable> handler)
      Set an exception handling, catching stream exceptions.
      Specified by:
      exceptionHandler in interface ReadStream<io.vertx.core.buffer.Buffer>
      Specified by:
      exceptionHandler in interface StreamBase
      Specified by:
      exceptionHandler in interface StreamChannel
      Specified by:
      exceptionHandler in interface WriteStream<io.vertx.core.buffer.Buffer>
      Parameters:
      handler - the exception handler. Can be null.
      Returns:
      this instance of a stream

    • handler

      public QuicStream handler(Consumer<io.vertx.core.buffer.Buffer> handler)
      Set the handler signaled with the data events the remote peer has sent.
      Specified by:
      handler in interface ReadStream<io.vertx.core.buffer.Buffer>
      Specified by:
      handler in interface StreamChannel
      Parameters:
      handler - the data event handler. Can be null.
      Returns:
      this instance of a stream

    • pause

      public QuicStream pause()
      Description copied from interface: ReadStream
      Pause the ReadStream, it sets the buffer in fetch mode and clears the actual demand.

      While it's paused, no data will be sent to the data handler.

      Specified by:
      pause in interface ReadStream<io.vertx.core.buffer.Buffer>
      Specified by:
      pause in interface StreamChannel
      Returns:
      a reference to this, so the API can be used fluently

    • resume

      public QuicStream resume()
      Description copied from interface: ReadStream
      Resume reading, and sets the buffer in flowing mode.

      If the ReadStream has been paused, reading will recommence on it.

      Specified by:
      resume in interface ReadStream<io.vertx.core.buffer.Buffer>
      Specified by:
      resume in interface StreamChannel
      Returns:
      a reference to this, so the API can be used fluently

    • fetch

      public QuicStream fetch(long amount)
      Description copied from interface: ReadStream
      Fetch the specified amount of elements. If the ReadStream has been paused, reading will recommence with the specified amount of items, otherwise the specified amount will be added to the current stream demand.
      Specified by:
      fetch in interface ReadStream<io.vertx.core.buffer.Buffer>
      Specified by:
      fetch in interface StreamChannel
      Returns:
      a reference to this, so the API can be used fluently

    • endHandler

      public QuicStream endHandler(Runnable endHandler)
      Description copied from interface: StreamChannel
      Set an end handler. Once the stream has ended, and there is no more data to be read, this handler will be called.

      This handler might be called after the close handler when the channel is paused and there are still buffers to deliver.

      Specified by:
      endHandler in interface ReadStream<io.vertx.core.buffer.Buffer>
      Specified by:
      endHandler in interface StreamChannel
      Returns:
      a reference to this, so the API can be used fluently

    • setWriteQueueMaxSize

      public QuicStream setWriteQueueMaxSize(int maxSize)
      Description copied from interface: WriteStream
      Set the maximum size of the write queue to maxSize. You will still be able to write to the stream even if there is more than maxSize items in the write queue. This is used as an indicator by classes such as Pipe to provide flow control.

      The value is defined by the implementation of the stream, e.g in bytes for a NetSocket, etc...

      Specified by:
      setWriteQueueMaxSize in interface StreamChannel
      Specified by:
      setWriteQueueMaxSize in interface WriteStream<io.vertx.core.buffer.Buffer>
      Parameters:
      maxSize - the max size of the write stream
      Returns:
      a reference to this, so the API can be used fluently

    • drainHandler

      public QuicStream drainHandler(Runnable handler)
      Description copied from interface: WriteStream
      Set a drain handler on the stream. If the write queue is full, then the handler will be called when the write queue is ready to accept buffers again. See Pipe for an example of this being used.

      The stream implementation defines when the drain handler, for example it could be when the queue size has been reduced to maxSize / 2.

      Specified by:
      drainHandler in interface StreamChannel
      Specified by:
      drainHandler in interface WriteStream<io.vertx.core.buffer.Buffer>
      Parameters:
      handler - the handler. Can be null.
      Returns:
      a reference to this, so the API can be used fluently

    • pipe

      public Pipe<io.vertx.core.buffer.Buffer> pipe()
      Pause this stream and return a Pipe to transfer the elements of this stream to a destination WriteStream.

      The stream will be resumed when the pipe will be wired to a WriteStream.

      Specified by:
      pipe in interface ReadStream<io.vertx.core.buffer.Buffer>
      Specified by:
      pipe in interface StreamChannel
      Returns:
      a pipe

    • writeQueueFull

      public boolean writeQueueFull()
      This will return true if there are more bytes in the write queue than the value set using setWriteQueueMaxSize(int)
      Specified by:
      writeQueueFull in interface StreamChannel
      Specified by:
      writeQueueFull in interface WriteStream<io.vertx.core.buffer.Buffer>
      Returns:
      true if write queue is full

    • newInstance

      public static QuicStream newInstance(io.vertx.core.net.QuicStream delegate)
      Creates a new instance of the QuicStream.

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Object

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • toMulti

      @CheckReturnValue public io.smallrye.mutiny.Multi<io.vertx.core.buffer.Buffer> toMulti()
      Specified by:
      toMulti in interface StreamChannel

    • toBlockingIterable

      public Iterable<io.vertx.core.buffer.Buffer> toBlockingIterable()

    • toBlockingStream

      public Stream<io.vertx.core.buffer.Buffer> toBlockingStream()

    • toSubscriber

      @CheckReturnValue public Flow.Subscriber<io.vertx.core.buffer.Buffer> toSubscriber()
      Converts the current write stream to a subscriber.