Uses of Interface
io.netty5.util.concurrent.Future

Packages that use Future

Package	Description
io.netty5.bootstrap	The helper classes with fluent API which enable an easy implementation of typical client side and server side channel initialization.
io.netty5.channel	The core channel API which is asynchronous and event-driven abstraction of various transports such as a NIO Channel.
io.netty5.channel.embedded	A virtual Channel that helps wrapping a series of handlers to unit test the handlers or use them in non-I/O context.
io.netty5.channel.epoll	Optimized transport for linux which uses EPOLL Edge-Triggered Mode for maximal performance.
io.netty5.channel.group	A channel registry which helps a user maintain the list of open Channels and perform bulk operations on them.
io.netty5.channel.internal	Internal utilities for channel implementations.
io.netty5.channel.kqueue	BSD specific transport.
io.netty5.channel.socket	Abstract TCP and UDP socket interfaces which extend the core channel API.
io.netty5.channel.socket.nio	NIO-based socket channel API implementation - recommended for a large number of connections (>= 1000).
io.netty5.handler.address	Package to dynamically replace local / remote SocketAddress.
io.netty5.handler.codec	Extensible decoder and its common implementations which deal with the packet fragmentation and reassembly issue found in a stream-based transport such as TCP/IP.
io.netty5.handler.codec.compression	Encoder and decoder which compresses and decompresses io.netty5.buffer.ByteBufs in a compression format such as zlib, gzip, and Snappy.
io.netty5.handler.codec.http	Encoder, decoder and their related message types for HTTP.
io.netty5.handler.codec.http.cors	This package contains Cross Origin Resource Sharing (CORS) related classes.
io.netty5.handler.codec.http.websocketx	Encoder, decoder, handshakers and their related message types for Web Socket data frames.
io.netty5.handler.codec.http.websocketx.extensions	Encoder, decoder, handshakers to handle WebSocket Extensions.
io.netty5.handler.codec.http2	Handlers for sending and receiving HTTP/2 frames.
io.netty5.handler.flush	Package to control flush behavior.
io.netty5.handler.ipfilter	Package to filter IP addresses (allow/deny).
io.netty5.handler.logging	Logs the I/O events for debugging purpose.
io.netty5.handler.ssl	SSL · TLS implementation based on SSLEngine
io.netty5.handler.stream	Writes very large data stream asynchronously neither spending a lot of memory nor getting OutOfMemoryError.
io.netty5.handler.timeout	Adds support for read and write timeout and idle connection notification using a Timer.
io.netty5.handler.traffic	Implementation of a Traffic Shaping Handler and Dynamic Statistics.
io.netty5.resolver	Resolves an arbitrary string that represents the name of an endpoint into an address.
io.netty5.resolver.dns	An alternative to Java's built-in domain name lookup mechanism that resolves a domain name asynchronously, which supports the queries of an arbitrary DNS record type as well.
io.netty5.util	Utility classes used across multiple packages.
io.netty5.util.concurrent	Utility classes for concurrent / async tasks.

Uses of Future in io.netty5.bootstrap

Methods in io.netty5.bootstrap that return Future

Modifier and Type	Method	Description
Future<Channel>	AbstractBootstrap.bind()	Create a new Channel and bind it.
Future<Channel>	AbstractBootstrap.bind(int inetPort)	Create a new Channel and bind it.
Future<Channel>	AbstractBootstrap.bind(String inetHost, int inetPort)	Create a new Channel and bind it.
Future<Channel>	AbstractBootstrap.bind(InetAddress inetHost, int inetPort)	Create a new Channel and bind it.
Future<Channel>	AbstractBootstrap.bind(SocketAddress localAddress)	Create a new Channel and bind it.
Future<Channel>	Bootstrap.connect()	Connect a Channel to the remote peer.
Future<Channel>	Bootstrap.connect(String inetHost, int inetPort)	Connect a Channel to the remote peer.
Future<Channel>	Bootstrap.connect(InetAddress inetHost, int inetPort)	Connect a Channel to the remote peer.
Future<Channel>	Bootstrap.connect(SocketAddress remoteAddress)	Connect a Channel to the remote peer.
Future<Channel>	Bootstrap.connect(SocketAddress remoteAddress, SocketAddress localAddress)	Connect a Channel to the remote peer.
Future<Channel>	AbstractBootstrap.register()	Create a new Channel and register it with an EventLoop.

Uses of Future in io.netty5.channel

Methods in io.netty5.channel that return Future

