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

Packages that use Promise

Package	Description
io.netty.bootstrap	The helper classes with fluent API which enable an easy implementation of typical client side and server side channel initialization.
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.group	A channel registry which helps a user maintain the list of open Channels and perform bulk operations on them.
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.proxy	Adds support for client connections via proxy protocols such as SOCKS and HTTP CONNECT tunneling
io.netty.handler.ssl	SSL · TLS implementation based on SSLEngine
io.netty.handler.ssl.ocsp	Certificate validation using OCSP
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.
io.netty.util.internal	Internal-use-only utilities which is not allowed to be used outside Netty.

Uses of Promise in io.netty.bootstrap

Classes in io.netty.bootstrap that implement Promise

Modifier and Type	Class	Description
(package private) static final class	AbstractBootstrap.PendingRegistrationPromise

Uses of Promise in io.netty.channel

Subinterfaces of Promise in io.netty.channel

Modifier and Type	Interface	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	Description
(package private) static final class	AbstractChannel.CloseFuture
class	DefaultChannelProgressivePromise	The default ChannelProgressivePromise implementation.
class	DefaultChannelPromise	The default ChannelPromise implementation.
final class	DelegatingChannelPromiseNotifier
final class	VoidChannelPromise

Fields in io.netty.channel declared as Promise

Modifier and Type	Field	Description
private final Promise<?>	ThreadPerChannelEventLoopGroup.terminationFuture	Deprecated.

Uses of Promise in io.netty.channel.group

Classes in io.netty.channel.group that implement Promise

Modifier and Type	Class	Description
(package private) final class	DefaultChannelGroupFuture	The default ChannelGroupFuture implementation.

Uses of Promise in io.netty.channel.pool

Fields in io.netty.channel.pool declared as Promise

Modifier and Type	Field	Description
private final Promise<Channel>	FixedChannelPool.AcquireListener.originalPromise
(package private) final Promise<Channel>	FixedChannelPool.AcquireTask.promise

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

Modifier and Type	Method	Description
Future<Channel>	ChannelPool.acquire(Promise<Channel> promise)	Acquire a Channel from this ChannelPool.
Future<Channel>	FixedChannelPool.acquire(Promise<Channel> promise)
Future<Channel>	SimpleChannelPool.acquire(Promise<Channel> promise)
private void	FixedChannelPool.acquire0(Promise<Channel> promise)
private Future<Channel>	SimpleChannelPool.acquireHealthyFromPoolOrNew(Promise<Channel> promise)	Tries to retrieve healthy channel from the pool if any or creates a new channel otherwise.
private void	SimpleChannelPool.closeAndFail(Channel channel, Throwable cause, Promise<?> promise)
private void	SimpleChannelPool.doHealthCheck(Channel channel, Promise<Channel> promise)
private void	SimpleChannelPool.doHealthCheckOnRelease(Channel channel, Promise<Void> promise)
private void	SimpleChannelPool.doReleaseChannel(Channel channel, Promise<Void> promise)
private void	SimpleChannelPool.notifyConnect(ChannelFuture future, Promise<Channel> promise)
private void	SimpleChannelPool.notifyHealthCheck(Future<Boolean> future, Channel channel, Promise<Channel> promise)
Future<Void>	ChannelPool.release(Channel channel, Promise<Void> promise)	Release a Channel back to this ChannelPool.
Future<Void>	FixedChannelPool.release(Channel channel, Promise<Void> promise)
Future<Void>	SimpleChannelPool.release(Channel channel, Promise<Void> promise)
private void	SimpleChannelPool.releaseAndOffer(Channel channel, Promise<Void> promise)
private void	SimpleChannelPool.releaseAndOfferIfHealthy(Channel channel, Promise<Void> promise, Future<Boolean> future)	Adds the channel back to the pool only if the channel is healthy.
private void	FixedChannelPool.tooManyOutstanding(Promise<?> promise)

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

Modifier	Constructor	Description
(package private)	AcquireListener(Promise<Channel> originalPromise)
(package private)	AcquireTask(Promise<Channel> promise)

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

Classes in io.netty.handler.codec.http2 that implement Promise

Modifier and Type	Class	Description
(package private) static final class	Http2CodecUtil.SimpleChannelPromiseAggregator	Provides the ability to associate the outcome of multiple ChannelPromise objects into a single ChannelPromise object.

