NettyOutbound (Reactor Netty 0.7.14.RELEASE)

All Superinterfaces:

Publisher<java.lang.Void>

All Known Subinterfaces:

HttpClientRequest, HttpServerResponse, UdpOutbound, WebsocketOutbound

All Known Implementing Classes:

ChannelOperations, HttpOperations
```
public interface NettyOutbound
extends Publisher<java.lang.Void>
```
Author:

Stephane Maldini

Field Summary

Fields
Modifier and Type Field and Description

static FileChunkedStrategy<io.netty.buffer.ByteBuf> FILE_CHUNKED_STRATEGY_BUFFER

Fields
Modifier and Type	Field and Description
`static FileChunkedStrategy<io.netty.buffer.ByteBuf>`	`FILE_CHUNKED_STRATEGY_BUFFER`

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default io.netty.buffer.ByteBufAllocator`	`alloc()` Return the assigned `ByteBufAllocator`.
`NettyContext`	`context()` Return a `NettyContext` to operate on the underlying `Channel` state.
`default NettyOutbound`	`context(java.util.function.Consumer<NettyContext> contextCallback)` Immediately call the passed callback with a `NettyContext` to operate on the underlying `Channel` state.
`default FileChunkedStrategy<?>`	`getFileChunkedStrategy()`
`default reactor.core.publisher.Mono<java.lang.Void>`	`neverComplete()` Return a never completing `Mono` after this `then()` has completed.
`default NettyOutbound`	`onWriteIdle(long idleTimeout, java.lang.Runnable onWriteIdle)` Assign a `Runnable` to be invoked when writes have become idle for the given timeout.
`default NettyOutbound`	`options(java.util.function.Consumer<? super NettyPipeline.SendOptions> configurator)` Provide a new `NettyOutbound` scoped configuration for sending.
`default NettyOutbound`	`send(Publisher<? extends io.netty.buffer.ByteBuf> dataStream)` Send data to the peer, listen for any error on write and close on terminal signal (complete\|error).
`default NettyOutbound`	`sendByteArray(Publisher<? extends byte[]> dataStream)` Send bytes to the peer, listen for any error on write and close on terminal signal (complete\|error).
`default NettyOutbound`	`sendFile(java.nio.file.Path file)` Send content from given `Path` using `FileChannel.transferTo(long, long, WritableByteChannel)` support.
`default NettyOutbound`	`sendFile(java.nio.file.Path file, long position, long count)` Send content from given `Path` using `FileChannel.transferTo(long, long, WritableByteChannel)` support.
`default NettyOutbound`	`sendFileChunked(java.nio.file.Path file, long position, long count)` Note: Nesting any send* method is not supported.
`default NettyOutbound`	`sendGroups(Publisher<? extends Publisher<? extends io.netty.buffer.ByteBuf>> dataStreams)` Send data to the peer, listen for any error on write and close on terminal signal (complete\|error).Each individual `Publisher` completion will flush the underlying IO runtime.
`default NettyOutbound`	`sendObject(java.lang.Object msg)` Send data to the peer, listen for any error on write and close on terminal signal (complete\|error).
`default NettyOutbound`	`sendObject(Publisher<?> dataStream)` Send Object to the peer, listen for any error on write and close on terminal signal (complete\|error).
`default NettyOutbound`	`sendString(Publisher<? extends java.lang.String> dataStream)` Send String to the peer, listen for any error on write and close on terminal signal (complete\|error).
`default NettyOutbound`	`sendString(Publisher<? extends java.lang.String> dataStream, java.nio.charset.Charset charset)` Send String to the peer, listen for any error on write and close on terminal signal (complete\|error).
`default void`	`subscribe(Subscriber<? super java.lang.Void> s)` Subscribe a `Void` subscriber to this outbound and trigger all eventual parent outbound send.
`default reactor.core.publisher.Mono<java.lang.Void>`	`then()` Obtain a `Mono` of pending outbound(s) write completion.
`default NettyOutbound`	`then(Publisher<java.lang.Void> other)` Append a `Publisher` task such as a Mono and return a new `NettyOutbound` to sequence further send.

- Field Detail
  - FILE_CHUNKED_STRATEGY_BUFFER
```
static final FileChunkedStrategy<io.netty.buffer.ByteBuf> FILE_CHUNKED_STRATEGY_BUFFER
```
- Method Detail
  - alloc
```
default io.netty.buffer.ByteBufAllocator alloc()
```
    Return the assigned ByteBufAllocator.
    
    Returns:
    
    the ByteBufAllocator
  - context
```
NettyContext context()
```
    Return a NettyContext to operate on the underlying Channel state.
    
    Returns:
    
    the NettyContext
  - context
```
default NettyOutbound context(java.util.function.Consumer<NettyContext> contextCallback)
```
    Immediately call the passed callback with a NettyContext to operate on the underlying Channel state. This allows for chaining outbound API.
    
    Parameters:
    
    contextCallback - context callback
    
    Returns:
    
    the NettyContext
  - getFileChunkedStrategy
```
default FileChunkedStrategy<?> getFileChunkedStrategy()
```
  - neverComplete
```
default reactor.core.publisher.Mono<java.lang.Void> neverComplete()
```
    Return a never completing Mono after this then() has completed.
    
    Returns:
    
    a never completing Mono after this then() has completed.
  - onWriteIdle
```
default NettyOutbound onWriteIdle(long idleTimeout,
                                  java.lang.Runnable onWriteIdle)
