## Uses of Interface
org.apache.ignite.lang.IgniteFuture

Packages that use IgniteFuture
Package | Description
--- | ---
org.apache.ignite | Contains entry-point Ignite & HPC APIs.
org.apache.ignite.cluster | Contains cluster-related classes.
org.apache.ignite.compute | Contains Compute Grid functionality.
org.apache.ignite.internal | Contains main implementation.
org.apache.ignite.internal.cluster |
org.apache.ignite.internal.managers | TODO.
org.apache.ignite.internal.managers.deployment | TODO.
org.apache.ignite.internal.processors | TODO.
org.apache.ignite.internal.processors.cache |
org.apache.ignite.internal.processors.cache.binary | Implementation of binary processor.
org.apache.ignite.internal.processors.cache.distributed |
org.apache.ignite.internal.processors.cache.dr |
org.apache.ignite.internal.processors.cache.query |
org.apache.ignite.internal.processors.cache.transactions |
org.apache.ignite.internal.processors.cluster |
org.apache.ignite.internal.processors.continuous |
org.apache.ignite.internal.processors.datastreamer | Data streamer processor.
org.apache.ignite.internal.processors.igfs | Contains high performance file system processor.
org.apache.ignite.internal.processors.marshaller |
org.apache.ignite.internal.processors.platform |
org.apache.ignite.internal.processors.platform.utils |
org.apache.ignite.internal.processors.query |
org.apache.ignite.internal.processors.service |
org.apache.ignite.internal.processors.task | TODO.
org.apache.ignite.internal.util.future | Future related classes.
org.apache.ignite.internal.util.typedef | Contains typedefs definitions for frequently used classes.
org.apache.ignite.lang | Contains general language constructs and functional APIs for distributed computations.
org.apache.ignite.scheduler | Contains Job Scheduling functionality.
org.apache.ignite.spi | Contains common classes and interfaces for SPI implementations.
org.apache.ignite.spi.communication.tcp | Contains default TCP/IP-based implementation for communication SPI.
org.apache.ignite.transactions | Contains transaction-related classes.

### Uses of IgniteFuture in org.apache.ignite