Fields in io.netty.handler.codec.http2 declared as Promise

Modifier and Type	Field	Description
(package private) Promise<Void>	DefaultHttp2Connection.closePromise

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

Modifier and Type	Method	Description
Future<Void>	DefaultHttp2Connection.close(Promise<Void> promise)
Future<Void>	Http2Connection.close(Promise<Void> promise)	Close this connection.
Future<Http2StreamChannel>	Http2StreamChannelBootstrap.open(Promise<Http2StreamChannel> promise)	Open a new Http2StreamChannel to use and notifies the given Promise.
void	Http2StreamChannelBootstrap.open0(ChannelHandlerContext ctx, Promise<Http2StreamChannel> promise)	Deprecated. should not be used directly.

Uses of Promise in io.netty.handler.proxy

Classes in io.netty.handler.proxy that implement Promise

Modifier and Type	Class	Description
private final class	ProxyHandler.LazyChannelPromise

Uses of Promise in io.netty.handler.ssl

Classes in io.netty.handler.ssl that implement Promise

Modifier and Type	Class	Description
private final class	SslHandler.LazyChannelPromise

Fields in io.netty.handler.ssl declared as Promise

Modifier and Type	Field	Description
private Promise<Channel>	SslHandler.handshakePromise

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

Modifier and Type	Method	Description
Future<SslContext>	SniHandler.AsyncMappingAdapter.map(String input, Promise<SslContext> promise)
Future<Channel>	SslHandler.renegotiate(Promise<Channel> promise)	Performs TLS renegotiation.
private void	SslHandler.renegotiateOnEventLoop(Promise<Channel> newHandshakePromise)

Uses of Promise in io.netty.handler.ssl.ocsp

Fields in io.netty.handler.ssl.ocsp declared as Promise

Modifier and Type	Field	Description
private final Promise<org.bouncycastle.cert.ocsp.OCSPResp>	OcspHttpHandler.responseFuture
private final Promise<org.bouncycastle.cert.ocsp.OCSPResp>	OcspClient.Initializer.responsePromise

Methods in io.netty.handler.ssl.ocsp that return Promise

Modifier and Type	Method	Description
private static Promise<org.bouncycastle.cert.ocsp.OCSPResp>	OcspClient.query(EventLoop eventLoop, ByteBuf ocspRequest, String host, int port, String path, IoTransport ioTransport, DnsNameResolver dnsNameResolver)	Query the OCSP responder for certificate status using HTTP/1.1
(package private) static Promise<org.bouncycastle.cert.ocsp.BasicOCSPResp>	OcspClient.query(X509Certificate x509Certificate, X509Certificate issuer, boolean validateResponseNonce, IoTransport ioTransport, DnsNameResolver dnsNameResolver)	Query the certificate status using OCSP

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

Modifier and Type	Method	Description
private static void	OcspClient.validateResponse(Promise<org.bouncycastle.cert.ocsp.BasicOCSPResp> responsePromise, org.bouncycastle.cert.ocsp.BasicOCSPResp basicResponse, org.bouncycastle.asn1.DEROctetString derNonce, X509Certificate issuer, boolean validateNonce)

Constructors in io.netty.handler.ssl.ocsp with parameters of type Promise

Modifier	Constructor	Description
(package private)	Initializer(Promise<org.bouncycastle.cert.ocsp.OCSPResp> responsePromise)
(package private)	OcspHttpHandler(Promise<org.bouncycastle.cert.ocsp.OCSPResp> responsePromise)	Create new OcspHttpHandler instance

Uses of Promise in io.netty.resolver

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