```
    Assign a Runnable to be invoked when writes have become idle for the given timeout. This replaces any previously set idle callback.
    
    Parameters:
    
    idleTimeout - the idle timeout
    
    onWriteIdle - the idle timeout handler
    
    Returns:
    
    this
  - options
```
default NettyOutbound options(java.util.function.Consumer<? super NettyPipeline.SendOptions> configurator)
```
    Provide a new NettyOutbound scoped configuration for sending. The NettyPipeline.SendOptions changes will apply to the next written object or Publisher.
    
    Parameters:
    
    configurator - the callback invoked to retrieve send configuration
    
    Returns:
    
    this instance
  - send
```
default NettyOutbound send(Publisher<? extends io.netty.buffer.ByteBuf> dataStream)
```
    Send data to the peer, listen for any error on write and close on terminal signal (complete|error).
    A new NettyOutbound type (or the same) for typed send sequences. An implementor can therefore specialize the Outbound after a first after a prepending data publisher. Note: Nesting any send* method is not supported.
    
    Parameters:
    
    dataStream - the dataStream publishing OUT items to write on this channel
    
    Returns:
    
    A new NettyOutbound to append further send. It will emit a complete signal successful sequence write (e.g. after "flush") or any error during write.
  - sendByteArray
```
default NettyOutbound sendByteArray(Publisher<? extends byte[]> dataStream)
```
    Send bytes to the peer, listen for any error on write and close on terminal signal (complete|error). If more than one publisher is attached (multiple calls to send()) completion occurs after all publishers complete. Note: Nesting any send* method is not supported.
    
    Parameters:
    
    dataStream - the dataStream publishing Buffer items to write on this channel
    
    Returns:
    
    A Publisher to signal successful sequence write (e.g. after "flush") or any error during write
  - sendFile
```
default NettyOutbound sendFile(java.nio.file.Path file)
```
    Send content from given Path using FileChannel.transferTo(long, long, WritableByteChannel) support. If the system supports it and the path resolves to a local file system File then transfer will use zero-byte copy to the peer.
    It will listen for any error on write and close on terminal signal (complete|error). If more than one publisher is attached (multiple calls to send()) completion occurs after all publishers complete.
    Note: this will emit FileRegion in the outbound ChannelPipeline Note: Nesting any send* method is not supported.
    
    Parameters:
    
    file - the file Path
    
    Returns:
    
    A Publisher to signal successful sequence write (e.g. after "flush") or any error during write
  - sendFile
```
default NettyOutbound sendFile(java.nio.file.Path file,
                               long position,
                               long count)
```
    Send content from given Path using FileChannel.transferTo(long, long, WritableByteChannel) support. If the system supports it and the path resolves to a local file system File then transfer will use zero-byte copy to the peer.
    It will listen for any error on write and close on terminal signal (complete|error). If more than one publisher is attached (multiple calls to send()) completion occurs after all publishers complete.
    Note: this will emit FileRegion in the outbound ChannelPipeline Note: Nesting any send* method is not supported.
    
    Parameters:
    
    file - the file Path
    
    position - where to start
    
    count - how much to transfer
    
    Returns:
    
    A Publisher to signal successful sequence write (e.g. after "flush") or any error during write
  - sendFileChunked
```
default NettyOutbound sendFileChunked(java.nio.file.Path file,
                                      long position,
                                      long count)
