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.
io.netty.util.internal	Internal-use-only utilities which is not allowed to be used outside Netty.

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
class	DefaultChannelProgressivePromise	The default ChannelProgressivePromise implementation.
class	DefaultChannelPromise	The default ChannelPromise implementation.
class	DelegatingChannelPromiseNotifier
class	VoidChannelPromise

Uses of Promise in io.netty.channel.pool

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)
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)

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	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.ssl

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

Modifier and Type	Method	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	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.
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)
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

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

Modifier and Type	Method	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, 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.
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, 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, 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	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>

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.
Promise<V>	DefaultPromise.setSuccess(V result)
Promise<V>	Promise.setSuccess(V result)	Marks this future as a success and notifies all listeners.
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
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

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

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.