All Superinterfaces:

io.netty5.util.concurrent.FuturePromiseFactory

All Known Subinterfaces:

Channel, ChannelHandlerContext, ChannelPipeline, DatagramChannel, ServerChannel, ServerSocketChannel, SocketChannel

All Known Implementing Classes:

AbstractChannel, AbstractChannel.DefaultAbstractChannelPipeline, AbstractNioByteChannel, AbstractNioChannel, AbstractNioMessageChannel, AbstractServerChannel, DefaultChannelPipeline, DelegatingChannelHandlerContext, EmbeddedChannel, LocalChannel, LocalServerChannel, NioDatagramChannel, NioServerSocketChannel, NioSocketChannel
```
public interface ChannelOutboundInvoker
extends io.netty5.util.concurrent.FuturePromiseFactory
```

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method	Description
`io.netty5.util.concurrent.Future<Void>`	`bind(SocketAddress localAddress)`	Request to bind to the given `SocketAddress` and notify the `Future` once the operation completes, either because the operation was successful or because of an error.
`io.netty5.util.concurrent.Future<Void>`	`close()`	Request to close the `Channel` and notify the `Future` once the operation completes, either because the operation was successful or because of an error.
`io.netty5.util.concurrent.Future<Void>`	`connect(SocketAddress remoteAddress)`	Request to connect to the given `SocketAddress` and notify the `Future` once the operation completes, either because the operation was successful or because of an error.
`io.netty5.util.concurrent.Future<Void>`	`connect(SocketAddress remoteAddress, SocketAddress localAddress)`	Request to connect to the given `SocketAddress` while bind to the localAddress and notify the `Future` once the operation completes, either because the operation was successful or because of an error.
`io.netty5.util.concurrent.Future<Void>`	`deregister()`	Request to deregister from the previous assigned `EventExecutor` and notify the `Future` once the operation completes, either because the operation was successful or because of an error.
`io.netty5.util.concurrent.Future<Void>`	`disconnect()`	Request to disconnect from the remote peer and notify the `Future` once the operation completes, either because the operation was successful or because of an error.
`io.netty5.util.concurrent.EventExecutor`	`executor()`	Returns the `EventExecutor` that is used to execute the operations of this `ChannelOutboundInvoker`.
`ChannelOutboundInvoker`	`flush()`	Request to flush all pending messages via this ChannelOutboundInvoker.
`default <V> io.netty5.util.concurrent.Future<V>`	`newFailedFuture(Throwable cause)`
`default <V> io.netty5.util.concurrent.Promise<V>`	`newPromise()`
`default io.netty5.util.concurrent.Future<Void>`	`newSucceededFuture()`
`default <V> io.netty5.util.concurrent.Future<V>`	`newSucceededFuture(V value)`
`ChannelOutboundInvoker`	`read()`
`ChannelOutboundInvoker`	`read(ReadBufferAllocator readBufferAllocator)`	Request to read data from the `Channel`, triggers an `ChannelHandler.channelRead(ChannelHandlerContext, Object)` event if data was read, and triggers a `channelReadComplete` event so the handler can decide to continue reading.
`io.netty5.util.concurrent.Future<Void>`	`register()`	Request to register on the `EventExecutor` for I/O processing.
`io.netty5.util.concurrent.Future<Void>`	`sendOutboundEvent(Object event)`	Send a custom outbound event via this `ChannelOutboundInvoker` through the `ChannelPipeline`.
`io.netty5.util.concurrent.Future<Void>`	`shutdown(ChannelShutdownDirection direction)`	Request shutdown one direction of the `Channel` and notify the `Future` once the operation completes, either because the operation was successful or because of an error.
`io.netty5.util.concurrent.Future<Void>`	`write(Object msg)`	Request to write a message via this `ChannelHandlerContext` through the `ChannelPipeline`.
`io.netty5.util.concurrent.Future<Void>`	`writeAndFlush(Object msg)`	Shortcut for call `write(Object)` and `flush()`.

- Method Detail
  - bind
```
io.netty5.util.concurrent.Future<Void> bind(SocketAddress localAddress)
```
    Request to bind to the given SocketAddress and notify the Future once the operation completes, either because the operation was successful or because of an error.
    This will result in having the ChannelHandler.bind(ChannelHandlerContext, SocketAddress) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
  - connect
```
io.netty5.util.concurrent.Future<Void> connect(SocketAddress remoteAddress)
```
    Request to connect to the given SocketAddress and notify the Future once the operation completes, either because the operation was successful or because of an error.
    If the connection fails because of a connection timeout, the Future will get failed with a ConnectTimeoutException. If it fails because of connection refused a ConnectException will be used.
    This will result in having the ChannelHandler.connect(ChannelHandlerContext, SocketAddress, SocketAddress) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
  - connect
```
io.netty5.util.concurrent.Future<Void> connect(SocketAddress remoteAddress,
                                               SocketAddress localAddress)
```
    Request to connect to the given SocketAddress while bind to the localAddress and notify the Future once the operation completes, either because the operation was successful or because of an error.
    This will result in having the ChannelHandler.connect(ChannelHandlerContext, SocketAddress, SocketAddress) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
  - disconnect