Modifier and Type	Method	Description
default Future<Void>	Channel.bind(SocketAddress localAddress)
default Future<Void>	ChannelHandler.bind(ChannelHandlerContext ctx, SocketAddress localAddress)	Called once a bind operation is made.
Future<Void>	ChannelOutboundInvoker.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.
Future<Void>	CombinedChannelDuplexHandler.bind(ChannelHandlerContext ctx, SocketAddress localAddress)
Future<Void>	DefaultChannelPipeline.bind(SocketAddress localAddress)
default Future<Void>	Channel.close()
default Future<Void>	ChannelHandler.close(ChannelHandlerContext ctx)	Called once a close operation is made.
Future<Void>	ChannelOutboundInvoker.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.
Future<Void>	CombinedChannelDuplexHandler.close(ChannelHandlerContext ctx)
Future<Void>	DefaultChannelPipeline.close()
Future<Void>	AbstractChannel.closeFuture()
Future<Void>	Channel.closeFuture()	Returns the Future which will be notified when this channel is closed.
default Future<Void>	Channel.connect(SocketAddress remoteAddress)
default Future<Void>	Channel.connect(SocketAddress remoteAddress, SocketAddress localAddress)
default Future<Void>	ChannelHandler.connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress)	Called once a connect operation is made.
Future<Void>	ChannelOutboundInvoker.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.
Future<Void>	ChannelOutboundInvoker.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.
Future<Void>	CombinedChannelDuplexHandler.connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress)
Future<Void>	DefaultChannelPipeline.connect(SocketAddress remoteAddress)
Future<Void>	DefaultChannelPipeline.connect(SocketAddress remoteAddress, SocketAddress localAddress)
default Future<Void>	Channel.deregister()
default Future<Void>	ChannelHandler.deregister(ChannelHandlerContext ctx)	Called once a deregister operation is made from the current registered EventLoop.
Future<Void>	ChannelOutboundInvoker.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.
Future<Void>	CombinedChannelDuplexHandler.deregister(ChannelHandlerContext ctx)
Future<Void>	DefaultChannelPipeline.deregister()
Future<Void>	EventLoop.deregisterForIo(IoHandle handle)	Deregister the Channel from the EventLoop for I/O processing.
Future<Void>	SingleThreadEventLoop.deregisterForIo(IoHandle handle)
default Future<Void>	Channel.disconnect()
default Future<Void>	ChannelHandler.disconnect(ChannelHandlerContext ctx)	Called once a disconnect operation is made.
Future<Void>	ChannelOutboundInvoker.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.
Future<Void>	CombinedChannelDuplexHandler.disconnect(ChannelHandlerContext ctx)
Future<Void>	DefaultChannelPipeline.disconnect()
default <V> Future<V>	ChannelOutboundInvoker.newFailedFuture(Throwable cause)
<V> Future<V>	DefaultChannelPipeline.newFailedFuture(Throwable cause)
default Future<Void>	ChannelOutboundInvoker.newSucceededFuture()
default <V> Future<V>	ChannelOutboundInvoker.newSucceededFuture(V value)
Future<Void>	DefaultChannelPipeline.newSucceededFuture()
<V> Future<V>	DefaultChannelPipeline.newSucceededFuture(V value)
protected Future<Executor>	AbstractChannel.prepareToClose()	Prepares to close the Channel.
default Future<Void>	Channel.register()
default Future<Void>	ChannelHandler.register(ChannelHandlerContext ctx)	Called once a register operation is made to register for IO on the EventLoop.
Future<Void>	ChannelOutboundInvoker.register()	Request to register on the EventExecutor for I/O processing.
Future<Void>	CombinedChannelDuplexHandler.register(ChannelHandlerContext ctx)
Future<Void>	DefaultChannelPipeline.register()
Future<Void>	EventLoop.registerForIo(IoHandle handle)	Register the IoHandle to the EventLoop for I/O processing.
Future<Void>	SingleThreadEventLoop.registerForIo(IoHandle handle)
Future<Void>	PendingWriteQueue.removeAndTransfer(Function<Object,Future<Void>> transferFunc)	Removes a pending write operation and performs it via Function.apply(Object).
Future<Void>	PendingWriteQueue.removeAndTransferAll(Function<Object,Future<Void>> transferFunc)	Remove all pending write operation and performs them via Function.apply(Object).
default Future<Void>	Channel.sendOutboundEvent(Object event)
default Future<Void>	ChannelHandler.sendOutboundEvent(ChannelHandlerContext ctx, Object event)	Called once a custom defined outbound event was sent.
Future<Void>	ChannelOutboundInvoker.sendOutboundEvent(Object event)	Send a custom outbound event via this ChannelOutboundInvoker through the ChannelPipeline.
Future<Void>	CombinedChannelDuplexHandler.sendOutboundEvent(ChannelHandlerContext ctx, Object event)
Future<Void>	DefaultChannelPipeline.sendOutboundEvent(Object event)
default Future<Void>	Channel.shutdown(ChannelShutdownDirection direction)
default Future<Void>	ChannelHandler.shutdown(ChannelHandlerContext ctx, ChannelShutdownDirection direction)	Called once a shutdown operation was requested and should be executed.
Future<Void>	ChannelOutboundInvoker.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.
Future<Void>	CombinedChannelDuplexHandler.shutdown(ChannelHandlerContext ctx, ChannelShutdownDirection direction)
Future<Void>	DefaultChannelPipeline.shutdown(ChannelShutdownDirection direction)
default Future<Void>	Channel.write(Object msg)
default Future<Void>	ChannelHandler.write(ChannelHandlerContext ctx, Object msg)	Called once a write operation is made.
Future<Void>	ChannelOutboundInvoker.write(Object msg)	Request to write a message via this ChannelHandlerContext through the ChannelPipeline.
Future<Void>	CombinedChannelDuplexHandler.write(ChannelHandlerContext ctx, Object msg)
Future<Void>	DefaultChannelPipeline.write(Object msg)
default Future<Void>	Channel.writeAndFlush(Object msg)
Future<Void>	ChannelOutboundInvoker.writeAndFlush(Object msg)	Shortcut for call ChannelOutboundInvoker.write(Object) and ChannelOutboundInvoker.flush().
Future<Void>	DefaultChannelPipeline.writeAndFlush(Object msg)

Method parameters in io.netty5.channel with type arguments of type Future

Modifier and Type	Method	Description
Future<Void>	PendingWriteQueue.removeAndTransfer(Function<Object,Future<Void>> transferFunc)	Removes a pending write operation and performs it via Function.apply(Object).
Future<Void>	PendingWriteQueue.removeAndTransferAll(Function<Object,Future<Void>> transferFunc)	Remove all pending write operation and performs them via Function.apply(Object).

Uses of Future in io.netty5.channel.embedded

Methods in io.netty5.channel.embedded that return Future

Modifier and Type	Method	Description
Future<Void>	EmbeddedChannel.close()
Future<Void>	EmbeddedChannel.disconnect()
Future<Void>	EmbeddedChannel.register()
Future<Void>	EmbeddedChannel.writeOneInbound(Object msg)	Writes one message to the inbound of this Channel and does not flush it.
Future<Void>	EmbeddedChannel.writeOneOutbound(Object msg)	Writes one message to the outbound of this Channel and does not flush it.

Uses of Future in io.netty5.channel.epoll

Methods in io.netty5.channel.epoll that return Future

Modifier and Type	Method	Description
Future<Void>	EpollDatagramChannel.block(InetAddress multicastAddress, InetAddress sourceToBlock)
Future<Void>	EpollDatagramChannel.block(InetAddress multicastAddress, NetworkInterface networkInterface, InetAddress sourceToBlock)
Future<Void>	EpollDatagramChannel.joinGroup(InetAddress multicastAddress)
Future<Void>	EpollDatagramChannel.joinGroup(InetAddress multicastAddress, NetworkInterface networkInterface, InetAddress source)
Future<Void>	EpollDatagramChannel.leaveGroup(InetAddress multicastAddress)
Future<Void>	EpollDatagramChannel.leaveGroup(InetAddress multicastAddress, NetworkInterface networkInterface, InetAddress source)
protected Future<Executor>	EpollSocketChannel.prepareToClose()

Uses of Future in io.netty5.channel.group

Subinterfaces of Future in io.netty5.channel.group

Modifier and Type	Interface	Description
interface	ChannelGroupFuture	The result of an asynchronous ChannelGroup operation.

Methods in io.netty5.channel.group that return Future

Modifier and Type	Method	Description
Future<Void>	ChannelGroupFuture.find(Channel channel)	Returns the Future of the individual I/O operation which is associated with the specified Channel.

Methods in io.netty5.channel.group that return types with arguments of type Future

Modifier and Type	Method	Description
Iterator<Future<Void>>	ChannelGroupFuture.iterator()	Returns the Iterator that enumerates all Futures which are associated with this future.

Uses of Future in io.netty5.channel.internal

Methods in io.netty5.channel.internal that return Future

