NettyOutbound (Reactor Netty 0.8.1.RELEASE)

All Superinterfaces:

Publisher<java.lang.Void>

All Known Subinterfaces:

HttpServerResponse, UdpOutbound, WebsocketOutbound

All Known Implementing Classes:

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

Stephane Maldini

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`io.netty.buffer.ByteBufAllocator`	`alloc()` Return the assigned `ByteBufAllocator`.
`default Mono<java.lang.Void>`	`neverComplete()` Return a never completing `Mono` after this `then()` has completed.
`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)` Send content from given `Path` using chunked read/write.
`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.
`NettyOutbound`	`sendObject(java.lang.Object message)` Send data to the peer, listen for any error on write and close on terminal signal (complete\|error).
`NettyOutbound`	`sendObject(Publisher<?> dataStream)` Send an object through netty pipeline.
`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).
`<S> NettyOutbound`	`sendUsing(java.util.concurrent.Callable<? extends S> sourceInput, java.util.function.BiFunction<? super Connection,? super S,?> mappedInput, java.util.function.Consumer<? super S> sourceCleanup)` Bind a send to a starting/cleanup lifecycle
`default void`	`subscribe(Subscriber<? super java.lang.Void> s)` Subscribe a `Void` subscriber to this outbound and trigger all eventual parent outbound send.
`default 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.
`NettyOutbound`	`withConnection(java.util.function.Consumer<? super Connection> withConnection)` Call the passed callback with a `Connection` to operate on the underlying `Channel` state.

- Method Detail
  - alloc
```
io.netty.buffer.ByteBufAllocator alloc()
```
    Return the assigned ByteBufAllocator.
    
    Returns:
    
    the ByteBufAllocator
  - neverComplete
```
default 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.
  - 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.
    
    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.
    
    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
    
    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
    
    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)
```
    Send content from given Path using chunked read/write.
    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
    
    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.
    
    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
```
NettyOutbound sendObject(Publisher<?> dataStream)
```
    Send an object through netty pipeline. If type of Publisher, send all signals, flushing on complete by default. Write occur in FIFO sequence.
    
    Parameters:
    
    dataStream - the dataStream publishing items to write on this channel or a simple pojo supported by configured netty handlers
    
    Returns:
    
    A Publisher to signal successful sequence write (e.g. after "flush") or any error during write
  - sendObject
```
NettyOutbound sendObject(java.lang.Object message)
```
    Send data to the peer, listen for any error on write and close on terminal signal (complete|error).
    
    Parameters:
    
    message - 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.
    
    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.
    
    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
  - sendUsing
```
<S> NettyOutbound sendUsing(java.util.concurrent.Callable<? extends S> sourceInput,
                            java.util.function.BiFunction<? super Connection,? super S,?> mappedInput,
                            java.util.function.Consumer<? super S> sourceCleanup)
```
    Bind a send to a starting/cleanup lifecycle
    
    Type Parameters:
    
    S - state type
    
    Parameters:
    
    sourceInput - state generator
    
    mappedInput - input to send
    
    sourceCleanup - state cleaner
    
    Returns:
    
    a new NettyOutbound
  - 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 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
  - withConnection
```
NettyOutbound withConnection(java.util.function.Consumer<? super Connection> withConnection)
```
    Call the passed callback with a Connection to operate on the underlying Channel state.
    
    Parameters:
    
    withConnection - connection callback
    
    Returns:
    
    the Connection

Interface NettyOutbound

Method Summary

Method Detail

alloc

neverComplete

options

send

sendByteArray

sendFile

sendFile

sendFileChunked

sendGroups

sendObject

sendObject

sendString

sendString

sendUsing

subscribe

then

then

withConnection