Methods in org.apache.ignite that return IgniteFuture
Modifier and Type | Method and Description
--- | ---
`IgniteFuture<?>` | IgniteDataStreamer.`addData(Collection<? extends Map.Entry<K,V>> entries)` Adds data for streaming on remote node.
`IgniteFuture<?>` | IgniteDataStreamer.`addData(K key, V val)` Adds data for streaming on remote node.
`IgniteFuture<?>` | IgniteDataStreamer.`addData(Map.Entry<K,V> entry)` Adds data for streaming on remote node.
`IgniteFuture<?>` | IgniteDataStreamer.`addData(Map<K,V> entries)` Adds data for streaming on remote node.
`<R> IgniteFuture<R>` | IgniteCompute.`affinityCallAsync(Collection<String> cacheNames, int partId, IgniteCallable<R> job)` Executes given job asynchronously on the node where partition is located (the partition is primary on the node) The data of the partition will not be migrated from the target node while the job is executed.
`<R> IgniteFuture<R>` | IgniteCompute.`affinityCallAsync(Collection<String> cacheNames, Object affKey, IgniteCallable<R> job)` Executes given job asynchronously on the node where data for provided affinity key is located (a.k.a. affinity co-location).
`<R> IgniteFuture<R>` | IgniteCompute.`affinityCallAsync(String cacheName, Object affKey, IgniteCallable<R> job)` Executes given job asynchronously on the node where data for provided affinity key is located (a.k.a. affinity co-location).
`IgniteFuture<Void>` | IgniteCompute.`affinityRunAsync(Collection<String> cacheNames, int partId, IgniteRunnable job)` Executes given job asynchronously on the node where partition is located (the partition is primary on the node) The data of the partition will not be migrated from the target node while the job is executed.
`IgniteFuture<Void>` | IgniteCompute.`affinityRunAsync(Collection<String> cacheNames, Object affKey, IgniteRunnable job)` Executes given job asynchronously on the node where data for provided affinity key is located (a.k.a. affinity co-location).
`IgniteFuture<Void>` | IgniteCompute.`affinityRunAsync(String cacheName, Object affKey, IgniteRunnable job)` Executes given job asynchronously on the node where data for provided affinity key is located (a.k.a. affinity co-location).
`<T,R> IgniteFuture<Collection<R>>` | IgniteCompute.`applyAsync(IgniteClosure<T,R> job, Collection<? extends T> args)` Executes provided closure job asynchronously on nodes within the underlying cluster group.
`<R,T> IgniteFuture<R>` | IgniteCompute.`applyAsync(IgniteClosure<T,R> job, T arg)` Executes provided closure job asynchronously on a node within the underlying cluster group.
`<R1,R2,T> IgniteFuture<R2>` | IgniteCompute.`applyAsync(IgniteClosure<T,R1> job, Collection<? extends T> args, IgniteReducer<R1,R2> rdc)` Executes provided closure job asynchronously on nodes within the underlying cluster group.
`<R> IgniteFuture<Collection<R>>` | IgniteCompute.`broadcastAsync(IgniteCallable<R> job)` Broadcasts given job asynchronously to all nodes in cluster group.
`<R,T> IgniteFuture<Collection<R>>` | IgniteCompute.`broadcastAsync(IgniteClosure<T,R> job, T arg)` Broadcasts given closure job asynchronously with passed in argument to all nodes in the cluster group.
`IgniteFuture<Void>` | IgniteCompute.`broadcastAsync(IgniteRunnable job)` Broadcasts given job asynchronously to all nodes in the cluster group.
`<R> IgniteFuture<Collection<R>>` | IgniteCompute.`callAsync(Collection<? extends IgniteCallable<R>> jobs)` Executes collection of jobs asynchronously on nodes within the underlying cluster group.
`<R1,R2> IgniteFuture<R2>` | IgniteCompute.`callAsync(Collection<? extends IgniteCallable<R1>> jobs, IgniteReducer<R1,R2> rdc)` Executes collection of jobs asynchronously on nodes within the underlying cluster group.
`<R> IgniteFuture<R>` | IgniteCompute.`callAsync(IgniteCallable<R> job)` Executes provided job asynchronously on a node within the underlying cluster group.
`<R> IgniteFuture<R>` | IgniteScheduler.`callLocal(Callable<R> c)` Executes given callable on internal system thread pool asynchronously.
`IgniteFuture<Void>` | IgniteServices.`cancelAllAsync()` Asynchronously cancels all deployed services.
`IgniteFuture<Void>` | IgniteServices.`cancelAsync(String name)` Asynchronously cancels service deployment.
`IgniteFuture<Void>` | IgniteCache.`clearAllAsync(Set<? extends K> keys)` Asynchronously clears entries from the cache and swap storage, without notifying listeners or `CacheWriter`s.
`IgniteFuture<Void>` | IgniteCache.`clearAsync()` Asynchronously clears the contents of the cache, without notifying listeners or `CacheWriter`s.
`IgniteFuture<Void>` | IgniteFileSystem.`clearAsync()` Formats the file system removing all existing entries from it, but not removing anything in secondary file system (if any).
`IgniteFuture<Void>` | IgniteCache.`clearAsync(K key)` Asynchronously clears entry from the cache and swap storage, without notifying listeners or `CacheWriter`s.
`IgniteFuture<?>` | IgniteCluster.`clientReconnectFuture()` If local client node disconnected from cluster returns future that will be completed when client reconnected.
`IgniteFuture<Boolean>` | IgniteCache.`containsKeyAsync(K key)` Asynchronously determines if the `Cache` contains an entry for the specified key.
`IgniteFuture<Boolean>` | IgniteCache.`containsKeysAsync(Set<? extends K> keys)` Asynchronously determines if the `Cache` contains entries for the specified keys.
`IgniteFuture<Void>` | IgniteServices.`deployAsync(ServiceConfiguration cfg)` Asynchronously deploys multiple instances of the service on the grid according to provided configuration.
`IgniteFuture<Void>` | IgniteServices.`deployClusterSingletonAsync(String name, Service svc)` Asynchronously deploys a cluster-wide singleton service.
`IgniteFuture<Void>` | IgniteServices.`deployKeyAffinitySingletonAsync(String name, Service svc, String cacheName, Object affKey)` Asynchronously deploys one instance of this service on the primary node for a given affinity key.
`IgniteFuture<Void>` | IgniteServices.`deployMultipleAsync(String name, Service svc, int totalCnt, int maxPerNodeCnt)` Asynchronously deploys multiple instances of the service on the grid.
`IgniteFuture<Void>` | IgniteServices.`deployNodeSingletonAsync(String name, Service svc)` Asynchronously deploys a per-node singleton service.
`<T,R> IgniteFuture<R>` | IgniteFileSystem.`executeAsync(Class<? extends IgfsTask<T,R>> taskCls, IgfsRecordResolver rslvr, Collection<IgfsPath> paths, boolean skipNonExistentFiles, long maxRangeLen, T arg)` Executes IGFS task asynchronously with overridden maximum range length (see `FileSystemConfiguration.getMaximumTaskRangeLength()` for more information).
`<T,R> IgniteFuture<R>` | IgniteFileSystem.`executeAsync(Class<? extends IgfsTask<T,R>> taskCls, IgfsRecordResolver rslvr, Collection<IgfsPath> paths, T arg)` Executes IGFS task asynchronously.
`<T,R> IgniteFuture<R>` | IgniteFileSystem.`executeAsync(IgfsTask<T,R> task, IgfsRecordResolver rslvr, Collection<IgfsPath> paths, boolean skipNonExistentFiles, long maxRangeLen, T arg)` Executes IGFS task asynchronously with overridden maximum range length (see `FileSystemConfiguration.getMaximumTaskRangeLength()` for more information).
`<T,R> IgniteFuture<R>` | IgniteFileSystem.`executeAsync(IgfsTask<T,R> task, IgfsRecordResolver rslvr, Collection<IgfsPath> paths, T arg)` Executes IGFS task asynchronously.
`IgniteFuture<?>` | IgniteDataStreamer.`future()` Gets future for this streaming process.
`IgniteFuture<Map<K,V>>` | IgniteCache.`getAllAsync(Set<? extends K> keys)` Asynchronously gets a collection of entries from the `Cache`, returning them as `Map` of the values associated with the set of keys requested.
`IgniteFuture<Map<K,V>>` | IgniteCache.`getAllOutTxAsync(Set<? extends K> keys)` Asynchronously gets values from cache.
`IgniteFuture<V>` | IgniteCache.`getAndPutAsync(K key, V val)` Asynchronously associates the specified value with the specified key in this cache, returning an existing value if one existed as the future result.
`IgniteFuture<V>` | IgniteCache.`getAndPutIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteFuture<V>` | IgniteCache.`getAndRemoveAsync(K key)` Asynchronously removes the entry for a key only if currently mapped to some value.
`IgniteFuture<V>` | IgniteCache.`getAndReplaceAsync(K key, V val)` Asynchronously replaces the value for a given key if and only if there is a value currently mapped by the key.
`IgniteFuture<V>` | IgniteCache.`getAsync(K key)` Asynchronously gets an entry from the cache.
`IgniteFuture<Collection<CacheEntry<K,V>>>` | IgniteCache.`getEntriesAsync(Set<? extends K> keys)` Asynchronously gets a collection of entries from the `Cache`.
`IgniteFuture<CacheEntry<K,V>>` | IgniteCache.`getEntryAsync(K key)` Asynchronously gets an entry from the cache.
`IgniteFuture<?>` | IgniteCache.`indexReadyFuture()` Returns future that will be completed when all indexes for this cache are ready to use.
`<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | IgniteCache.`invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)` Asynchronously version of the `IgniteCache.invokeAll(Set, EntryProcessor, Object...)` method.
`<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | IgniteCache.`invokeAllAsync(Set<? extends K> keys, CacheEntryProcessor<K,V,T> entryProcessor, Object... args)` Asynchronously invokes an `CacheEntryProcessor` against the set of `Cache.Entry`s specified by the set of keys.
`<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | IgniteCache.`invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)` Asynchronously invokes an `EntryProcessor` against the set of `Cache.Entry`s specified by the set of keys.
`<T> IgniteFuture<T>` | IgniteCache.`invokeAsync(K key, CacheEntryProcessor<K,V,T> entryProcessor, Object... arguments)` Asynchronously invokes an `CacheEntryProcessor` against the `Cache.Entry` specified by the provided key.
`<T> IgniteFuture<T>` | IgniteCache.`invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... arguments)` Asynchronously invokes an `EntryProcessor` against the `Cache.Entry` specified by the provided key.
`IgniteFuture<Void>` | IgniteCache.`loadCacheAsync(IgniteBiPredicate<K,V> p, Object... args)` Asynchronously executes `IgniteCache.localLoadCache(IgniteBiPredicate, Object...)` on all cache nodes.
`IgniteFuture<Void>` | IgniteCache.`localLoadCacheAsync(IgniteBiPredicate<K,V> p, Object... args)` Asynchronously loads state from the underlying persistent storage by delegating to `CacheStore.loadCache(IgniteBiInClosure,Object...)` method.
`IgniteFuture<Void>` | IgniteCache.`putAllAsync(Map<? extends K,? extends V> map)` Asynchronously copies all of the entries from the specified map to the `Cache`.
`IgniteFuture<Void>` | IgniteCache.`putAsync(K key, V val)` Asynchronously associates the specified value with the specified key in the cache.
`IgniteFuture<Boolean>` | IgniteCache.`putIfAbsentAsync(K key, V val)` Asynchronously associates the specified key with the given value if it is not already associated with a value.
`IgniteFuture<?>` | IgniteCache.`rebalance()` This cache node to re-balance its partitions.
`IgniteFuture<?>` | IgniteClientDisconnectedException.`reconnectFuture()`
`<T extends Event> IgniteFuture<UUID>` | IgniteEvents.`remoteListenAsync(IgniteBiPredicate<UUID,T> locLsnr, IgnitePredicate<T> rmtFilter, int... types)` Asynchronously adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well).
`<T extends Event> IgniteFuture<UUID>` | IgniteEvents.`remoteListenAsync(int bufSize, long interval, boolean autoUnsubscribe, IgniteBiPredicate<UUID,T> locLsnr, IgnitePredicate<T> rmtFilter, int... types)` Asynchronously adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well).
`IgniteFuture<UUID>` | IgniteMessaging.`remoteListenAsync(Object topic, IgniteBiPredicate<UUID,?> p)` Asynchronously adds a message listener for a given topic to all nodes in the cluster group (possibly including this node if it belongs to the cluster group as well).
`<T extends Event> IgniteFuture<List<T>>` | IgniteEvents.`remoteQueryAsync(IgnitePredicate<T> p, long timeout, int... types)` Asynchronously queries nodes in this cluster group for events using passed in predicate filter for event selection.
`IgniteFuture<Void>` | IgniteCache.`removeAllAsync()` Asynchronously removes all of the mappings from this cache.
`IgniteFuture<Void>` | IgniteCache.`removeAllAsync(Set<? extends K> keys)` Asynchronously removes entries for the specified keys.
`IgniteFuture<Boolean>` | IgniteCache.`removeAsync(K key)` Asynchronously removes the mapping for a key from this cache if it is present.
`IgniteFuture<Boolean>` | IgniteCache.`removeAsync(K key, V oldVal)` Asynchronously removes the mapping for a key only if currently mapped to the given value.
`IgniteFuture<?>` | IgniteDataStreamer.`removeData(K key)` Adds key for removal on remote node.
`IgniteFuture<Boolean>` | IgniteCache.`replaceAsync(K key, V val)` Asynchronously replaces the entry for a key only if currently mapped to a given value.
`IgniteFuture<Boolean>` | IgniteCache.`replaceAsync(K key, V oldVal, V newVal)` Asynchronous version of the `IgniteCache.replace(Object, Object, Object)`.
`IgniteFuture<Void>` | IgniteCompute.`runAsync(Collection<? extends IgniteRunnable> jobs)` Executes collection of jobs asynchronously on grid nodes within the underlying cluster group.
`IgniteFuture<Void>` | IgniteCompute.`runAsync(IgniteRunnable job)` Executes provided job asynchronously on a node within the underlying cluster group.
`IgniteFuture<?>` | IgniteScheduler.`runLocal(Runnable r)` Executes given closure on internal system thread pool asynchronously.
`IgniteFuture<Integer>` | IgniteCache.`sizeAsync(CachePeekMode... peekModes)` Asynchronously gets the number of all entries cached across all nodes.
`IgniteFuture<Long>` | IgniteCache.`sizeLongAsync(CachePeekMode... peekModes)` Asynchronously gets the number of all entries cached across all nodes as a long value.
`IgniteFuture<Long>` | IgniteCache.`sizeLongAsync(int partition, CachePeekMode... peekModes)` Asynchronously gets the number of all entries cached in a partition as a long value.
`IgniteFuture<Collection<ClusterStartNodeResult>>` | IgniteCluster.`startNodesAsync(Collection<Map<String,Object>> hosts, Map<String,Object> dflts, boolean restart, int timeout, int maxConn)` Starts one or more nodes on remote host(s) asynchronously.
`IgniteFuture<Collection<ClusterStartNodeResult>>` | IgniteCluster.`startNodesAsync(File file, boolean restart, int timeout, int maxConn)` Starts one or more nodes on remote host(s) asynchronously.
`IgniteFuture<Void>` | IgniteMessaging.`stopRemoteListenAsync(UUID opId)` Asynchronously unregisters all listeners identified with provided operation ID on all nodes in the cluster group.
`IgniteFuture<Void>` | IgniteEvents.`stopRemoteListenAsync(UUID opId)` Asynchronously stops listening to remote events.
`<T extends Event> IgniteFuture<T>` | IgniteEvents.`waitForLocalAsync(IgnitePredicate<T> filter, int... types)` Create future to wait for the specified events.

Constructors in org.apache.ignite with parameters of type IgniteFuture
Constructor and Description
`IgniteClientDisconnectedException(IgniteFuture<?> reconnectFut, String msg)`
`IgniteClientDisconnectedException(IgniteFuture<?> reconnectFut, String msg, Throwable cause)`

### Uses of IgniteFuture in org.apache.ignite.cluster

Methods in org.apache.ignite.cluster that return IgniteFuture
Modifier and Type | Method and Description
--- | ---
`IgniteFuture<?>` | ClusterTopologyException.`retryReadyFuture()`

Methods in org.apache.ignite.cluster with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | ClusterTopologyException.`retryReadyFuture(IgniteFuture<?> readyFut)`

### Uses of IgniteFuture in org.apache.ignite.compute

Subinterfaces of IgniteFuture in org.apache.ignite.compute
Modifier and Type | Interface and Description
--- | ---
`interface` | `ComputeTaskFuture<R>` This class defines a handler for asynchronous task execution.

Methods in org.apache.ignite.compute that return IgniteFuture
Modifier and Type | Method and Description
--- | ---
`IgniteFuture<?>` | ComputeTaskSession.`mapFuture()` Gets future that will be completed when task "`map`" step has completed (which means that `ComputeTask.map(List, Object)` method has finished).

### Uses of IgniteFuture in org.apache.ignite.internal

Fields in org.apache.ignite.internal with type parameters of type IgniteFuture
Modifier and Type | Field and Description
--- | ---
`protected ThreadLocal<IgniteFuture<?>>` | AsyncSupportAdapter.`curFut` Future for previous asynchronous operation.

Methods in org.apache.ignite.internal that return IgniteFuture
Modifier and Type | Method and Description
--- | ---
`<R> IgniteFuture<R>` | IgniteComputeImpl.`affinityCallAsync(Collection<String> cacheNames, int partId, IgniteCallable<R> job)` Executes given job asynchronously on the node where partition is located (the partition is primary on the node) The data of the partition will not be migrated from the target node while the job is executed.
`<R> IgniteFuture<R>` | IgniteComputeImpl.`affinityCallAsync(Collection<String> cacheNames, Object affKey, IgniteCallable<R> job)` Executes given job asynchronously on the node where data for provided affinity key is located (a.k.a. affinity co-location).
`<R> IgniteFuture<R>` | IgniteComputeImpl.`affinityCallAsync(String cacheName, Object affKey, IgniteCallable<R> job)` Executes given job asynchronously on the node where data for provided affinity key is located (a.k.a. affinity co-location).
`IgniteFuture<Void>` | IgniteComputeImpl.`affinityRunAsync(Collection<String> cacheNames, int partId, IgniteRunnable job)` Executes given job asynchronously on the node where partition is located (the partition is primary on the node) The data of the partition will not be migrated from the target node while the job is executed.
`IgniteFuture<Void>` | IgniteComputeImpl.`affinityRunAsync(Collection<String> cacheNames, Object affKey, IgniteRunnable job)` Executes given job asynchronously on the node where data for provided affinity key is located (a.k.a. affinity co-location).
`IgniteFuture<Void>` | IgniteComputeImpl.`affinityRunAsync(String cacheName, Object affKey, IgniteRunnable job)` Executes given job asynchronously on the node where data for provided affinity key is located (a.k.a. affinity co-location).
`<T,R> IgniteFuture<Collection<R>>` | IgniteComputeImpl.`applyAsync(IgniteClosure<T,R> job, Collection<? extends T> args)` Executes provided closure job asynchronously on nodes within the underlying cluster group.
`<R,T> IgniteFuture<R>` | IgniteComputeImpl.`applyAsync(IgniteClosure<T,R> job, T arg)` Executes provided closure job asynchronously on a node within the underlying cluster group.
`<R1,R2,T> IgniteFuture<R2>` | IgniteComputeImpl.`applyAsync(IgniteClosure<T,R1> job, Collection<? extends T> args, IgniteReducer<R1,R2> rdc)` Executes provided closure job asynchronously on nodes within the underlying cluster group.
`<R> IgniteFuture<Collection<R>>` | IgniteComputeImpl.`broadcastAsync(IgniteCallable<R> job)` Broadcasts given job asynchronously to all nodes in cluster group.
`<R,T> IgniteFuture<Collection<R>>` | IgniteComputeImpl.`broadcastAsync(IgniteClosure<T,R> job, T arg)` Broadcasts given closure job asynchronously with passed in argument to all nodes in the cluster group.
`IgniteFuture<Void>` | IgniteComputeImpl.`broadcastAsync(IgniteRunnable job)` Broadcasts given job asynchronously to all nodes in the cluster group.
`<R> IgniteFuture<Collection<R>>` | IgniteComputeImpl.`callAsync(Collection<? extends IgniteCallable<R>> jobs)` Executes collection of jobs asynchronously on nodes within the underlying cluster group.
`<R1,R2> IgniteFuture<R2>` | IgniteComputeImpl.`callAsync(Collection<? extends IgniteCallable<R1>> jobs, IgniteReducer<R1,R2> rdc)` Executes collection of jobs asynchronously on nodes within the underlying cluster group.
`<R> IgniteFuture<R>` | IgniteComputeImpl.`callAsync(IgniteCallable<R> job)` Executes provided job asynchronously on a node within the underlying cluster group.
`<R> IgniteFuture<R>` | IgniteSchedulerImpl.`callLocal(Callable<R> c)` Executes given callable on internal system thread pool asynchronously.
`IgniteFuture<Void>` | IgniteServicesImpl.`cancelAllAsync()` Asynchronously cancels all deployed services.
`IgniteFuture<Void>` | IgniteServicesImpl.`cancelAsync(String name)` Asynchronously cancels service deployment.
`protected <R> IgniteFuture<R>` | IgniteComputeImpl.`createFuture(IgniteInternalFuture<R> fut)`
`protected <R> IgniteFuture<R>` | AsyncSupportAdapter.`createFuture(IgniteInternalFuture<R> fut)`
`IgniteFuture<Void>` | IgniteServicesImpl.`deployAsync(ServiceConfiguration cfg)` Asynchronously deploys multiple instances of the service on the grid according to provided configuration.
`IgniteFuture<Void>` | IgniteServicesImpl.`deployClusterSingletonAsync(String name, Service svc)` Asynchronously deploys a cluster-wide singleton service.
`IgniteFuture<Void>` | IgniteServicesImpl.`deployKeyAffinitySingletonAsync(String name, Service svc, String cacheName, Object affKey)` Asynchronously deploys one instance of this service on the primary node for a given affinity key.
`IgniteFuture<Void>` | IgniteServicesImpl.`deployMultipleAsync(String name, Service svc, int totalCnt, int maxPerNodeCnt)` Asynchronously deploys multiple instances of the service on the grid.
`IgniteFuture<Void>` | IgniteServicesImpl.`deployNodeSingletonAsync(String name, Service svc)` Asynchronously deploys a per-node singleton service.
`<R> IgniteFuture<R>` | AsyncSupportAdapter.`future()` Gets and resets future for previous asynchronous operation.
`<R> IgniteFuture<R>` | AsyncSupportAdapter.`future(boolean reset)` Gets and optionally resets future for previous asynchronous operation.
`IgniteFuture<?>` | GridJobSessionImpl.`mapFuture()` Gets future that will be completed when task "`map`" step has completed (which means that `ComputeTask.map(List, Object)` method has finished).
`IgniteFuture<?>` | GridTaskSessionImpl.`mapFuture()` Gets future that will be completed when task "`map`" step has completed (which means that `ComputeTask.map(List, Object)` method has finished).
`IgniteFuture<?>` | IgniteClientDisconnectedCheckedException.`reconnectFuture()`
`<T extends Event> IgniteFuture<UUID>` | IgniteEventsImpl.`remoteListenAsync(IgniteBiPredicate<UUID,T> locLsnr, IgnitePredicate<T> rmtFilter, int... types)` Asynchronously adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well).
`<T extends Event> IgniteFuture<UUID>` | IgniteEventsImpl.`remoteListenAsync(int bufSize, long interval, boolean autoUnsubscribe, IgniteBiPredicate<UUID,T> locLsnr, IgnitePredicate<T> rmtFilter, int... types)` Asynchronously adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well).
`IgniteFuture<UUID>` | IgniteMessagingImpl.`remoteListenAsync(Object topic, IgniteBiPredicate<UUID,?> p)` Asynchronously adds a message listener for a given topic to all nodes in the cluster group (possibly including this node if it belongs to the cluster group as well).
`<T extends Event> IgniteFuture<List<T>>` | IgniteEventsImpl.`remoteQueryAsync(IgnitePredicate<T> p, long timeout, int... types)` Asynchronously queries nodes in this cluster group for events using passed in predicate filter for event selection.
`IgniteFuture<Void>` | IgniteComputeImpl.`runAsync(Collection<? extends IgniteRunnable> jobs)` Executes collection of jobs asynchronously on grid nodes within the underlying cluster group.
`IgniteFuture<Void>` | IgniteComputeImpl.`runAsync(IgniteRunnable job)` Executes provided job asynchronously on a node within the underlying cluster group.
`IgniteFuture<?>` | IgniteSchedulerImpl.`runLocal(Runnable r)` Executes given closure on internal system thread pool asynchronously.
`IgniteFuture<Void>` | IgniteMessagingImpl.`stopRemoteListenAsync(UUID opId)` Asynchronously unregisters all listeners identified with provided operation ID on all nodes in the cluster group.
`IgniteFuture<Void>` | IgniteEventsImpl.`stopRemoteListenAsync(UUID opId)` Asynchronously stops listening to remote events.
`<T extends Event> IgniteFuture<T>` | IgniteEventsImpl.`waitForLocalAsync(IgnitePredicate<T> filter, int... types)` Create future to wait for the specified events.

Methods in org.apache.ignite.internal with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridComponent.`onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.
`void` | GridPluginComponent.`onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.

Constructors in org.apache.ignite.internal with parameters of type IgniteFuture
Constructor and Description
`IgniteClientDisconnectedCheckedException(IgniteFuture<?> reconnectFut, String msg)`

### Uses of IgniteFuture in org.apache.ignite.internal.cluster

Methods in org.apache.ignite.internal.cluster that return IgniteFuture
Modifier and Type | Method and Description
--- | ---
`IgniteFuture<?>` | IgniteClusterAsyncImpl.`clientReconnectFuture()` If local client node disconnected from cluster returns future that will be completed when client reconnected.
`IgniteFuture<?>` | IgniteClusterImpl.`clientReconnectFuture()` If local client node disconnected from cluster returns future that will be completed when client reconnected.
`<R> IgniteFuture<R>` | IgniteClusterImpl.`future()` Gets and resets future for previous asynchronous operation.
`IgniteFuture<Collection<ClusterStartNodeResult>>` | IgniteClusterAsyncImpl.`startNodesAsync(Collection<Map<String,Object>> hosts, Map<String,Object> dflts, boolean restart, int timeout, int maxConn)` Starts one or more nodes on remote host(s) asynchronously.
`IgniteFuture<Collection<ClusterStartNodeResult>>` | IgniteClusterImpl.`startNodesAsync(Collection<Map<String,Object>> hosts, Map<String,Object> dflts, boolean restart, int timeout, int maxConn)` Starts one or more nodes on remote host(s) asynchronously.
`IgniteFuture<Collection<ClusterStartNodeResult>>` | IgniteClusterAsyncImpl.`startNodesAsync(File file, boolean restart, int timeout, int maxConn)` Starts one or more nodes on remote host(s) asynchronously.
`IgniteFuture<Collection<ClusterStartNodeResult>>` | IgniteClusterImpl.`startNodesAsync(File file, boolean restart, int timeout, int maxConn)` Starts one or more nodes on remote host(s) asynchronously.

Methods in org.apache.ignite.internal.cluster with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | IgniteClusterImpl.`clientReconnectFuture(IgniteFuture<?> reconnecFut)`

### Uses of IgniteFuture in org.apache.ignite.internal.managers

Methods in org.apache.ignite.internal.managers with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridManagerAdapter.`onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.