Modifier and Type	Method	Description
Future<Void>	DelegatingChannelHandlerContext.bind(SocketAddress localAddress)
Future<Void>	DelegatingChannelHandlerContext.close()
Future<Void>	DelegatingChannelHandlerContext.connect(SocketAddress remoteAddress)
Future<Void>	DelegatingChannelHandlerContext.connect(SocketAddress remoteAddress, SocketAddress localAddress)
Future<Void>	DelegatingChannelHandlerContext.deregister()
Future<Void>	DelegatingChannelHandlerContext.disconnect()
<V> Future<V>	DelegatingChannelHandlerContext.newFailedFuture(Throwable cause)
Future<Void>	DelegatingChannelHandlerContext.newSucceededFuture()
<V> Future<V>	DelegatingChannelHandlerContext.newSucceededFuture(V value)
Future<Void>	DelegatingChannelHandlerContext.register()
Future<Void>	DelegatingChannelHandlerContext.sendOutboundEvent(Object event)
Future<Void>	DelegatingChannelHandlerContext.shutdown(ChannelShutdownDirection direction)
Future<Void>	DelegatingChannelHandlerContext.write(Object msg)
Future<Void>	DelegatingChannelHandlerContext.writeAndFlush(Object msg)

Uses of Future in io.netty5.channel.kqueue

Methods in io.netty5.channel.kqueue that return Future

Modifier and Type	Method	Description
Future<Void>	KQueueDatagramChannel.block(InetAddress multicastAddress, InetAddress sourceToBlock)
Future<Void>	KQueueDatagramChannel.block(InetAddress multicastAddress, NetworkInterface networkInterface, InetAddress sourceToBlock)
Future<Void>	KQueueDatagramChannel.joinGroup(InetAddress multicastAddress)
Future<Void>	KQueueDatagramChannel.joinGroup(InetAddress multicastAddress, NetworkInterface networkInterface, InetAddress source)
Future<Void>	KQueueDatagramChannel.leaveGroup(InetAddress multicastAddress)
Future<Void>	KQueueDatagramChannel.leaveGroup(InetAddress multicastAddress, NetworkInterface networkInterface, InetAddress source)
protected Future<Executor>	KQueueSocketChannel.prepareToClose()

Uses of Future in io.netty5.channel.socket

Methods in io.netty5.channel.socket that return Future

Modifier and Type	Method	Description
Future<Void>	DatagramChannel.block(InetAddress multicastAddress, InetAddress sourceToBlock)	Block the given sourceToBlock address for the given multicastAddress and notifies the Future once the operation completes.
Future<Void>	DatagramChannel.block(InetAddress multicastAddress, NetworkInterface networkInterface, InetAddress sourceToBlock)	Block the given sourceToBlock address for the given multicastAddress on the given networkInterface and notifies the Future once the operation completes.
Future<Void>	DatagramChannel.joinGroup(InetAddress multicastAddress)	Joins a multicast group and notifies the Future once the operation completes.
Future<Void>	DatagramChannel.joinGroup(InetAddress multicastAddress, NetworkInterface networkInterface, InetAddress source)	Joins the specified multicast group at the specified interface and notifies the Future once the operation completes.
Future<Void>	DatagramChannel.leaveGroup(InetAddress multicastAddress)	Leaves a multicast group and notifies the Future once the operation completes.
Future<Void>	DatagramChannel.leaveGroup(InetAddress multicastAddress, NetworkInterface networkInterface, InetAddress source)	Leave the specified multicast group at the specified interface using the specified source and notifies the Future once the operation completes.

Uses of Future in io.netty5.channel.socket.nio

Methods in io.netty5.channel.socket.nio that return Future

Modifier and Type	Method	Description
Future<Void>	NioDatagramChannel.block(InetAddress multicastAddress, InetAddress sourceToBlock)	Block the given sourceToBlock address for the given multicastAddress
Future<Void>	NioDatagramChannel.block(InetAddress multicastAddress, NetworkInterface networkInterface, InetAddress sourceToBlock)	Block the given sourceToBlock address for the given multicastAddress on the given networkInterface
Future<Void>	NioDatagramChannel.joinGroup(InetAddress multicastAddress)
Future<Void>	NioDatagramChannel.joinGroup(InetAddress multicastAddress, NetworkInterface networkInterface, InetAddress source)
Future<Void>	NioDatagramChannel.leaveGroup(InetAddress multicastAddress)
Future<Void>	NioDatagramChannel.leaveGroup(InetAddress multicastAddress, NetworkInterface networkInterface, InetAddress source)
protected Future<Executor>	NioSocketChannel.prepareToClose()

Uses of Future in io.netty5.handler.address

Methods in io.netty5.handler.address that return Future

Modifier and Type	Method	Description
Future<Void>	DynamicAddressConnectHandler.connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress)
Future<Void>	ResolveAddressHandler.connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress)

Uses of Future in io.netty5.handler.codec

Methods in io.netty5.handler.codec that return Future

Modifier and Type	Method	Description
Future<Void>	DatagramPacketEncoder.bind(ChannelHandlerContext ctx, SocketAddress localAddress)
Future<Void>	DatagramPacketEncoder.close(ChannelHandlerContext ctx)
Future<Void>	DatagramPacketEncoder.connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress)
Future<Void>	DatagramPacketEncoder.deregister(ChannelHandlerContext ctx)
Future<Void>	DatagramPacketEncoder.disconnect(ChannelHandlerContext ctx)
Future<Void>	ByteToMessageCodec.write(ChannelHandlerContext ctx, Object msg)
Future<Void>	MessageToByteEncoder.write(ChannelHandlerContext ctx, Object msg)
Future<Void>	MessageToMessageCodec.write(ChannelHandlerContext ctx, Object msg)
Future<Void>	MessageToMessageEncoder.write(ChannelHandlerContext ctx, Object msg)

Uses of Future in io.netty5.handler.codec.compression

Methods in io.netty5.handler.codec.compression that return Future

Modifier and Type	Method	Description
Future<Void>	CompressionHandler.close(ChannelHandlerContext ctx)
Future<Void>	CompressionHandler.write(ChannelHandlerContext ctx, Object msg)

Uses of Future in io.netty5.handler.codec.http

Methods in io.netty5.handler.codec.http that return Future

Modifier and Type	Method	Description
Future<Void>	HttpClientUpgradeHandler.write(ChannelHandlerContext ctx, Object msg)
Future<Void>	HttpServerKeepAliveHandler.write(ChannelHandlerContext ctx, Object msg)

Uses of Future in io.netty5.handler.codec.http.cors

Methods in io.netty5.handler.codec.http.cors that return Future

Modifier and Type	Method	Description
Future<Void>	CorsHandler.write(ChannelHandlerContext ctx, Object msg)

Uses of Future in io.netty5.handler.codec.http.websocketx

Methods in io.netty5.handler.codec.http.websocketx that return Future