Modifier and Type	Method	Description
protected abstract void	AbstractAddressResolver.doResolve(T unresolvedAddress, Promise<T> promise)	Invoked by AbstractAddressResolver.resolve(SocketAddress) to perform the actual name resolution.
protected void	CompositeNameResolver.doResolve(String inetHost, Promise<T> promise)
protected void	DefaultNameResolver.doResolve(String inetHost, Promise<InetAddress> promise)
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 abstract void	SimpleNameResolver.doResolve(String inetHost, Promise<T> promise)	Invoked by SimpleNameResolver.resolve(String) to perform the actual name resolution.
protected abstract void	AbstractAddressResolver.doResolveAll(T unresolvedAddress, Promise<List<T>> promise)	Invoked by AbstractAddressResolver.resolveAll(SocketAddress) to perform the actual name resolution.
protected void	CompositeNameResolver.doResolveAll(String inetHost, Promise<List<T>> promise)
protected void	DefaultNameResolver.doResolveAll(String inetHost, Promise<List<InetAddress>> promise)
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 abstract void	SimpleNameResolver.doResolveAll(String inetHost, Promise<List<T>> promise)	Invoked by SimpleNameResolver.resolveAll(String) to perform the actual name resolution.
private void	CompositeNameResolver.doResolveAllRec(String inetHost, Promise<List<T>> promise, int resolverIndex, Throwable lastFailure)
private void	CompositeNameResolver.doResolveRec(String inetHost, Promise<T> promise, int resolverIndex, Throwable lastFailure)
final Future<T>	AbstractAddressResolver.resolve(SocketAddress address, Promise<T> promise)
Future<T>	AddressResolver.resolve(SocketAddress address, Promise<T> promise)	Resolves the specified address.
Future<T>	NameResolver.resolve(String inetHost, Promise<T> promise)	Resolves the specified name into an address.
Future<T>	SimpleNameResolver.resolve(String inetHost, Promise<T> promise)
final Future<List<T>>	AbstractAddressResolver.resolveAll(SocketAddress address, Promise<List<T>> promise)
Future<List<T>>	AddressResolver.resolveAll(SocketAddress address, Promise<List<T>> promise)	Resolves the specified 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, Promise<List<T>> promise)

Uses of Promise in io.netty.resolver.dns

Fields in io.netty.resolver.dns declared as Promise

Modifier and Type	Field	Description
private final Promise<?>	DnsResolveContext.originalPromise
private final Promise<AddressedEnvelope<DnsResponse,InetSocketAddress>>	DnsQueryContext.promise

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

Modifier and Type	Field	Description
private final ConcurrentMap<String,Promise<List<InetAddress>>>	DnsAddressResolverGroup.resolveAllsInProgress
private final ConcurrentMap<String,Promise<List<T>>>	InflightNameResolver.resolveAllsInProgress
private final ConcurrentMap<String,Promise<InetAddress>>	DnsAddressResolverGroup.resolvesInProgress
private final ConcurrentMap<String,Promise<T>>	InflightNameResolver.resolvesInProgress

Methods in io.netty.resolver.dns that return Promise

Modifier and Type	Method	Description
private static Promise<AddressedEnvelope<DnsResponse,InetSocketAddress>>	DnsNameResolver.cast(Promise<?> promise)
Promise<T>	InflightNameResolver.resolve(String inetHost, Promise<T> promise)
private <U> Promise<U>	InflightNameResolver.resolve(ConcurrentMap<String,Promise<U>> resolveMap, String inetHost, Promise<U> promise, boolean resolveAll)
Promise<List<T>>	InflightNameResolver.resolveAll(String inetHost, Promise<List<T>> promise)

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