### Uses of IgniteFuture in org.apache.ignite.internal.managers.deployment

Methods in org.apache.ignite.internal.managers.deployment with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridDeploymentManager.`onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.

### Uses of IgniteFuture in org.apache.ignite.internal.processors

Methods in org.apache.ignite.internal.processors with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridProcessorAdapter.`onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.

### Uses of IgniteFuture in org.apache.ignite.internal.processors.cache

Classes in org.apache.ignite.internal.processors.cache that implement IgniteFuture
Modifier and Type | Class and Description
--- | ---
`class` | `IgniteCacheFutureImpl<V>` Implementation of public API future for cache.

Methods in org.apache.ignite.internal.processors.cache that return IgniteFuture
Modifier and Type | Method and Description
--- | ---
`<T> IgniteFuture<T>` | IgniteCacheFutureImpl.`chain(IgniteClosure<? super IgniteFuture<V>,T> doneCb)` Make a chained future to convert result of this future (when complete) into a new format.
`IgniteFuture<Void>` | IgniteCacheProxy.`clearAllAsync(Set<? extends K> keys)` Asynchronously clears entries from the cache and swap storage, without notifying listeners or `CacheWriter`s.
`IgniteFuture<Void>` | IgniteCacheProxy.`clearAsync()` Asynchronously clears the contents of the cache, without notifying listeners or `CacheWriter`s.
`IgniteFuture<Void>` | IgniteCacheProxy.`clearAsync(K key)` Asynchronously clears entry from the cache and swap storage, without notifying listeners or `CacheWriter`s.
`IgniteFuture<Boolean>` | IgniteCacheProxy.`containsKeyAsync(K key)` Asynchronously determines if the `Cache` contains an entry for the specified key.
`IgniteFuture<Boolean>` | IgniteCacheProxy.`containsKeysAsync(Set<? extends K> keys)` Asynchronously determines if the `Cache` contains entries for the specified keys.
`protected <R> IgniteFuture<R>` | IgniteCacheProxy.`createFuture(IgniteInternalFuture<R> fut)`
`IgniteFuture<Map<K,V>>` | IgniteCacheProxy.`getAllAsync(Set<? extends K> keys)` Asynchronously gets a collection of entries from the `Cache`, returning them as `Map` of the values associated with the set of keys requested.
`IgniteFuture<Map<K,V>>` | IgniteCacheProxy.`getAllOutTxAsync(Set<? extends K> keys)` Asynchronously gets values from cache.
`IgniteFuture<V>` | IgniteCacheProxy.`getAndPutAsync(K key, V val)` Asynchronously associates the specified value with the specified key in this cache, returning an existing value if one existed as the future result.
`IgniteFuture<V>` | IgniteCacheProxy.`getAndPutIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteFuture<V>` | IgniteCacheProxy.`getAndRemoveAsync(K key)` Asynchronously removes the entry for a key only if currently mapped to some value.
`IgniteFuture<V>` | IgniteCacheProxy.`getAndReplaceAsync(K key, V val)` Asynchronously replaces the value for a given key if and only if there is a value currently mapped by the key.
`IgniteFuture<V>` | IgniteCacheProxy.`getAsync(K key)` Asynchronously gets an entry from the cache.
`IgniteFuture<Collection<CacheEntry<K,V>>>` | IgniteCacheProxy.`getEntriesAsync(Set<? extends K> keys)` Asynchronously gets a collection of entries from the `Cache`.
`IgniteFuture<CacheEntry<K,V>>` | IgniteCacheProxy.`getEntryAsync(K key)` Asynchronously gets an entry from the cache.
`IgniteFuture<?>` | IgniteCacheProxy.`indexReadyFuture()` Returns future that will be completed when all indexes for this cache are ready to use.
`<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | IgniteCacheProxy.`invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)` Asynchronously version of the `IgniteCache.invokeAll(Set, EntryProcessor, Object...)` method.
`<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | IgniteCacheProxy.`invokeAllAsync(Set<? extends K> keys, CacheEntryProcessor<K,V,T> entryProcessor, Object... args)` Asynchronously invokes an `CacheEntryProcessor` against the set of `Cache.Entry`s specified by the set of keys.
`<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | IgniteCacheProxy.`invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)` Asynchronously invokes an `EntryProcessor` against the set of `Cache.Entry`s specified by the set of keys.
`<T> IgniteFuture<T>` | IgniteCacheProxy.`invokeAsync(K key, CacheEntryProcessor<K,V,T> entryProcessor, Object... args)` Asynchronously invokes an `CacheEntryProcessor` against the `Cache.Entry` specified by the provided key.
`<T> IgniteFuture<T>` | IgniteCacheProxy.`invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)` Asynchronously invokes an `EntryProcessor` against the `Cache.Entry` specified by the provided key.
`IgniteFuture<Void>` | IgniteCacheProxy.`loadCacheAsync(IgniteBiPredicate<K,V> p, Object... args)` Asynchronously executes `IgniteCache.localLoadCache(IgniteBiPredicate, Object...)` on all cache nodes.
`IgniteFuture<Void>` | IgniteCacheProxy.`localLoadCacheAsync(IgniteBiPredicate<K,V> p, Object... args)` Asynchronously loads state from the underlying persistent storage by delegating to `CacheStore.loadCache(IgniteBiInClosure,Object...)` method.
`IgniteFuture<Void>` | IgniteCacheProxy.`putAllAsync(Map<? extends K,? extends V> map)` Asynchronously copies all of the entries from the specified map to the `Cache`.
`IgniteFuture<Void>` | IgniteCacheProxy.`putAsync(K key, V val)` Asynchronously associates the specified value with the specified key in the cache.
`IgniteFuture<Boolean>` | IgniteCacheProxy.`putIfAbsentAsync(K key, V val)` Asynchronously associates the specified key with the given value if it is not already associated with a value.
`IgniteFuture<?>` | IgniteCacheProxy.`rebalance()` This cache node to re-balance its partitions.
`IgniteFuture<Void>` | IgniteCacheProxy.`removeAllAsync()` Asynchronously removes all of the mappings from this cache.
`IgniteFuture<Void>` | IgniteCacheProxy.`removeAllAsync(Set<? extends K> keys)` Asynchronously removes entries for the specified keys.
`IgniteFuture<Boolean>` | IgniteCacheProxy.`removeAsync(K key)` Asynchronously removes the mapping for a key from this cache if it is present.
`IgniteFuture<Boolean>` | IgniteCacheProxy.`removeAsync(K key, V oldVal)` Asynchronously removes the mapping for a key only if currently mapped to the given value.
`IgniteFuture<Boolean>` | IgniteCacheProxy.`replaceAsync(K key, V val)` Asynchronously replaces the entry for a key only if currently mapped to a given value.
`IgniteFuture<Boolean>` | IgniteCacheProxy.`replaceAsync(K key, V oldVal, V newVal)` Asynchronous version of the `IgniteCache.replace(Object, Object, Object)`.
`IgniteFuture<Integer>` | IgniteCacheProxy.`sizeAsync(CachePeekMode... peekModes)` Asynchronously gets the number of all entries cached across all nodes.
`IgniteFuture<Long>` | IgniteCacheProxy.`sizeLongAsync(CachePeekMode... peekModes)` Asynchronously gets the number of all entries cached across all nodes as a long value.
`IgniteFuture<Long>` | IgniteCacheProxy.`sizeLongAsync(int part, CachePeekMode... peekModes)` Asynchronously gets the number of all entries cached in a partition as a long value.

Methods in org.apache.ignite.internal.processors.cache with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridCacheMvccManager.`onDisconnected(IgniteFuture reconnectFut)`
`void` | GridCacheAffinityManager.`onDisconnected(IgniteFuture reconnectFut)`
`void` | GridCacheProcessor.`onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.
`void` | GridCacheSharedManager.`onDisconnected(IgniteFuture<?> reconnectFut)`
`void` | CacheOsConflictResolutionManager.`onDisconnected(IgniteFuture<?> reconnectFut)`
`void` | GridCacheSharedManagerAdapter.`onDisconnected(IgniteFuture<?> reconnectFut)`
`void` | GridCacheManagerAdapter.`onDisconnected(IgniteFuture<?> reconnectFut)`
`void` | GridCacheManager.`onDisconnected(IgniteFuture<?> reconnectFut)`
`void` | GridCacheGateway.`onDisconnected(IgniteFuture<?> reconnectFut)`