Modifier and Type	Method	Description
Future<Void>	WebSocketClientHandshaker.close(ChannelHandlerContext ctx, CloseWebSocketFrame frame)	Performs the closing handshake
Future<Void>	WebSocketClientHandshaker.close(Channel channel, CloseWebSocketFrame frame)	Performs the closing handshake.
Future<Void>	WebSocketServerHandshaker.close(ChannelHandlerContext ctx, CloseWebSocketFrame frame)	Performs the closing handshake.
Future<Void>	WebSocketServerHandshaker.close(Channel channel, CloseWebSocketFrame frame)	Performs the closing handshake.
Future<Void>	WebSocketClientHandshaker.handshake(Channel channel)	Begins the opening handshake
Future<Void>	WebSocketServerHandshaker.handshake(Channel channel, FullHttpRequest req)	Performs the opening handshake.
Future<Void>	WebSocketServerHandshaker.handshake(Channel channel, FullHttpRequest req, HttpHeaders responseHeaders)	Performs the opening handshake When call this method you MUST NOT retain the FullHttpRequest which is passed in.
Future<Void>	WebSocketServerHandshaker.handshake(Channel channel, HttpRequest req)	Performs the opening handshake.
Future<Void>	WebSocketServerHandshaker.handshake(Channel channel, HttpRequest req, HttpHeaders responseHeaders)	Performs the opening handshake When call this method you MUST NOT retain the HttpRequest which is passed in.
Future<Void>	WebSocketClientHandshaker.processHandshake(Channel channel, HttpResponse response)	Process the opening handshake initiated by WebSocketClientHandshaker.handshake(io.netty5.channel.Channel)}.
static Future<Void>	WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(Channel channel)	Return that we need cannot not support the web socket version

Uses of Future in io.netty5.handler.codec.http.websocketx.extensions

Methods in io.netty5.handler.codec.http.websocketx.extensions that return Future

Modifier and Type	Method	Description
Future<Void>	WebSocketClientExtensionHandler.write(ChannelHandlerContext ctx, Object msg)
Future<Void>	WebSocketServerExtensionHandler.write(ChannelHandlerContext ctx, Object msg)

Uses of Future in io.netty5.handler.codec.http2

Methods in io.netty5.handler.codec.http2 that return Future