Modifier and Type	Method	Description
private static Promise<AddressedEnvelope<DnsResponse,InetSocketAddress>>	DnsNameResolver.cast(Promise<?> promise)
(package private) final Future<AddressedEnvelope<DnsResponse,InetSocketAddress>>	DnsNameResolver.doQuery(Channel channel, InetSocketAddress nameServerAddr, DnsQuestion question, DnsQueryLifecycleObserver queryLifecycleObserver, DnsRecord[] additionals, boolean flush, Promise<AddressedEnvelope<? extends DnsResponse,InetSocketAddress>> promise)
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)
(package private) static boolean	DnsNameResolver.doResolveAllCached(String hostname, DnsRecord[] additionals, Promise<List<InetAddress>> promise, DnsCache resolveCache, String[] searchDomains, int ndots, InternetProtocolFamily[] resolvedInternetProtocolFamilies)
private void	DnsNameResolver.doResolveAllNow(ChannelFuture f, String hostname, DnsRecord[] additionals, Promise<List<InetAddress>> promise, DnsCache resolveCache)
private void	DnsNameResolver.doResolveAllUncached(Channel channel, String hostname, DnsRecord[] additionals, Promise<?> originalPromise, Promise<List<InetAddress>> promise, DnsCache resolveCache, boolean completeEarlyIfPossible)
private void	DnsNameResolver.doResolveAllUncached0(Channel channel, String hostname, DnsRecord[] additionals, Promise<?> originalPromise, Promise<List<InetAddress>> promise, DnsCache resolveCache, boolean completeEarlyIfPossible)
private boolean	DnsNameResolver.doResolveCached(String hostname, DnsRecord[] additionals, Promise<InetAddress> promise, DnsCache resolveCache)
private void	DnsNameResolver.doResolveNow(ChannelFuture f, String hostname, DnsRecord[] additionals, Promise<InetAddress> promise, DnsCache resolveCache)
private void	DnsNameResolver.doResolveUncached(Channel channel, String hostname, DnsRecord[] additionals, Promise<InetAddress> promise, DnsCache resolveCache, boolean completeEarlyIfPossible)
(package private) void	DnsAddressResolveContext.doSearchDomainQuery(String hostname, Promise<List<InetAddress>> nextPromise)
(package private) void	DnsResolveContext.doSearchDomainQuery(String hostname, Promise<List<T>> nextPromise)
private void	DnsResolveContext.finishResolve(Promise<List<T>> promise, Throwable cause)
private void	DnsResolveContext.followCname(DnsQuestion question, String cname, DnsQueryLifecycleObserver queryLifecycleObserver, Promise<List<T>> promise)
private boolean	DnsResolveContext.handleRedirect(DnsQuestion question, AddressedEnvelope<DnsResponse,InetSocketAddress> envelope, DnsQueryLifecycleObserver queryLifecycleObserver, Promise<List<T>> promise)	Handles a redirect answer if needed and returns true if a redirect query has been made.
private void	DnsResolveContext.internalResolve(String name, Promise<List<T>> promise)
(package private) DnsResolveContext<InetAddress>	DnsAddressResolveContext.newResolverContext(DnsNameResolver parent, Channel channel, Promise<?> originalPromise, String hostname, int dnsClass, DnsRecordType[] expectedTypes, DnsRecord[] additionals, DnsServerAddressStream nameServerAddrs, int allowedQueries)
(package private) DnsResolveContext<DnsRecord>	DnsRecordResolveContext.newResolverContext(DnsNameResolver parent, Channel channel, Promise<?> originalPromise, String hostname, int dnsClass, DnsRecordType[] expectedTypes, DnsRecord[] additionals, DnsServerAddressStream nameServerAddrs, int allowedQueries)
(package private) abstract DnsResolveContext<T>	DnsResolveContext.newResolverContext(DnsNameResolver parent, Channel channel, Promise<?> originalPromise, String hostname, int dnsClass, DnsRecordType[] expectedTypes, DnsRecord[] additionals, DnsServerAddressStream nameServerAddrs, int allowedQueries)	Creates a new context with the given parameters.
private void	DnsResolveContext.onExpectedResponse(DnsQuestion question, AddressedEnvelope<DnsResponse,InetSocketAddress> envelope, DnsQueryLifecycleObserver queryLifecycleObserver, Promise<List<T>> promise)
private void	DnsResolveContext.onResponse(DnsServerAddressStream nameServerAddrStream, int nameServerAddrStreamIndex, DnsQuestion question, AddressedEnvelope<DnsResponse,InetSocketAddress> envelope, DnsQueryLifecycleObserver queryLifecycleObserver, Promise<List<T>> promise)
private void	DnsResolveContext.onResponseCNAME(DnsQuestion question, Map<String,String> cnames, DnsQueryLifecycleObserver queryLifecycleObserver, Promise<List<T>> 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, 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, Promise<AddressedEnvelope<? extends DnsResponse,InetSocketAddress>> promise)	Sends a DNS query with the specified question with additional records using the specified name server list.
private void	DnsResolveContext.query(DnsServerAddressStream nameServerAddrStream, int nameServerAddrStreamIndex, DnsQuestion question, DnsQueryLifecycleObserver queryLifecycleObserver, boolean flush, Promise<List<T>> promise, Throwable cause)
private boolean	DnsResolveContext.query(String hostname, DnsRecordType type, DnsServerAddressStream dnsServerAddressStream, boolean flush, Promise<List<T>> promise)
private void	DnsResolveContext.queryUnresolvedNameServer(InetSocketAddress nameServerAddr, DnsServerAddressStream nameServerAddrStream, int nameServerAddrStreamIndex, DnsQuestion question, DnsQueryLifecycleObserver queryLifecycleObserver, Promise<List<T>> promise, Throwable cause)
final Future<InetAddress>	DnsNameResolver.resolve(String inetHost, Iterable<DnsRecord> additionals, Promise<InetAddress> promise)	Resolves the specified name into an address.
(package private) void	DnsResolveContext.resolve(Promise<List<T>> promise)
Promise<T>	InflightNameResolver.resolve(String inetHost, Promise<T> promise)
private <U> Promise<U>	InflightNameResolver.resolve(ConcurrentMap<String,Promise<U>> resolveMap, String inetHost, Promise<U> promise, boolean resolveAll)
private Future<List<DnsRecord>>	DnsNameResolver.resolveAll(DnsQuestion question, DnsRecord[] additionals, Promise<List<DnsRecord>> promise)
final Future<List<DnsRecord>>	DnsNameResolver.resolveAll(DnsQuestion question, Iterable<DnsRecord> additionals, Promise<List<DnsRecord>> promise)	Resolves the DnsRecords that are matched by the specified DnsQuestion.
final 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.
Promise<List<T>>	InflightNameResolver.resolveAll(String inetHost, Promise<List<T>> promise)
private void	DnsNameResolver.resolveAllNow(ChannelFuture f, String hostname, DnsQuestion question, DnsRecord[] additionals, Promise<List<DnsRecord>> promise)
private void	DnsNameResolver.resolveNow(Channel channel, String hostname, DnsRecord[] additionals, Promise<?> originalPromise, Promise<List<InetAddress>> promise, DnsCache resolveCache, boolean completeEarlyIfPossible)
private static <T> void	InflightNameResolver.transferResult(Future<T> src, Promise<T> dst)
private static void	DnsNameResolver.tryFailure(Promise<?> promise, Throwable cause)
(package private) static <T> boolean	DnsNameResolver.trySuccess(Promise<T> promise, T result)
private void	DnsResolveContext.tryToFinishResolve(DnsServerAddressStream nameServerAddrStream, int nameServerAddrStreamIndex, DnsQuestion question, DnsQueryLifecycleObserver queryLifecycleObserver, Promise<List<T>> promise, Throwable cause)