Method parameters in org.apache.ignite.internal.processors.cache with type arguments of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`<T> IgniteFuture<T>` | IgniteCacheFutureImpl.`chain(IgniteClosure<? super IgniteFuture<V>,T> doneCb)` Make a chained future to convert result of this future (when complete) into a new format.

### Uses of IgniteFuture in org.apache.ignite.internal.processors.cache.binary

Methods in org.apache.ignite.internal.processors.cache.binary with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | CacheObjectBinaryProcessorImpl.`onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.

### Uses of IgniteFuture in org.apache.ignite.internal.processors.cache.distributed

Methods in org.apache.ignite.internal.processors.cache.distributed with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridCacheTxFinishSync.`onDisconnected(IgniteFuture<?> reconnectFut)`

### Uses of IgniteFuture in org.apache.ignite.internal.processors.cache.dr

Methods in org.apache.ignite.internal.processors.cache.dr with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridOsCacheDrManager.`onDisconnected(IgniteFuture reconnectFut)`

### Uses of IgniteFuture in org.apache.ignite.internal.processors.cache.query

Methods in org.apache.ignite.internal.processors.cache.query with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridCacheDistributedQueryManager.`onDisconnected(IgniteFuture<?> reconnectFut)`

### Uses of IgniteFuture in org.apache.ignite.internal.processors.cache.transactions

Methods in org.apache.ignite.internal.processors.cache.transactions that return IgniteFuture
Modifier and Type | Method and Description
--- | ---
`IgniteFuture<Void>` | TransactionProxyImpl.`commitAsync()` Asynchronously commits this transaction by initiating `two-phase-commit` process.
`<R> IgniteFuture<R>` | TransactionProxyImpl.`future()` Gets and resets future for previous asynchronous operation.
`IgniteFuture<Void>` | TransactionProxyImpl.`rollbackAsync()` Asynchronously rolls back this transaction.

Methods in org.apache.ignite.internal.processors.cache.transactions with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | IgniteTxManager.`onDisconnected(IgniteFuture reconnectFut)`

### Uses of IgniteFuture in org.apache.ignite.internal.processors.cluster

Methods in org.apache.ignite.internal.processors.cluster that return IgniteFuture
Modifier and Type | Method and Description
--- | ---
`IgniteFuture<?>` | ClusterProcessor.`clientReconnectFuture()`

### Uses of IgniteFuture in org.apache.ignite.internal.processors.continuous

Methods in org.apache.ignite.internal.processors.continuous with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridContinuousProcessor.`onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.