Modifier and Type	Method	Description
Future<Void>	Http2ConnectionHandler.close(ChannelHandlerContext ctx)
Future<Void>	Http2ConnectionHandler.goAway(ChannelHandlerContext ctx, int lastStreamId, long errorCode, Buffer debugData)
Future<Void>	Http2LifecycleManager.goAway(ChannelHandlerContext ctx, int lastStreamId, long errorCode, Buffer debugData)	Prevents the peer from creating streams and close the connection if errorCode is not Http2Error.NO_ERROR.
Future<Http2StreamChannel>	Http2StreamChannelBootstrap.open()	Open a new Http2StreamChannel to use.
Future<Http2StreamChannel>	Http2StreamChannelBootstrap.open(Promise<Http2StreamChannel> promise)	Open a new Http2StreamChannel to use and notifies the given Promise.
Future<Void>	Http2ConnectionHandler.resetStream(ChannelHandlerContext ctx, int streamId, long errorCode)
Future<Void>	Http2LifecycleManager.resetStream(ChannelHandlerContext ctx, int streamId, long errorCode)	Ensure the stream identified by streamId is reset.
Future<Void>	Http2FrameCodec.write(ChannelHandlerContext ctx, Object msg)	Processes all Http2Frames.
Future<Void>	HttpToHttp2ConnectionHandler.write(ChannelHandlerContext ctx, Object msg)	Handles conversion of HttpMessage and HttpContent to HTTP/2 frames.
Future<Void>	CompressorHttp2ConnectionEncoder.writeData(ChannelHandlerContext ctx, int streamId, Buffer data, int padding, boolean endOfStream)
Future<Void>	DecoratingHttp2FrameWriter.writeData(ChannelHandlerContext ctx, int streamId, Buffer data, int padding, boolean endStream)
Future<Void>	DefaultHttp2ConnectionEncoder.writeData(ChannelHandlerContext ctx, int streamId, Buffer data, int padding, boolean endOfStream)
Future<Void>	DefaultHttp2FrameWriter.writeData(ChannelHandlerContext ctx, int streamId, Buffer data, int padding, boolean endStream)
Future<Void>	Http2DataWriter.writeData(ChannelHandlerContext ctx, int streamId, Buffer data, int padding, boolean endStream)	Writes a DATA frame to the remote endpoint.
Future<Void>	Http2OutboundFrameLogger.writeData(ChannelHandlerContext ctx, int streamId, Buffer data, int padding, boolean endStream)
Future<Void>	StreamBufferingEncoder.writeData(ChannelHandlerContext ctx, int streamId, Buffer data, int padding, boolean endOfStream)
Future<Void>	DecoratingHttp2FrameWriter.writeFrame(ChannelHandlerContext ctx, byte frameType, int streamId, Http2Flags flags, Buffer payload)
Future<Void>	DefaultHttp2ConnectionEncoder.writeFrame(ChannelHandlerContext ctx, byte frameType, int streamId, Http2Flags flags, Buffer payload)
Future<Void>	DefaultHttp2FrameWriter.writeFrame(ChannelHandlerContext ctx, byte frameType, int streamId, Http2Flags flags, Buffer payload)
Future<Void>	Http2ConnectionEncoder.writeFrame(ChannelHandlerContext ctx, byte frameType, int streamId, Http2Flags flags, Buffer payload)	Writes the given data to the internal Http2FrameWriter without performing any state checks on the connection/stream.
Future<Void>	Http2FrameWriter.writeFrame(ChannelHandlerContext ctx, byte frameType, int streamId, Http2Flags flags, Buffer payload)	Generic write method for any HTTP/2 frame.
Future<Void>	Http2OutboundFrameLogger.writeFrame(ChannelHandlerContext ctx, byte frameType, int streamId, Http2Flags flags, Buffer payload)
Future<Void>	DecoratingHttp2FrameWriter.writeGoAway(ChannelHandlerContext ctx, int lastStreamId, long errorCode, Buffer debugData)
Future<Void>	DefaultHttp2ConnectionEncoder.writeGoAway(ChannelHandlerContext ctx, int lastStreamId, long errorCode, Buffer debugData)
Future<Void>	DefaultHttp2FrameWriter.writeGoAway(ChannelHandlerContext ctx, int lastStreamId, long errorCode, Buffer debugData)
Future<Void>	Http2FrameWriter.writeGoAway(ChannelHandlerContext ctx, int lastStreamId, long errorCode, Buffer debugData)	Writes a GO_AWAY frame to the remote endpoint.
Future<Void>	Http2OutboundFrameLogger.writeGoAway(ChannelHandlerContext ctx, int lastStreamId, long errorCode, Buffer debugData)
Future<Void>	CompressorHttp2ConnectionEncoder.writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int padding, boolean endStream)
Future<Void>	CompressorHttp2ConnectionEncoder.writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int streamDependency, short weight, boolean exclusive, int padding, boolean endOfStream)
Future<Void>	DecoratingHttp2FrameWriter.writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int padding, boolean endStream)
Future<Void>	DecoratingHttp2FrameWriter.writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int streamDependency, short weight, boolean exclusive, int padding, boolean endStream)
Future<Void>	DefaultHttp2ConnectionEncoder.writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int padding, boolean endStream)
Future<Void>	DefaultHttp2ConnectionEncoder.writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int streamDependency, short weight, boolean exclusive, int padding, boolean endOfStream)
Future<Void>	DefaultHttp2FrameWriter.writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int padding, boolean endStream)
Future<Void>	DefaultHttp2FrameWriter.writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int streamDependency, short weight, boolean exclusive, int padding, boolean endStream)
Future<Void>	Http2FrameWriter.writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int padding, boolean endStream)	Writes a HEADERS frame to the remote endpoint.
Future<Void>	Http2FrameWriter.writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int streamDependency, short weight, boolean exclusive, int padding, boolean endStream)	Writes a HEADERS frame with priority specified to the remote endpoint.
Future<Void>	Http2OutboundFrameLogger.writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int padding, boolean endStream)
Future<Void>	Http2OutboundFrameLogger.writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int streamDependency, short weight, boolean exclusive, int padding, boolean endStream)
Future<Void>	StreamBufferingEncoder.writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int padding, boolean endStream)
Future<Void>	StreamBufferingEncoder.writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int streamDependency, short weight, boolean exclusive, int padding, boolean endOfStream)
Future<Void>	DecoratingHttp2FrameWriter.writePing(ChannelHandlerContext ctx, boolean ack, long data)
Future<Void>	DefaultHttp2ConnectionEncoder.writePing(ChannelHandlerContext ctx, boolean ack, long data)
Future<Void>	DefaultHttp2FrameWriter.writePing(ChannelHandlerContext ctx, boolean ack, long data)
Future<Void>	Http2FrameWriter.writePing(ChannelHandlerContext ctx, boolean ack, long data)	Writes a PING frame to the remote endpoint.
Future<Void>	Http2OutboundFrameLogger.writePing(ChannelHandlerContext ctx, boolean ack, long data)
Future<Void>	DecoratingHttp2FrameWriter.writePriority(ChannelHandlerContext ctx, int streamId, int streamDependency, short weight, boolean exclusive)
Future<Void>	DefaultHttp2ConnectionEncoder.writePriority(ChannelHandlerContext ctx, int streamId, int streamDependency, short weight, boolean exclusive)
Future<Void>	DefaultHttp2FrameWriter.writePriority(ChannelHandlerContext ctx, int streamId, int streamDependency, short weight, boolean exclusive)
Future<Void>	Http2FrameWriter.writePriority(ChannelHandlerContext ctx, int streamId, int streamDependency, short weight, boolean exclusive)	Writes a PRIORITY frame to the remote endpoint.
Future<Void>	Http2OutboundFrameLogger.writePriority(ChannelHandlerContext ctx, int streamId, int streamDependency, short weight, boolean exclusive)
Future<Void>	DecoratingHttp2FrameWriter.writePushPromise(ChannelHandlerContext ctx, int streamId, int promisedStreamId, Http2Headers headers, int padding)
Future<Void>	DefaultHttp2ConnectionEncoder.writePushPromise(ChannelHandlerContext ctx, int streamId, int promisedStreamId, Http2Headers headers, int padding)
Future<Void>	DefaultHttp2FrameWriter.writePushPromise(ChannelHandlerContext ctx, int streamId, int promisedStreamId, Http2Headers headers, int padding)
Future<Void>	Http2FrameWriter.writePushPromise(ChannelHandlerContext ctx, int streamId, int promisedStreamId, Http2Headers headers, int padding)	Writes a PUSH_PROMISE frame to the remote endpoint.
Future<Void>	Http2OutboundFrameLogger.writePushPromise(ChannelHandlerContext ctx, int streamId, int promisedStreamId, Http2Headers headers, int padding)
Future<Void>	DecoratingHttp2FrameWriter.writeRstStream(ChannelHandlerContext ctx, int streamId, long errorCode)
Future<Void>	DefaultHttp2ConnectionEncoder.writeRstStream(ChannelHandlerContext ctx, int streamId, long errorCode)
Future<Void>	DefaultHttp2FrameWriter.writeRstStream(ChannelHandlerContext ctx, int streamId, long errorCode)
Future<Void>	Http2FrameWriter.writeRstStream(ChannelHandlerContext ctx, int streamId, long errorCode)	Writes a RST_STREAM frame to the remote endpoint.
Future<Void>	Http2OutboundFrameLogger.writeRstStream(ChannelHandlerContext ctx, int streamId, long errorCode)
Future<Void>	StreamBufferingEncoder.writeRstStream(ChannelHandlerContext ctx, int streamId, long errorCode)
Future<Void>	DecoratingHttp2FrameWriter.writeSettings(ChannelHandlerContext ctx, Http2Settings settings)
Future<Void>	DefaultHttp2ConnectionEncoder.writeSettings(ChannelHandlerContext ctx, Http2Settings settings)
Future<Void>	DefaultHttp2FrameWriter.writeSettings(ChannelHandlerContext ctx, Http2Settings settings)
Future<Void>	Http2FrameWriter.writeSettings(ChannelHandlerContext ctx, Http2Settings settings)	Writes a SETTINGS frame to the remote endpoint.
Future<Void>	Http2OutboundFrameLogger.writeSettings(ChannelHandlerContext ctx, Http2Settings settings)
Future<Void>	DecoratingHttp2FrameWriter.writeSettingsAck(ChannelHandlerContext ctx)
Future<Void>	DefaultHttp2ConnectionEncoder.writeSettingsAck(ChannelHandlerContext ctx)
Future<Void>	DefaultHttp2FrameWriter.writeSettingsAck(ChannelHandlerContext ctx)
Future<Void>	Http2FrameWriter.writeSettingsAck(ChannelHandlerContext ctx)	Writes a SETTINGS acknowledgment to the remote endpoint.
Future<Void>	Http2OutboundFrameLogger.writeSettingsAck(ChannelHandlerContext ctx)
Future<Void>	DecoratingHttp2FrameWriter.writeWindowUpdate(ChannelHandlerContext ctx, int streamId, int windowSizeIncrement)
Future<Void>	DefaultHttp2ConnectionEncoder.writeWindowUpdate(ChannelHandlerContext ctx, int streamId, int windowSizeIncrement)
Future<Void>	DefaultHttp2FrameWriter.writeWindowUpdate(ChannelHandlerContext ctx, int streamId, int windowSizeIncrement)
Future<Void>	Http2FrameWriter.writeWindowUpdate(ChannelHandlerContext ctx, int streamId, int windowSizeIncrement)	Writes a WINDOW_UPDATE frame to the remote endpoint.
Future<Void>	Http2OutboundFrameLogger.writeWindowUpdate(ChannelHandlerContext ctx, int streamId, int windowSizeIncrement)

Methods in io.netty5.handler.codec.http2 with parameters of type Future

Modifier and Type	Method	Description
void	Http2ConnectionHandler.closeStream(Http2Stream stream, Future<Void> future)
void	Http2LifecycleManager.closeStream(Http2Stream stream, Future<Void> future)	Closes and deactivates the given stream.
void	Http2ConnectionHandler.closeStreamLocal(Http2Stream stream, Future<Void> future)	Closes the local side of the given stream.
void	Http2LifecycleManager.closeStreamLocal(Http2Stream stream, Future<Void> future)	Closes the local side of the stream.
void	Http2ConnectionHandler.closeStreamRemote(Http2Stream stream, Future<Void> future)	Closes the remote side of the given stream.
void	Http2LifecycleManager.closeStreamRemote(Http2Stream stream, Future<Void> future)	Closes the remote side of the stream.
void	DefaultHttp2ConnectionEncoder.FlowControlledBase.operationComplete(Future<? extends Void> future)

