Uses of Interface
io.netty.util.concurrent.Promise

Packages that use Promise

Package	Description
io.netty.channel	The core channel API which is asynchronous and event-driven abstraction of various transports such as a NIO Channel.
io.netty.channel.pool	Implementations and API for Channel pools.
io.netty.handler.codec.http2	Handlers for sending and receiving HTTP/2 frames.
io.netty.handler.ssl	SSL · TLS implementation based on SSLEngine
io.netty.resolver	Resolves an arbitrary string that represents the name of an endpoint into an address.
io.netty.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.netty.util	Utility classes used across multiple packages.
io.netty.util.concurrent	Utility classes for concurrent / async tasks.

Uses of Promise in io.netty.channel

Subinterfaces of Promise in io.netty.channel

Modifier and Type	Interface and Description
interface	ChannelProgressivePromise Special ChannelPromise which will be notified once the associated bytes is transferring.
interface	ChannelPromise Special ChannelFuture which is writable.

Classes in io.netty.channel that implement Promise

Modifier and Type	Class and Description
class	DefaultChannelProgressivePromise The default ChannelProgressivePromise implementation.
class	DefaultChannelPromise The default ChannelPromise implementation.

Uses of Promise in io.netty.channel.pool

Methods in io.netty.channel.pool with parameters of type Promise

Modifier and Type	Method and Description
Future<Channel>	SimpleChannelPool.acquire(Promise<Channel> promise)
Future<Channel>	FixedChannelPool.acquire(Promise<Channel> promise)
Future<Channel>	ChannelPool.acquire(Promise<Channel> promise) Acquire a Channel from this ChannelPool.
Future<Void>	SimpleChannelPool.release(Channel channel, Promise<Void> promise)
Future<Void>	FixedChannelPool.release(Channel channel, Promise<Void> promise)
Future<Void>	ChannelPool.release(Channel channel, Promise<Void> promise) Release a Channel back to this ChannelPool.

Uses of Promise in io.netty.handler.codec.http2

Methods in io.netty.handler.codec.http2 with parameters of type Promise

Modifier and Type	Method and Description
Future<Void>	Http2Connection.close(Promise<Void> promise) Close this connection.
Future<Void>	DefaultHttp2Connection.close(Promise<Void> promise)

Uses of Promise in io.netty.handler.ssl

Methods in io.netty.handler.ssl with parameters of type Promise

Modifier and Type	Method and Description
Future<Channel>	SslHandler.renegotiate(Promise<Channel> promise) Performs TLS renegotiation.

Uses of Promise in io.netty.resolver

Methods in io.netty.resolver with parameters of type Promise

Modifier and Type	Method and Description
protected void	InetSocketAddressResolver.doResolve(InetSocketAddress unresolvedAddress, Promise<InetSocketAddress> promise)
protected void	NoopAddressResolver.doResolve(SocketAddress unresolvedAddress, Promise<SocketAddress> promise)
protected void	RoundRobinInetAddressResolver.doResolve(String inetHost, Promise<InetAddress> promise)
protected void	DefaultNameResolver.doResolve(String inetHost, Promise<InetAddress> promise)
protected abstract void	SimpleNameResolver.doResolve(String inetHost, Promise<T> promise) Invoked by SimpleNameResolver.resolve(String) to perform the actual name resolution.
protected void	CompositeNameResolver.doResolve(String inetHost, Promise<T> promise)
protected abstract void	AbstractAddressResolver.doResolve(T unresolvedAddress, Promise<T> promise) Invoked by AbstractAddressResolver.resolve(SocketAddress) to perform the actual name resolution.
protected void	InetSocketAddressResolver.doResolveAll(InetSocketAddress unresolvedAddress, Promise<List<InetSocketAddress>> promise)
protected void	NoopAddressResolver.doResolveAll(SocketAddress unresolvedAddress, Promise<List<SocketAddress>> promise)
protected void	RoundRobinInetAddressResolver.doResolveAll(String inetHost, Promise<List<InetAddress>> promise)
protected void	DefaultNameResolver.doResolveAll(String inetHost, Promise<List<InetAddress>> promise)
protected abstract void	SimpleNameResolver.doResolveAll(String inetHost, Promise<List<T>> promise) Invoked by SimpleNameResolver.resolveAll(String) to perform the actual name resolution.
protected void	CompositeNameResolver.doResolveAll(String inetHost, Promise<List<T>> promise)
protected abstract void	AbstractAddressResolver.doResolveAll(T unresolvedAddress, Promise<List<T>> promise) Invoked by AbstractAddressResolver.resolveAll(SocketAddress) to perform the actual name resolution.
Future<T>	AddressResolver.resolve(SocketAddress address, Promise<T> promise) Resolves the specified address.
Future<T>	AbstractAddressResolver.resolve(SocketAddress address, Promise<T> promise)
Future<T>	SimpleNameResolver.resolve(String inetHost, Promise<T> promise)
Future<T>	NameResolver.resolve(String inetHost, Promise<T> promise) Resolves the specified name into an address.
Future<List<T>>	AddressResolver.resolveAll(SocketAddress address, Promise<List<T>> promise) Resolves the specified address.
Future<List<T>>	AbstractAddressResolver.resolveAll(SocketAddress address, Promise<List<T>> promise)
Future<List<T>>	SimpleNameResolver.resolveAll(String inetHost, Promise<List<T>> promise)
Future<List<T>>	NameResolver.resolveAll(String inetHost, Promise<List<T>> promise) Resolves the specified host name and port into a list of address.