```
    Note: Nesting any send* method is not supported.
    
    Parameters:
    
    file - the file Path
    
    position - where to start
    
    count - how much to transfer
    
    Returns:
    
    A Publisher to signal successful sequence write (e.g. after "flush") or any error during write
  - sendGroups
```
default NettyOutbound sendGroups(Publisher<? extends Publisher<? extends io.netty.buffer.ByteBuf>> dataStreams)
```
    Send data to the peer, listen for any error on write and close on terminal signal (complete|error).Each individual Publisher completion will flush the underlying IO runtime. Note: Nesting any send* method is not supported.
    
    Parameters:
    
    dataStreams - the dataStream publishing OUT items to write on this channel
    
    Returns:
    
    A Mono to signal successful sequence write (e.g. after "flush") or any error during write
  - sendObject
```
default NettyOutbound sendObject(Publisher<?> dataStream)
```
    Send Object to the peer, listen for any error on write and close on terminal signal (complete|error). If more than one publisher is attached (multiple calls to send()) completion occurs after all publishers complete. Note: Nesting any send* method is not supported.
    
    Parameters:
    
    dataStream - the dataStream publishing Buffer items to write on this channel
    
    Returns:
    
    A Publisher to signal successful sequence write (e.g. after "flush") or any error during write
  - sendObject
```
default NettyOutbound sendObject(java.lang.Object msg)
```
    Send data to the peer, listen for any error on write and close on terminal signal (complete|error). Note: Nesting any send* method is not supported.
    
    Parameters:
    
    msg - the object to publish
    
    Returns:
    
    A Mono to signal successful sequence write (e.g. after "flush") or any error during write
  - sendString
```
default NettyOutbound sendString(Publisher<? extends java.lang.String> dataStream)
```
    Send String to the peer, listen for any error on write and close on terminal signal (complete|error). If more than one publisher is attached (multiple calls to send()) completion occurs after all publishers complete. Note: Nesting any send* method is not supported.
    
    Parameters:
    
    dataStream - the dataStream publishing Buffer items to write on this channel
    
    Returns:
    
    A Publisher to signal successful sequence write (e.g. after "flush") or any error during write
  - sendString
```
default NettyOutbound sendString(Publisher<? extends java.lang.String> dataStream,
                                 java.nio.charset.Charset charset)
```
    Send String to the peer, listen for any error on write and close on terminal signal (complete|error). If more than one publisher is attached (multiple calls to send()) completion occurs after all publishers complete. Note: Nesting any send* method is not supported.
    
    Parameters:
    
    dataStream - the dataStream publishing Buffer items to write on this channel
    
    charset - the encoding charset
    
    Returns:
    
    A Publisher to signal successful sequence write (e.g. after "flush") or any error during write
  - subscribe
```
default void subscribe(Subscriber<? super java.lang.Void> s)
```
    Subscribe a Void subscriber to this outbound and trigger all eventual parent outbound send.
    
    Specified by:
    
    subscribe in interface Publisher<java.lang.Void>
    
    Parameters:
    
    s - the Subscriber to listen for send sequence completion/failure
  - then
```
default reactor.core.publisher.Mono<java.lang.Void> then()
```
    Obtain a Mono of pending outbound(s) write completion.
    
    Returns:
    
    a Mono of pending outbound(s) write completion
  - then
```
default NettyOutbound then(Publisher<java.lang.Void> other)
```
    Append a Publisher task such as a Mono and return a new NettyOutbound to sequence further send.
    
    Parameters:
    
    other - the Publisher to subscribe to when this pending outbound then() is complete;
    
    Returns:
    
    a new NettyOutbound that

Interface NettyOutbound

Field Summary

Method Summary

Field Detail

FILE_CHUNKED_STRATEGY_BUFFER

Method Detail

alloc

context

context

getFileChunkedStrategy

neverComplete

onWriteIdle

options

send

sendByteArray

sendFile

sendFile

sendFileChunked

sendGroups

sendObject

sendObject

sendString

sendString

subscribe

then

then