Uses of Future in io.netty5.handler.flush

Methods in io.netty5.handler.flush that return Future

Modifier and Type	Method	Description
Future<Void>	FlushConsolidationHandler.close(ChannelHandlerContext ctx)
Future<Void>	FlushConsolidationHandler.disconnect(ChannelHandlerContext ctx)

Uses of Future in io.netty5.handler.ipfilter

Methods in io.netty5.handler.ipfilter that return Future

Modifier and Type	Method	Description
protected Future<Void>	AbstractRemoteAddressFilter.channelRejected(ChannelHandlerContext ctx, T remoteAddress)	This method is called if remoteAddress gets rejected by AbstractRemoteAddressFilter.accept(ChannelHandlerContext, SocketAddress).

Uses of Future in io.netty5.handler.logging

Methods in io.netty5.handler.logging that return Future

Modifier and Type	Method	Description
Future<Void>	LoggingHandler.bind(ChannelHandlerContext ctx, SocketAddress localAddress)
Future<Void>	LoggingHandler.close(ChannelHandlerContext ctx)
Future<Void>	LoggingHandler.connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress)
Future<Void>	LoggingHandler.deregister(ChannelHandlerContext ctx)
Future<Void>	LoggingHandler.disconnect(ChannelHandlerContext ctx)
Future<Void>	LoggingHandler.write(ChannelHandlerContext ctx, Object msg)

Uses of Future in io.netty5.handler.ssl

Methods in io.netty5.handler.ssl that return Future

Modifier and Type	Method	Description
Future<Void>	SslHandler.close(ChannelHandlerContext ctx)
Future<Void>	SslHandler.closeOutbound()	Sends an SSL close_notify message to the specified channel and destroys the underlying SSLEngine.
Future<byte[]>	OpenSslAsyncPrivateKeyMethod.decrypt(SSLEngine engine, byte[] input)	Decrypts the input with the given key and notifies the returned Future with the decrypted bytes.
Future<Void>	SslHandler.disconnect(ChannelHandlerContext ctx)
Future<Channel>	SslHandler.handshakeFuture()	Returns a Future that will get notified once the current TLS handshake completes.
protected Future<T>	AbstractSniHandler.lookup(ChannelHandlerContext ctx, Buffer clientHello)
protected abstract Future<T>	AbstractSniHandler.lookup(ChannelHandlerContext ctx, String hostname)	Kicks off a lookup for the given SNI value and returns a Future which in turn will notify the AbstractSniHandler.onLookupComplete(ChannelHandlerContext, String, Future) on completion.
protected Future<SslContext>	SniHandler.lookup(ChannelHandlerContext ctx, String hostname)	The default implementation will simply call AsyncMapping.map(Object, Promise) but users can override this method to implement custom behavior.
protected abstract Future<T>	SslClientHelloHandler.lookup(ChannelHandlerContext ctx, Buffer clientHello)	Kicks off a lookup for the given ClientHello and returns a Future which in turn will notify the SslClientHelloHandler.onLookupComplete(ChannelHandlerContext, Future) on completion.
Future<Channel>	SslHandler.renegotiate()	Performs TLS renegotiation.
Future<Channel>	SslHandler.renegotiate(Promise<Channel> promise)	Performs TLS renegotiation.
Future<byte[]>	OpenSslAsyncPrivateKeyMethod.sign(SSLEngine engine, int signatureAlgorithm, byte[] input)	Signs the input with the given key and notifies the returned Future with the signed bytes.
Future<Channel>	SslHandler.sslCloseFuture()	Return the Future that will get notified if the inbound of the SSLEngine is closed.
Future<Void>	SslHandler.write(ChannelHandlerContext ctx, Object msg)

Methods in io.netty5.handler.ssl with parameters of type Future

Modifier and Type	Method	Description
protected void	AbstractSniHandler.onLookupComplete(ChannelHandlerContext ctx, Future<? extends T> future)
protected abstract void	AbstractSniHandler.onLookupComplete(ChannelHandlerContext ctx, String hostname, Future<? extends T> future)	Called upon completion of the AbstractSniHandler.lookup(ChannelHandlerContext, String) Future.
protected void	SniHandler.onLookupComplete(ChannelHandlerContext ctx, String hostname, Future<? extends SslContext> future)
protected abstract void	SslClientHelloHandler.onLookupComplete(ChannelHandlerContext ctx, Future<? extends T> future)	Called upon completion of the SslClientHelloHandler.lookup(ChannelHandlerContext, Buffer) Future.

Uses of Future in io.netty5.handler.stream

Methods in io.netty5.handler.stream that return Future

Modifier and Type	Method	Description
Future<Void>	ChunkedWriteHandler.write(ChannelHandlerContext ctx, Object msg)

Uses of Future in io.netty5.handler.timeout

Methods in io.netty5.handler.timeout that return Future

Modifier and Type	Method	Description
Future<Void>	IdleStateHandler.write(ChannelHandlerContext ctx, Object msg)
Future<Void>	WriteTimeoutHandler.write(ChannelHandlerContext ctx, Object msg)

Uses of Future in io.netty5.handler.traffic

Methods in io.netty5.handler.traffic that return Future

Modifier and Type	Method	Description
Future<Void>	AbstractTrafficShapingHandler.write(ChannelHandlerContext ctx, Object msg)
Future<Void>	GlobalChannelTrafficShapingHandler.write(ChannelHandlerContext ctx, Object msg)

Uses of Future in io.netty5.resolver

Methods in io.netty5.resolver that return Future

Modifier and Type	Method	Description
Future<T>	AbstractAddressResolver.resolve(SocketAddress address)
Future<T>	AbstractAddressResolver.resolve(SocketAddress address, Promise<T> promise)
Future<T>	AddressResolver.resolve(SocketAddress address)	Resolves the specified address.
Future<T>	AddressResolver.resolve(SocketAddress address, Promise<T> promise)	Resolves the specified address.
Future<T>	NameResolver.resolve(String inetHost)	Resolves the specified name into an address.
Future<T>	NameResolver.resolve(String inetHost, Promise<T> promise)	Resolves the specified name into an address.
Future<T>	SimpleNameResolver.resolve(String inetHost)
Future<T>	SimpleNameResolver.resolve(String inetHost, Promise<T> promise)
Future<List<T>>	AbstractAddressResolver.resolveAll(SocketAddress address)
Future<List<T>>	AbstractAddressResolver.resolveAll(SocketAddress address, Promise<List<T>> promise)
Future<List<T>>	AddressResolver.resolveAll(SocketAddress address)	Resolves the specified address.
Future<List<T>>	AddressResolver.resolveAll(SocketAddress address, Promise<List<T>> promise)	Resolves the specified address.
Future<List<T>>	NameResolver.resolveAll(String inetHost)	Resolves the specified host name and port into a list of address.
Future<List<T>>	NameResolver.resolveAll(String inetHost, Promise<List<T>> promise)	Resolves the specified host name and port into a list of address.
Future<List<T>>	SimpleNameResolver.resolveAll(String inetHost)
Future<List<T>>	SimpleNameResolver.resolveAll(String inetHost, Promise<List<T>> promise)