### Uses of IgniteFuture in org.apache.ignite.internal.processors.datastreamer

Methods in org.apache.ignite.internal.processors.datastreamer that return IgniteFuture
Modifier and Type | Method and Description
--- | ---
`IgniteFuture<?>` | DataStreamerImpl.`addData(Collection<? extends Map.Entry<K,V>> entries)` Adds data for streaming on remote node.
`IgniteFuture<?>` | DataStreamerImpl.`addData(K key, V val)` Adds data for streaming on remote node.
`IgniteFuture<?>` | DataStreamerImpl.`addData(Map.Entry<K,V> entry)` Adds data for streaming on remote node.
`IgniteFuture<?>` | DataStreamerImpl.`addData(Map<K,V> entries)` Adds data for streaming on remote node.
`IgniteFuture<?>` | DataStreamerImpl.`addDataInternal(Collection<? extends DataStreamerEntry> entries)`
`IgniteFuture<?>` | DataStreamerImpl.`addDataInternal(KeyCacheObject key, CacheObject val)`
`IgniteFuture<?>` | DataStreamerImpl.`future()` Gets future for this streaming process.
`IgniteFuture<?>` | DataStreamerImpl.`removeData(K key)` Adds key for removal on remote node.
`IgniteFuture<?>` | DataStreamerImpl.`removeDataInternal(KeyCacheObject key)`