Uses of Promise in io.netty.resolver.dns

Methods in io.netty.resolver.dns with parameters of type Promise

Modifier and Type	Method and Description
protected void	DnsNameResolver.doResolve(String inetHost, DnsRecord[] additionals, Promise<InetAddress> promise, DnsCache resolveCache) Hook designed for extensibility so one can pass a different cache on each resolution attempt instead of using the global one.
protected void	DnsNameResolver.doResolve(String inetHost, Promise<InetAddress> promise)
protected void	DnsNameResolver.doResolveAll(String inetHost, DnsRecord[] additionals, Promise<List<InetAddress>> promise, DnsCache resolveCache) Hook designed for extensibility so one can pass a different cache on each resolution attempt instead of using the global one.
protected void	DnsNameResolver.doResolveAll(String inetHost, Promise<List<InetAddress>> promise)
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(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<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<InetAddress>	DnsNameResolver.resolve(String inetHost, Iterable<DnsRecord> additionals, Promise<InetAddress> promise) Resolves the specified name into an 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.

Uses of Promise in io.netty.util

Methods in io.netty.util with parameters of type Promise

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

Uses of Promise in io.netty.util.concurrent

Subinterfaces of Promise in io.netty.util.concurrent

Modifier and Type	Interface and Description
interface	ProgressivePromise<V> Special ProgressiveFuture which is writable.

Classes in io.netty.util.concurrent that implement Promise

Modifier and Type	Class and Description
class	DefaultProgressivePromise<V>
class	DefaultPromise<V>

Methods in io.netty.util.concurrent that return Promise

Modifier and Type	Method and Description
Promise<V>	Promise.addListener(GenericFutureListener<? extends Future<? super V>> listener)
Promise<V>	DefaultPromise.addListener(GenericFutureListener<? extends Future<? super V>> listener)
Promise<V>	Promise.addListeners(GenericFutureListener<? extends Future<? super V>>... listeners)
Promise<V>	DefaultPromise.addListeners(GenericFutureListener<? extends Future<? super V>>... listeners)
Promise<V>	Promise.await()
Promise<V>	DefaultPromise.await()
Promise<V>	Promise.awaitUninterruptibly()
Promise<V>	DefaultPromise.awaitUninterruptibly()
<V> Promise<V>	UnorderedThreadPoolEventExecutor.newPromise()
<V> Promise<V>	ImmediateEventExecutor.newPromise()
<V> Promise<V>	EventExecutor.newPromise() Return a new Promise.
<V> Promise<V>	AbstractEventExecutor.newPromise()
Promise<V>	Promise.removeListener(GenericFutureListener<? extends Future<? super V>> listener)
Promise<V>	DefaultPromise.removeListener(GenericFutureListener<? extends Future<? super V>> listener)
Promise<V>	Promise.removeListeners(GenericFutureListener<? extends Future<? super V>>... listeners)
Promise<V>	DefaultPromise.removeListeners(GenericFutureListener<? extends Future<? super V>>... listeners)
Promise<V>	Promise.setFailure(Throwable cause) Marks this future as a failure and notifies all listeners.
Promise<V>	DefaultPromise.setFailure(Throwable cause)
Promise<V>	Promise.setSuccess(V result) Marks this future as a success and notifies all listeners.
Promise<V>	DefaultPromise.setSuccess(V result)
Promise<V>	Promise.sync()
Promise<V>	DefaultPromise.sync()
Promise<V>	Promise.syncUninterruptibly()
Promise<V>	DefaultPromise.syncUninterruptibly()

Methods in io.netty.util.concurrent with parameters of type Promise

Modifier and Type	Method and Description
void	PromiseCombiner.add(Promise promise) Deprecated. Replaced by PromiseCombiner.add(Future).
PromiseAggregator<V,F>	PromiseAggregator.add(Promise<V>... promises) Deprecated. Add the given Promises to the aggregator.
void	PromiseCombiner.addAll(Promise... promises) Deprecated. Replaced by PromiseCombiner.addAll(Future[])
static <X> void	UnaryPromiseNotifier.cascadeTo(Future<X> completedFuture, Promise<? super X> promise)
void	PromiseCombiner.finish(Promise<Void> aggregatePromise) Sets the promise to be notified when all combined futures have finished.

Constructors in io.netty.util.concurrent with parameters of type Promise

Constructor and Description
PromiseAggregator(Promise<Void> aggregatePromise) Deprecated. See PromiseAggregator.PromiseAggregator(Promise, boolean).
PromiseAggregator(Promise<Void> aggregatePromise, boolean failPending) Deprecated. Creates a new instance.
PromiseNotifier(boolean logNotifyFailure, Promise<? super V>... promises) Create a new instance.
PromiseNotifier(Promise<? super V>... promises) Create a new instance.
UnaryPromiseNotifier(Promise<? super T> promise)