Uses of Future in io.netty5.resolver.dns

Methods in io.netty5.resolver.dns that return Future

Modifier and Type	Method	Description
Future<AddressedEnvelope<DnsResponse,InetSocketAddress>>	DnsNameResolver.query(DnsQuestion question)	Sends a DNS query with the specified question.
Future<AddressedEnvelope<DnsResponse,InetSocketAddress>>	DnsNameResolver.query(DnsQuestion question, Promise<AddressedEnvelope<? extends DnsResponse,InetSocketAddress>> promise)	Sends a DNS query with the specified question.
Future<AddressedEnvelope<DnsResponse,InetSocketAddress>>	DnsNameResolver.query(DnsQuestion question, Iterable<DnsRecord> additionals)	Sends a DNS query with the specified question with additional records.
Future<AddressedEnvelope<DnsResponse,InetSocketAddress>>	DnsNameResolver.query(InetSocketAddress nameServerAddr, DnsQuestion question)	Sends a DNS query with the specified question using the specified name server list.
Future<AddressedEnvelope<DnsResponse,InetSocketAddress>>	DnsNameResolver.query(InetSocketAddress nameServerAddr, DnsQuestion question, Promise<AddressedEnvelope<? extends DnsResponse,InetSocketAddress>> promise)	Sends a DNS query with the specified question using the specified name server list.
Future<AddressedEnvelope<DnsResponse,InetSocketAddress>>	DnsNameResolver.query(InetSocketAddress nameServerAddr, DnsQuestion question, Iterable<DnsRecord> additionals)	Sends a DNS query with the specified question with additional records using the specified name server list.
Future<AddressedEnvelope<DnsResponse,InetSocketAddress>>	DnsNameResolver.query(InetSocketAddress nameServerAddr, DnsQuestion question, Iterable<DnsRecord> additionals, Promise<AddressedEnvelope<? extends DnsResponse,InetSocketAddress>> promise)	Sends a DNS query with the specified question with additional records using the specified name server list.
Future<InetAddress>	DnsNameResolver.resolve(String inetHost, Iterable<DnsRecord> additionals)	Resolves the specified name into an address.
Future<InetAddress>	DnsNameResolver.resolve(String inetHost, Iterable<DnsRecord> additionals, Promise<InetAddress> promise)	Resolves the specified name into an address.
Future<List<DnsRecord>>	DnsNameResolver.resolveAll(DnsQuestion question)	Resolves the DnsRecords that are matched by the specified DnsQuestion.
Future<List<DnsRecord>>	DnsNameResolver.resolveAll(DnsQuestion question, Iterable<DnsRecord> additionals)	Resolves the DnsRecords that are matched by the specified DnsQuestion.
Future<List<DnsRecord>>	DnsNameResolver.resolveAll(DnsQuestion question, Iterable<DnsRecord> additionals, Promise<List<DnsRecord>> promise)	Resolves the DnsRecords that are matched by the specified DnsQuestion.
Future<List<InetAddress>>	DnsNameResolver.resolveAll(String inetHost, Iterable<DnsRecord> additionals)	Resolves the specified host name and port into a list of address.
Future<List<InetAddress>>	DnsNameResolver.resolveAll(String inetHost, Iterable<DnsRecord> additionals, Promise<List<InetAddress>> promise)	Resolves the specified host name and port into a list of address.

Methods in io.netty5.resolver.dns with parameters of type Future

Modifier and Type	Method	Description
void	BiDnsQueryLifecycleObserver.queryWritten(InetSocketAddress dnsServerAddress, Future<Void> future)
void	DnsQueryLifecycleObserver.queryWritten(InetSocketAddress dnsServerAddress, Future<Void> future)	The query has been written.

Uses of Future in io.netty5.util

Methods in io.netty5.util that return Future

Modifier and Type	Method	Description
Future<OUT>	AsyncMapping.map(IN input, Promise<OUT> promise)	Returns the Future that will provide the result of the mapping.

Uses of Future in io.netty5.util.concurrent

Subinterfaces of Future in io.netty5.util.concurrent

Modifier and Type	Interface	Description
interface	RunnableFuture<V>	A combination of RunnableFuture and Future.
interface	RunnableScheduledFuture<V>	A combination of RunnableFuture and Comparable (sorting by their next deadline), with additional methods for scheduling, periodicity, and delay.

Classes in io.netty5.util.concurrent that implement Future

Modifier and Type	Class	Description
class	DefaultPromise<V>

Methods in io.netty5.util.concurrent that return Future