Methods in org.apache.ignite.internal.processors.datastreamer with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | DataStreamProcessor.`onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.
`void` | DataStreamerImpl.`onDisconnected(IgniteFuture<?> reconnectFut)`

### Uses of IgniteFuture in org.apache.ignite.internal.processors.igfs

Methods in org.apache.ignite.internal.processors.igfs that return IgniteFuture
Modifier and Type | Method and Description
--- | ---
`IgniteFuture<Void>` | IgfsImpl.`clearAsync()` Formats the file system removing all existing entries from it, but not removing anything in secondary file system (if any).
`IgniteFuture<Void>` | IgfsAsyncImpl.`clearAsync()` Formats the file system removing all existing entries from it, but not removing anything in secondary file system (if any).
`<T,R> IgniteFuture<R>` | IgfsImpl.`executeAsync(Class<? extends IgfsTask<T,R>> taskCls, IgfsRecordResolver rslvr, Collection<IgfsPath> paths, boolean skipNonExistentFiles, long maxRangeLen, T arg)` Executes IGFS task asynchronously with overridden maximum range length (see `FileSystemConfiguration.getMaximumTaskRangeLength()` for more information).
`<T,R> IgniteFuture<R>` | IgfsAsyncImpl.`executeAsync(Class<? extends IgfsTask<T,R>> taskCls, IgfsRecordResolver rslvr, Collection<IgfsPath> paths, boolean skipNonExistentFiles, long maxRangeLen, T arg)` Executes IGFS task asynchronously with overridden maximum range length (see `FileSystemConfiguration.getMaximumTaskRangeLength()` for more information).
`<T,R> IgniteFuture<R>` | IgfsImpl.`executeAsync(Class<? extends IgfsTask<T,R>> taskCls, IgfsRecordResolver rslvr, Collection<IgfsPath> paths, T arg)` Executes IGFS task asynchronously.
`<T,R> IgniteFuture<R>` | IgfsAsyncImpl.`executeAsync(Class<? extends IgfsTask<T,R>> taskCls, IgfsRecordResolver rslvr, Collection<IgfsPath> paths, T arg)` Executes IGFS task asynchronously.
`<T,R> IgniteFuture<R>` | IgfsImpl.`executeAsync(IgfsTask<T,R> task, IgfsRecordResolver rslvr, Collection<IgfsPath> paths, boolean skipNonExistentFiles, long maxRangeLen, T arg)` Executes IGFS task asynchronously with overridden maximum range length (see `FileSystemConfiguration.getMaximumTaskRangeLength()` for more information).
`<T,R> IgniteFuture<R>` | IgfsAsyncImpl.`executeAsync(IgfsTask<T,R> task, IgfsRecordResolver rslvr, Collection<IgfsPath> paths, boolean skipNonExistentFiles, long maxRangeLen, T arg)` Executes IGFS task asynchronously with overridden maximum range length (see `FileSystemConfiguration.getMaximumTaskRangeLength()` for more information).
`<T,R> IgniteFuture<R>` | IgfsImpl.`executeAsync(IgfsTask<T,R> task, IgfsRecordResolver rslvr, Collection<IgfsPath> paths, T arg)` Executes IGFS task asynchronously.
`<T,R> IgniteFuture<R>` | IgfsAsyncImpl.`executeAsync(IgfsTask<T,R> task, IgfsRecordResolver rslvr, Collection<IgfsPath> paths, T arg)` Executes IGFS task asynchronously.
`<R> IgniteFuture<R>` | IgfsImpl.`future()` Gets and resets future for previous asynchronous operation.

### Uses of IgniteFuture in org.apache.ignite.internal.processors.marshaller

Methods in org.apache.ignite.internal.processors.marshaller with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridMarshallerMappingProcessor.`onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.