Method parameters in io.netty.resolver.dns with type arguments of type Promise

Modifier and Type	Method	Description
private <U> Promise<U>	InflightNameResolver.resolve(ConcurrentMap<String,Promise<U>> resolveMap, String inetHost, Promise<U> promise, boolean resolveAll)

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

Modifier	Constructor	Description
(package private)	DatagramDnsQueryContext(Channel channel, InetSocketAddress nameServerAddr, DnsQueryContextManager queryContextManager, int maxPayLoadSize, boolean recursionDesired, long queryTimeoutMillis, DnsQuestion question, DnsRecord[] additionals, Promise<AddressedEnvelope<DnsResponse,InetSocketAddress>> promise, Bootstrap socketBootstrap, boolean retryWithTcpOnTimeout)
(package private)	DnsAddressResolveContext(DnsNameResolver parent, Channel channel, Promise<?> originalPromise, String hostname, DnsRecord[] additionals, DnsServerAddressStream nameServerAddrs, int allowedQueries, DnsCache resolveCache, AuthoritativeDnsServerCache authoritativeDnsServerCache, boolean completeEarlyIfPossible)
(package private)	DnsQueryContext(Channel channel, InetSocketAddress nameServerAddr, DnsQueryContextManager queryContextManager, int maxPayLoadSize, boolean recursionDesired, long queryTimeoutMillis, DnsQuestion question, DnsRecord[] additionals, Promise<AddressedEnvelope<DnsResponse,InetSocketAddress>> promise, Bootstrap socketBootstrap, boolean retryWithTcpOnTimeout)
(package private)	DnsRecordResolveContext(DnsNameResolver parent, Channel channel, Promise<?> originalPromise, DnsQuestion question, DnsRecord[] additionals, DnsServerAddressStream nameServerAddrs, int allowedQueries)
private	DnsRecordResolveContext(DnsNameResolver parent, Channel channel, Promise<?> originalPromise, String hostname, int dnsClass, DnsRecordType[] expectedTypes, DnsRecord[] additionals, DnsServerAddressStream nameServerAddrs, int allowedQueries)
(package private)	DnsResolveContext(DnsNameResolver parent, Channel channel, Promise<?> originalPromise, String hostname, int dnsClass, DnsRecordType[] expectedTypes, DnsRecord[] additionals, DnsServerAddressStream nameServerAddrs, int allowedQueries)
(package private)	TcpDnsQueryContext(Channel channel, InetSocketAddress nameServerAddr, DnsQueryContextManager queryContextManager, int maxPayLoadSize, boolean recursionDesired, long queryTimeoutMillis, DnsQuestion question, DnsRecord[] additionals, Promise<AddressedEnvelope<DnsResponse,InetSocketAddress>> promise)