Modifier and Type	Method	Description
<C> Future<V>	DefaultPromise.addListener(C context, FutureContextListener<? super C,? super V> listener)
Future<V>	DefaultPromise.addListener(FutureListener<? super V> listener)
<C> Future<V>	Future.addListener(C context, FutureContextListener<? super C,? super V> listener)	Adds the specified listener to this future.
Future<V>	Future.addListener(FutureListener<? super V> listener)	Adds the specified listener to this future.
Future<V>	DefaultPromise.asFuture()
Future<V>	Promise.asFuture()	Return the Future instance is associated with this promise.
default Future<V>	Future.cascadeTo(Promise<? super V> promise)	Link the Future and Promise such that if the Future completes the Promise will be notified.
default <R> Future<R>	Future.flatMap(Function<V,Future<R>> mapper)	Creates a new Future that will complete with the result of this Future flat-mapped through the given mapper function.
Future<V>	DefaultPromise.future()
Future<V>	FutureCompletionStage.future()	Returns the underlying Future of this FutureCompletionStage.
default <R> Future<R>	Future.map(Function<V,R> mapper)	Creates a new Future that will complete with the result of this Future mapped through the given mapper function.
default <V> Future<V>	EventExecutor.newFailedFuture(Throwable cause)	Create a new Future which is marked as failed already.
default <V> Future<V>	FuturePromiseFactory.newFailedFuture(Throwable cause)	Create a new Future which is marked as failed already.
<V> Future<V>	AbstractEventExecutor.newSucceededFuture(V result)
default <V> Future<V>	EventExecutor.newSucceededFuture(V result)	Create a new Future which is marked as succeeded already.
default Future<Void>	FuturePromiseFactory.newSucceededFuture()	Create a new Future which is marked as succeeded already.
default <V> Future<V>	FuturePromiseFactory.newSucceededFuture(V result)	Create a new Future which is marked as succeeded already.
protected <V> Future<V>	AbstractScheduledEventExecutor.schedule(RunnableScheduledFuture<V> task)	Add the RunnableScheduledFuture for execution.
Future<Void>	AbstractScheduledEventExecutor.schedule(Runnable command, long delay, TimeUnit unit)
<V> Future<V>	AbstractScheduledEventExecutor.schedule(Callable<V> callable, long delay, TimeUnit unit)
Future<Void>	EventExecutor.schedule(Runnable task, long delay, TimeUnit unit)
<V> Future<V>	EventExecutor.schedule(Callable<V> task, long delay, TimeUnit unit)
default Future<Void>	EventExecutorGroup.schedule(Runnable task, long delay, TimeUnit unit)	Schedule the given task for execution after the given delay, in the next available EventExecutor in this group, and return a future that produces a null result when the task completes.
default <V> Future<V>	EventExecutorGroup.schedule(Callable<V> task, long delay, TimeUnit unit)	Schedule the given task for execution after the given delay, in the next available EventExecutor in this group, and return a future that will return the result of the callable when the task completes.
Future<Void>	ImmediateEventExecutor.schedule(Runnable task, long delay, TimeUnit unit)
<V> Future<V>	ImmediateEventExecutor.schedule(Callable<V> task, long delay, TimeUnit unit)
Future<Void>	NonStickyEventExecutorGroup.schedule(Runnable task, long delay, TimeUnit unit)
<V> Future<V>	NonStickyEventExecutorGroup.schedule(Callable<V> task, long delay, TimeUnit unit)
Future<Void>	UnorderedThreadPoolEventExecutor.schedule(Runnable task, long delay, TimeUnit unit)
<V> Future<V>	UnorderedThreadPoolEventExecutor.schedule(Callable<V> task, long delay, TimeUnit unit)
Future<Void>	AbstractScheduledEventExecutor.scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
Future<Void>	EventExecutor.scheduleAtFixedRate(Runnable task, long initialDelay, long period, TimeUnit unit)
default Future<Void>	EventExecutorGroup.scheduleAtFixedRate(Runnable task, long initialDelay, long period, TimeUnit unit)	Schedule the given task for periodic execution in the next available EventExecutor.
Future<Void>	ImmediateEventExecutor.scheduleAtFixedRate(Runnable task, long initialDelay, long period, TimeUnit unit)
Future<Void>	NonStickyEventExecutorGroup.scheduleAtFixedRate(Runnable task, long initialDelay, long period, TimeUnit unit)
Future<Void>	UnorderedThreadPoolEventExecutor.scheduleAtFixedRate(Runnable task, long initialDelay, long period, TimeUnit unit)
Future<Void>	AbstractScheduledEventExecutor.scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
Future<Void>	EventExecutor.scheduleWithFixedDelay(Runnable task, long initialDelay, long delay, TimeUnit unit)
default Future<Void>	EventExecutorGroup.scheduleWithFixedDelay(Runnable task, long initialDelay, long delay, TimeUnit unit)	Schedule the given task for periodic execution in the next available EventExecutor.
Future<Void>	ImmediateEventExecutor.scheduleWithFixedDelay(Runnable task, long initialDelay, long delay, TimeUnit unit)
Future<Void>	NonStickyEventExecutorGroup.scheduleWithFixedDelay(Runnable task, long initialDelay, long delay, TimeUnit unit)
Future<Void>	UnorderedThreadPoolEventExecutor.scheduleWithFixedDelay(Runnable task, long initialDelay, long delay, TimeUnit unit)
default Future<Void>	EventExecutorGroup.shutdownGracefully()	Shortcut method for EventExecutorGroup.shutdownGracefully(long, long, TimeUnit) with sensible default values.
Future<Void>	EventExecutorGroup.shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit)	Signals this executor that the caller wants the executor to be shut down.
Future<Void>	GlobalEventExecutor.shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit)
Future<Void>	ImmediateEventExecutor.shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit)
Future<Void>	MultithreadEventExecutorGroup.shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit)
Future<Void>	NonStickyEventExecutorGroup.shutdownGracefully()
Future<Void>	NonStickyEventExecutorGroup.shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit)
Future<Void>	SingleThreadEventExecutor.shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit)
Future<Void>	UnorderedThreadPoolEventExecutor.shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit)
Future<Void>	AbstractEventExecutor.submit(Runnable task)
<T> Future<T>	AbstractEventExecutor.submit(Runnable task, T result)
<T> Future<T>	AbstractEventExecutor.submit(Callable<T> task)
Future<Void>	EventExecutor.submit(Runnable task)
<T> Future<T>	EventExecutor.submit(Runnable task, T result)
<T> Future<T>	EventExecutor.submit(Callable<T> task)
default Future<Void>	EventExecutorGroup.submit(Runnable task)	Submit the given task for execution in the next available EventExecutor in this group, and return a future that produces a null result when the task completes.
default <T> Future<T>	EventExecutorGroup.submit(Runnable task, T result)	Submit the given task for execution in the next available EventExecutor in this group, and return a future that produces the given result when the task completes.
default <T> Future<T>	EventExecutorGroup.submit(Callable<T> task)	Submit the given task for execution in the next available EventExecutor in this group, and return a future that will return the result of the callable when the task completes.
Future<Void>	NonStickyEventExecutorGroup.submit(Runnable task)
<T> Future<T>	NonStickyEventExecutorGroup.submit(Runnable task, T result)
<T> Future<T>	NonStickyEventExecutorGroup.submit(Callable<T> task)
Future<Void>	UnorderedThreadPoolEventExecutor.submit(Runnable task)
<T> Future<T>	UnorderedThreadPoolEventExecutor.submit(Runnable task, T result)
<T> Future<T>	UnorderedThreadPoolEventExecutor.submit(Callable<T> task)
Future<Void>	EventExecutorGroup.terminationFuture()	Returns the Future which is notified when all EventExecutors managed by this EventExecutorGroup have been terminated.
Future<Void>	GlobalEventExecutor.terminationFuture()
Future<Void>	ImmediateEventExecutor.terminationFuture()
Future<Void>	MultithreadEventExecutorGroup.terminationFuture()
Future<Void>	NonStickyEventExecutorGroup.terminationFuture()
Future<Void>	SingleThreadEventExecutor.terminationFuture()
Future<Void>	UnorderedThreadPoolEventExecutor.terminationFuture()

Methods in io.netty5.util.concurrent with parameters of type Future

Modifier and Type	Method	Description
void	PromiseCombiner.add(Future<?> future)	Adds a new future to be combined.
void	PromiseCombiner.addAll(Future<?>... futures)	Adds new futures to be combined.
void	FutureContextListener.operationComplete(C context, Future<? extends V> future)	Invoked when the operation associated with the Future has been completed.
void	FutureListener.operationComplete(Future<? extends V> future)	Invoked when the operation associated with the Future has been completed.

Method parameters in io.netty5.util.concurrent with type arguments of type Future

Modifier and Type	Method	Description
default <R> Future<R>	Future.flatMap(Function<V,Future<R>> mapper)	Creates a new Future that will complete with the result of this Future flat-mapped through the given mapper function.