### Uses of IgniteFuture in org.apache.ignite.internal.processors.platform

Methods in org.apache.ignite.internal.processors.platform that return IgniteFuture
Modifier and Type | Method and Description
--- | ---
`IgniteFuture` | PlatformAsyncResult.`future()` Async operation future.

Methods in org.apache.ignite.internal.processors.platform with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | PlatformProcessorImpl.`onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.
`protected PlatformListenable` | PlatformAbstractTarget.`readAndListenFuture(BinaryRawReader reader, IgniteFuture fut)` Reads future information and listens.
`protected PlatformListenable` | PlatformAbstractTarget.`readAndListenFuture(BinaryRawReader reader, IgniteFuture fut, PlatformFutureUtils.Writer writer)` Reads future information and listens.

### Uses of IgniteFuture in org.apache.ignite.internal.processors.platform.utils

Methods in org.apache.ignite.internal.processors.platform.utils with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`static PlatformListenable` | PlatformFutureUtils.`getListenable(IgniteFuture fut)` Gets the listenable.
`static PlatformListenable` | PlatformFutureUtils.`listen(PlatformContext ctx, IgniteFuture fut, long futPtr, int typ, PlatformFutureUtils.Writer writer, PlatformTarget target)` Listen future.
`static PlatformListenable` | PlatformFutureUtils.`listen(PlatformContext ctx, IgniteFuture fut, long futPtr, int typ, PlatformTarget target)` Listen future.

### Uses of IgniteFuture in org.apache.ignite.internal.processors.query

Methods in org.apache.ignite.internal.processors.query with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridQueryProcessor.`onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.
`void` | GridQueryIndexing.`onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.

### Uses of IgniteFuture in org.apache.ignite.internal.processors.service

Methods in org.apache.ignite.internal.processors.service with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridServiceProcessor.`onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.