```
io.netty5.util.concurrent.Future<Void> disconnect()
```
    Request to disconnect from the remote peer and notify the Future once the operation completes, either because the operation was successful or because of an error.
    This will result in having the ChannelHandler.disconnect(ChannelHandlerContext) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
  - close
```
io.netty5.util.concurrent.Future<Void> close()
```
    Request to close the Channel and notify the Future once the operation completes, either because the operation was successful or because of an error. After it is closed it is not possible to reuse it again.
    This will result in having the ChannelHandler.close(ChannelHandlerContext) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
  - shutdown
```
io.netty5.util.concurrent.Future<Void> shutdown(ChannelShutdownDirection direction)
```
    Request shutdown one direction of the Channel and notify the Future once the operation completes, either because the operation was successful or because of an error.
    When completed, the channel will either not produce any inbound data anymore, or it will not be possible to write data anymore, depending on the given ChannelShutdownDirection.
    Depending on the transport implementation shutting down the ChannelShutdownDirection.Outbound or ChannelShutdownDirection.Inbound might also result in data transferred over the network. Like for example in case of TCP shutting down the ChannelShutdownDirection.Outbound will result in a FIN that is transmitted to the remote peer that will as a result shutdown ChannelShutdownDirection.Inbound.
    This will result in having the ChannelHandler.shutdown(ChannelHandlerContext, ChannelShutdownDirection). method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
  - register
```
io.netty5.util.concurrent.Future<Void> register()
```
    Request to register on the EventExecutor for I/O processing. Future once the operation completes, either because the operation was successful or because of an error.
    This will result in having the ChannelHandler.register(ChannelHandlerContext) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
  - deregister
```
io.netty5.util.concurrent.Future<Void> deregister()
```
    Request to deregister from the previous assigned EventExecutor and notify the Future once the operation completes, either because the operation was successful or because of an error.
    This will result in having the ChannelHandler.deregister(ChannelHandlerContext) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
  - read
```
ChannelOutboundInvoker read(ReadBufferAllocator readBufferAllocator)
```
    Request to read data from the Channel, triggers an ChannelHandler.channelRead(ChannelHandlerContext, Object) event if data was read, and triggers a channelReadComplete event so the handler can decide to continue reading. If there's a pending read operation already, this method does nothing.
    This will result in having the ChannelHandler.read(ChannelHandlerContext, ReadBufferAllocator) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
    
    Parameters:
    
    readBufferAllocator - The ReadBufferAllocator that should be used to allocate a Buffer if needed (for reading the data).
  - read
```
ChannelOutboundInvoker read()
```
    See Also:
    
    (using a default ).
  - write
```
io.netty5.util.concurrent.Future<Void> write(Object msg)
```
    Request to write a message via this ChannelHandlerContext through the ChannelPipeline. This method will not request to actual flush, so be sure to call flush() once you want to request to flush all pending data to the actual transport.
  - flush
```
ChannelOutboundInvoker flush()
```
    Request to flush all pending messages via this ChannelOutboundInvoker.
  - writeAndFlush
```
io.netty5.util.concurrent.Future<Void> writeAndFlush(Object msg)
```
    Shortcut for call write(Object) and flush().
  - sendOutboundEvent
```
io.netty5.util.concurrent.Future<Void> sendOutboundEvent(Object event)
```
    Send a custom outbound event via this ChannelOutboundInvoker through the ChannelPipeline.
    This will result in having the ChannelHandler.sendOutboundEvent(ChannelHandlerContext, Object) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
  - newPromise
```
default <V> io.netty5.util.concurrent.Promise<V> newPromise()
```
    Specified by:
    
    newPromise in interface io.netty5.util.concurrent.FuturePromiseFactory
  - newSucceededFuture
```
default <V> io.netty5.util.concurrent.Future<V> newSucceededFuture(V value)
```
    Specified by:
    
    newSucceededFuture in interface io.netty5.util.concurrent.FuturePromiseFactory
  - newFailedFuture
```
default <V> io.netty5.util.concurrent.Future<V> newFailedFuture(Throwable cause)
```
    Specified by:
    
    newFailedFuture in interface io.netty5.util.concurrent.FuturePromiseFactory
  - newSucceededFuture
```
default io.netty5.util.concurrent.Future<Void> newSucceededFuture()
```
    Specified by:
    
    newSucceededFuture in interface io.netty5.util.concurrent.FuturePromiseFactory
  - executor
```
io.netty5.util.concurrent.EventExecutor executor()
```
    Returns the EventExecutor that is used to execute the operations of this ChannelOutboundInvoker.
    
    Returns:
    
    the executor.

Interface ChannelOutboundInvoker

Method Summary

Method Detail

bind

connect

connect

disconnect

close

shutdown

register

deregister

read

read

write

flush

writeAndFlush

sendOutboundEvent

newPromise

newSucceededFuture

newFailedFuture

newSucceededFuture

executor