Constructor parameters in io.netty.resolver.dns with type arguments of type Promise

Modifier	Constructor	Description
(package private)	InflightNameResolver(EventExecutor executor, NameResolver<T> delegate, ConcurrentMap<String,Promise<T>> resolvesInProgress, ConcurrentMap<String,Promise<List<T>>> resolveAllsInProgress)

Uses of Promise in io.netty.util

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

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 Promise in io.netty.util.concurrent

Subinterfaces of Promise in io.netty.util.concurrent

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

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

Modifier and Type	Class	Description
class	DefaultProgressivePromise<V>
class	DefaultPromise<V>
(package private) static class	ImmediateEventExecutor.ImmediateProgressivePromise<V>
(package private) static class	ImmediateEventExecutor.ImmediatePromise<V>
(package private) class	PromiseTask<V>
(package private) final class	ScheduledFutureTask<V>
private static final class	UnorderedThreadPoolEventExecutor.RunnableScheduledFutureTask<V>

Fields in io.netty.util.concurrent declared as Promise

Modifier and Type	Field	Description
private final Promise<?>	PromiseAggregator.aggregatePromise	Deprecated.
private Promise<Void>	PromiseCombiner.aggregatePromise
private final Promise<? super T>	UnaryPromiseNotifier.promise	Deprecated.
private final Promise<? super V>[]	PromiseNotifier.promises
private final Promise<?>	MultithreadEventExecutorGroup.terminationFuture
private final Promise<?>	SingleThreadEventExecutor.terminationFuture
private final Promise<?>	UnorderedThreadPoolEventExecutor.terminationFuture

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

Modifier and Type	Field	Description
private Set<Promise<V>>	PromiseAggregator.pendingPromises	Deprecated.

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

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

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

Modifier and Type	Method	Description
final PromiseAggregator<V,F>	PromiseAggregator.add(Promise<V>... promises)	Deprecated. Add the given Promises to the aggregator.
void	PromiseCombiner.add(Promise promise)	Deprecated. Replaced by PromiseCombiner.add(Future).
void	PromiseCombiner.addAll(Promise... promises)	Deprecated. Replaced by PromiseCombiner.addAll(Future[])
static <V, F extends Future<V>> F	PromiseNotifier.cascade(boolean logNotifyFailure, F future, Promise<? super V> promise)	Link the Future and Promise such that if the Future completes the Promise will be notified.
static <V, F extends Future<V>> F	PromiseNotifier.cascade(F future, Promise<? super V> promise)	Link the Future and Promise such that if the Future completes the Promise will be notified.
static <X> void	UnaryPromiseNotifier.cascadeTo(Future<X> completedFuture, Promise<? super X> promise)	Deprecated.
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

Modifier	Constructor	Description
	PromiseAggregator(Promise<Void> aggregatePromise)	Deprecated. See 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)	Deprecated.

Uses of Promise in io.netty.util.internal

Fields in io.netty.util.internal declared as Promise

Modifier and Type	Field	Description
private Promise<Void>	PendingWrite.promise

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

Modifier and Type	Method	Description
Promise<Void>	PendingWrite.promise()
Promise<Void>	PendingWrite.recycleAndGet()	Recycle this instance and return the Promise.

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

Modifier and Type	Method	Description
static PendingWrite	PendingWrite.newInstance(Object msg, Promise<Void> promise)	Create a new empty RecyclableArrayList instance
static void	PromiseNotificationUtil.tryCancel(Promise<?> p, InternalLogger logger)	Try to cancel the Promise and log if logger is not null in case this fails.
static void	PromiseNotificationUtil.tryFailure(Promise<?> p, Throwable cause, InternalLogger logger)	Try to mark the Promise as failure and log if logger is not null in case this fails.
static <V> void	PromiseNotificationUtil.trySuccess(Promise<? super V> p, V result, InternalLogger logger)	Try to mark the Promise as success and log if logger is not null in case this fails.