### Uses of IgniteFuture in org.apache.ignite.internal.processors.task

Methods in org.apache.ignite.internal.processors.task with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridTaskProcessor.`onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.

### Uses of IgniteFuture in org.apache.ignite.internal.util.future

Classes in org.apache.ignite.internal.util.future that implement IgniteFuture
Modifier and Type | Class and Description
--- | ---
`class` | `IgniteFinishedFutureImpl<V>`
`class` | `IgniteFutureImpl<V>` Implementation of public API future.

Methods in org.apache.ignite.internal.util.future that return IgniteFuture
Modifier and Type | Method and Description
--- | ---
`<T> IgniteFuture<T>` | IgniteFutureImpl.`chain(IgniteClosure<? super IgniteFuture<V>,T> doneCb)` Make a chained future to convert result of this future (when complete) into a new format.

Method parameters in org.apache.ignite.internal.util.future with type arguments of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`<T> IgniteFuture<T>` | IgniteFutureImpl.`chain(IgniteClosure<? super IgniteFuture<V>,T> doneCb)` Make a chained future to convert result of this future (when complete) into a new format.
`protected <T> IgniteInternalFuture<T>` | IgniteFutureImpl.`chainInternal(IgniteClosure<? super IgniteFuture<V>,T> doneCb)`
`void` | IgniteFutureImpl.`listen(IgniteInClosure<? super IgniteFuture<V>> lsnr)` Registers listener closure to be asynchronously notified whenever future completes.

### Uses of IgniteFuture in org.apache.ignite.internal.util.typedef

Method parameters in org.apache.ignite.internal.util.typedef with type arguments of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`static void` | X.`waitAll(Iterable<IgniteFuture<?>> futs)` Synchronously waits for all futures in the collection.

### Uses of IgniteFuture in org.apache.ignite.lang

Methods in org.apache.ignite.lang that return IgniteFuture
Modifier and Type | Method and Description
--- | ---
`<T> IgniteFuture<T>` | IgniteFuture.`chain(IgniteClosure<? super IgniteFuture<V>,T> doneCb)` Make a chained future to convert result of this future (when complete) into a new format.

`<R> IgniteFuture<R>`

IgniteAsyncSupport.`future()`
Deprecated.
since 2.0. Please use new specialized async method e.g.

         IgniteFuture f = cache.getAsync();

instead of old-style async API:

         IgniteCache asyncCache = cache.withAsync();
         asyncCache.get(key);
         IgniteFuture fut = asyncCache.future();

Method parameters in org.apache.ignite.lang with type arguments of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`<T> IgniteFuture<T>` | IgniteFuture.`chain(IgniteClosure<? super IgniteFuture<V>,T> doneCb)` Make a chained future to convert result of this future (when complete) into a new format.
`void` | IgniteFuture.`listen(IgniteInClosure<? super IgniteFuture<V>> lsnr)` Registers listener closure to be asynchronously notified whenever future completes.

### Uses of IgniteFuture in org.apache.ignite.scheduler

Subinterfaces of IgniteFuture in org.apache.ignite.scheduler
Modifier and Type | Interface and Description
--- | ---
`interface` | `SchedulerFuture<R>` Future for cron-based scheduled execution.

### Uses of IgniteFuture in org.apache.ignite.spi

Methods in org.apache.ignite.spi with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | IgniteSpi.`onClientDisconnected(IgniteFuture<?> reconnectFut)` Client node disconnected callback.
`void` | IgniteSpiAdapter.`onClientDisconnected(IgniteFuture<?> reconnectFut)` Client node disconnected callback.

### Uses of IgniteFuture in org.apache.ignite.spi.communication.tcp

Methods in org.apache.ignite.spi.communication.tcp with parameters of type IgniteFuture
Modifier and Type | Method and Description
--- | ---
`void` | TcpCommunicationSpi.`onClientDisconnected(IgniteFuture<?> reconnectFut)` Client node disconnected callback.

### Uses of IgniteFuture in org.apache.ignite.transactions

Methods in org.apache.ignite.transactions that return IgniteFuture
Modifier and Type | Method and Description
--- | ---
`IgniteFuture<Void>` | Transaction.`commitAsync()` Asynchronously commits this transaction by initiating `two-phase-commit` process.
`IgniteFuture<Void>` | Transaction.`rollbackAsync()` Asynchronously rolls back this transaction.

2017 Copyright © Apache Software Foundation

Follow @ApacheIgnite

Ignite Fabric | : ver. 2.0.0
Release Date | : April 30 2017