## Uses of Interface
org.apache.ignite.internal.IgniteInternalFuture

Packages that use IgniteInternalFuture
Package | Description
--- | ---
org.apache.ignite.cache | Contains main Data Grid APIs.
org.apache.ignite.internal | Contains main implementation.
org.apache.ignite.internal.managers.discovery | TODO.
org.apache.ignite.internal.managers.eventstorage | TODO.
org.apache.ignite.internal.processors.affinity | Data affinity processor.
org.apache.ignite.internal.processors.cache |
org.apache.ignite.internal.processors.cache.distributed |
org.apache.ignite.internal.processors.cache.distributed.dht |
org.apache.ignite.internal.processors.cache.distributed.dht.atomic |
org.apache.ignite.internal.processors.cache.distributed.dht.colocated |
org.apache.ignite.internal.processors.cache.distributed.dht.preloader |
org.apache.ignite.internal.processors.cache.distributed.near |
org.apache.ignite.internal.processors.cache.local |
org.apache.ignite.internal.processors.cache.local.atomic |
org.apache.ignite.internal.processors.cache.query |
org.apache.ignite.internal.processors.cache.transactions |
org.apache.ignite.internal.processors.closure | TODO.
org.apache.ignite.internal.processors.continuous |
org.apache.ignite.internal.processors.dataload | Data loader processor.
org.apache.ignite.internal.processors.hadoop | Contains Hadoop APIs.
org.apache.ignite.internal.processors.igfs | Contains high performance file system processer.
org.apache.ignite.internal.processors.query |
org.apache.ignite.internal.processors.rest | REST processor.
org.apache.ignite.internal.processors.rest.handlers | REST commands handlers.
org.apache.ignite.internal.processors.rest.handlers.cache | REST in-memory data grid commands.
org.apache.ignite.internal.processors.rest.handlers.datastructures |
org.apache.ignite.internal.processors.rest.handlers.task |
org.apache.ignite.internal.processors.rest.handlers.top | REST topology commands.
org.apache.ignite.internal.processors.rest.handlers.version | REST version command.
org.apache.ignite.internal.processors.service |
org.apache.ignite.internal.processors.streamer | TODO.
org.apache.ignite.internal.util | System-wide utility routine and helper classes.
org.apache.ignite.internal.util.future | Future related classes.
org.apache.ignite.internal.util.lang |
org.apache.ignite.internal.util.worker | Common utility classes for threads.

### Uses of IgniteInternalFuture in org.apache.ignite.cache

Methods in org.apache.ignite.cache that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<?>` | GridCache.`forceRepartition()` Forces this cache node to re-balance its partitions.
`IgniteInternalFuture<?>` | GridCache.`loadCacheAsync(IgniteBiPredicate<K,V> p, long ttl, Object... args)` Asynchronously delegates to `CacheStore.loadCache(org.apache.ignite.lang.IgniteBiInClosure, Object...)` method to reload state from the underlying persistent storage.

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

Classes in org.apache.ignite.internal that implement IgniteInternalFuture
Modifier and Type | Class and Description
--- | ---
`class` | `ComputeTaskInternalFuture<R>` This class provide implementation for task future.

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

Methods in org.apache.ignite.internal with parameters of type IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`protected <R> IgniteFuture<R>` | AsyncSupportAdapter.`createFuture(IgniteInternalFuture<R> fut)`
`protected <R> IgniteFuture<R>` | IgniteComputeImpl.`createFuture(IgniteInternalFuture<R> fut)`
`<R> R` | AsyncSupportAdapter.`saveOrGet(IgniteInternalFuture<R> fut)`

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

### Uses of IgniteInternalFuture in org.apache.ignite.internal.managers.discovery

Methods in org.apache.ignite.internal.managers.discovery that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<Long>` | GridDiscoveryManager.`topologyFuture(long awaitVer)` Gets future that will be completed when current topology version becomes greater or equal to argument passed.

### Uses of IgniteInternalFuture in org.apache.ignite.internal.managers.eventstorage

Methods in org.apache.ignite.internal.managers.eventstorage that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`<T extends Event> IgniteInternalFuture<List<T>>` | GridEventStorageManager.`remoteEventsAsync(IgnitePredicate<T> p, Collection<? extends ClusterNode> nodes, long timeout)`
`<T extends Event> IgniteInternalFuture<T>` | GridEventStorageManager.`waitForEvent(IgnitePredicate<T> p, int... types)`

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.affinity

Methods in org.apache.ignite.internal.processors.affinity that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<Long>` | GridAffinityAssignmentCache.`readyFuture(long topVer)` Gets future that will be completed after topology with version `topVer` is calculated.

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

Subinterfaces of IgniteInternalFuture in org.apache.ignite.internal.processors.cache
Modifier and Type | Interface and Description
--- | ---
`interface` | `GridCacheAtomicFuture<K,R>` Update future for atomic cache.
`interface` | `GridCacheFuture<R>` This interface should be implemented by all distributed futures.
`interface` | `GridCacheMvccFuture<K,V,T>` Distributed future aware of MVCC locking.

Classes in org.apache.ignite.internal.processors.cache that implement IgniteInternalFuture
Modifier and Type | Class and Description
--- | ---
`class` | `GridCacheMultiTxFuture<K,V>` Future which waits for completion of one or more transactions.

Methods in org.apache.ignite.internal.processors.cache that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<Long>` | GridCacheAffinityManager.`affinityReadyFuture(long topVer)` Gets affinity ready future, a future that will be completed after affinity with given topology version is calculated.
`IgniteInternalFuture<Long>` | GridCacheAffinityManager.`affinityReadyFuturex(long topVer)` Gets affinity ready future that will be completed after affinity with given topology version is calculated.
`protected <T> IgniteInternalFuture<T>` | GridCacheAdapter.`asyncOp(IgniteTxLocalAdapter<K,V> tx, GridCacheAdapter.AsyncOp<T> op)`
`protected <T> IgniteInternalFuture<T>` | GridCacheAdapter.`asyncOpAcquire()` Tries to acquire asynchronous operations permit, if limited.
`IgniteInternalFuture<?>` | GridCacheMvccManager.`atomicFuture(GridCacheVersion futVer)` Gets future by given future ID.
`IgniteInternalFuture<?>` | GridCacheProjectionImpl.`clearAsync()`
`IgniteInternalFuture<?>` | CacheProjection.`clearAsync()`
`IgniteInternalFuture<?>` | GridCacheProxyImpl.`clearAsync()`
`IgniteInternalFuture<?>` | GridCacheAdapter.`clearAsync()`
`IgniteInternalFuture<IgniteInternalTx>` | GridCacheAdapter.`commitTxAsync(IgniteInternalTx tx)` Asynchronously commits transaction after all previous asynchronous operations are completed.
`IgniteInternalFuture<IgniteInternalTx>` | GridCacheSharedContext.`commitTxAsync(IgniteInternalTx<K,V> tx)`
`IgniteInternalFuture<Boolean>` | GridCacheProjectionImpl.`containsKeyAsync(K key)`
`IgniteInternalFuture<Boolean>` | CacheProjection.`containsKeyAsync(K key)`
`IgniteInternalFuture<Boolean>` | GridCacheProxyImpl.`containsKeyAsync(K key)`
`IgniteInternalFuture<Boolean>` | GridCacheAdapter.`containsKeyAsync(K key)`
`IgniteInternalFuture<Boolean>` | GridCacheProjectionImpl.`containsKeysAsync(Collection<? extends K> keys)`
`IgniteInternalFuture<Boolean>` | CacheProjection.`containsKeysAsync(Collection<? extends K> keys)`
`IgniteInternalFuture<Boolean>` | GridCacheProxyImpl.`containsKeysAsync(Collection<? extends K> keys)`
`IgniteInternalFuture<Boolean>` | GridCacheAdapter.`containsKeysAsync(Collection<? extends K> keys)`
`IgniteInternalFuture<?>` | GridCacheMvccManager.`finishAtomicUpdates(long topVer)`
`IgniteInternalFuture<?>` | GridCacheMvccManager.`finishExplicitLocks(long topVer)` Creates a future that will wait for all explicit locks acquired on given topology version to be released.
`IgniteInternalFuture<?>` | GridCacheMvccManager.`finishKeys(Collection<K> keys, long topVer)`
`IgniteInternalFuture<?>` | GridCacheMvccManager.`finishLocks(long topVer)`
`IgniteInternalFuture<?>` | GridCacheProxyImpl.`forceRepartition()` Forces this cache node to re-balance its partitions.
`IgniteInternalFuture<?>` | GridCacheAdapter.`forceRepartition()` Forces this cache node to re-balance its partitions.
`IgniteInternalFuture` | GridCacheAdapter.FutureHolder.`future()` Gets future.
`IgniteInternalFuture<Map<K,V>>` | GridCacheProjectionImpl.`getAllAsync(Collection<? extends K> keys)` Asynchronously retrieves values mapped to the specified keys from cache.
`IgniteInternalFuture<Map<K,V>>` | CacheProjection.`getAllAsync(Collection<? extends K> keys)` Asynchronously retrieves values mapped to the specified keys from cache.
`IgniteInternalFuture<Map<K,V>>` | GridCacheProxyImpl.`getAllAsync(Collection<? extends K> keys)` Asynchronously retrieves values mapped to the specified keys from cache.
`IgniteInternalFuture<Map<K,V>>` | GridCacheAdapter.`getAllAsync(Collection<? extends K> keys)` Asynchronously retrieves values mapped to the specified keys from cache.
`IgniteInternalFuture<Map<K,V>>` | GridCacheAdapter.`getAllAsync(Collection<? extends K> keys, boolean deserializePortable)`
`protected IgniteInternalFuture<Map<K,V>>` | GridCacheAdapter.`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, GridCacheEntryEx<K,V> entry, UUID subjId, String taskName, boolean deserializePortable, boolean skipVals)`
`IgniteInternalFuture<Map<K,V>>` | GridCacheAdapter.`getAllAsync(Collection<? extends K> keys, boolean readThrough, GridCacheEntryEx<K,V> cached, boolean checkTx, UUID subjId, String taskName, boolean deserializePortable, boolean forcePrimary, IgniteCacheExpiryPolicy expiry, boolean skipVals)`
`IgniteInternalFuture<Map<K,V>>` | GridCacheProjectionEx.`getAllOutTxAsync(List<K> keys)` Asynchronously gets values from cache.
`IgniteInternalFuture<Map<K,V>>` | GridCacheProjectionImpl.`getAllOutTxAsync(List<K> keys)` Asynchronously gets values from cache.
`IgniteInternalFuture<Map<K,V>>` | GridCacheProxyImpl.`getAllOutTxAsync(List<K> keys)` Asynchronously gets values from cache.
`IgniteInternalFuture<Map<K,V>>` | GridCacheAdapter.`getAllOutTxAsync(List<K> keys)` Asynchronously gets values from cache.
`IgniteInternalFuture<V>` | GridCacheProjectionImpl.`getAsync(K key)` Asynchronously retrieves value mapped to the specified key from cache.
`IgniteInternalFuture<V>` | CacheProjection.`getAsync(K key)` Asynchronously retrieves value mapped to the specified key from cache.
`IgniteInternalFuture<V>` | GridCacheProxyImpl.`getAsync(K key)` Asynchronously retrieves value mapped to the specified key from cache.
`IgniteInternalFuture<V>` | GridCacheAdapter.`getAsync(K key)` Asynchronously retrieves value mapped to the specified key from cache.
`IgniteInternalFuture<V>` | GridCacheAdapter.`getAsync(K key, boolean deserializePortable)`
`IgniteInternalFuture<V>` | GridCacheProjectionEx.`getForcePrimaryAsync(K key)` Asynchronously gets value from cache.
`IgniteInternalFuture<V>` | GridCacheProjectionImpl.`getForcePrimaryAsync(K key)` Asynchronously gets value from cache.
`IgniteInternalFuture<V>` | GridCacheProxyImpl.`getForcePrimaryAsync(K key)` Asynchronously gets value from cache.
`IgniteInternalFuture<V>` | GridCacheAdapter.`getForcePrimaryAsync(K key)` Asynchronously gets value from cache.
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | GridCacheProjectionEx.`invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | GridCacheProjectionImpl.`invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | GridCacheProxyImpl.`invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | GridCacheAdapter.`invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | GridCacheProjectionEx.`invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | GridCacheProjectionImpl.`invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | GridCacheProxyImpl.`invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | GridCacheAdapter.`invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>>` | GridCacheProjectionEx.`invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>>` | GridCacheProjectionImpl.`invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>>` | GridCacheProxyImpl.`invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>>` | GridCacheAdapter.`invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`IgniteInternalFuture<?>` | GridCacheAdapter.`loadAll(Set<? extends K> keys, boolean replaceExisting)`
`IgniteInternalFuture<?>` | GridCacheProxyImpl.`loadCacheAsync(IgniteBiPredicate<K,V> p, long ttl, Object[] args)` Asynchronously delegates to `CacheStore.loadCache(org.apache.ignite.lang.IgniteBiInClosure, Object...)` method to reload state from the underlying persistent storage.
`IgniteInternalFuture<?>` | GridCacheAdapter.`loadCacheAsync(IgniteBiPredicate<K,V> p, long ttl, Object[] args)` Asynchronously delegates to `CacheStore.loadCache(org.apache.ignite.lang.IgniteBiInClosure, Object...)` method to reload state from the underlying persistent storage.
`IgniteInternalFuture<Boolean>` | CacheProjection.`lockAllAsync(Collection<? extends K> keys, long timeout, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` All or nothing synchronous lock for passed in keys.
`IgniteInternalFuture<Boolean>` | GridCacheProjectionImpl.`lockAllAsync(Collection<? extends K> keys, long timeout, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` All or nothing synchronous lock for passed in keys.
`IgniteInternalFuture<Boolean>` | GridCacheProxyImpl.`lockAllAsync(Collection<? extends K> keys, long timeout, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` All or nothing synchronous lock for passed in keys.
`IgniteInternalFuture<Boolean>` | CacheProjection.`lockAsync(K key, long timeout, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Asynchronously acquires lock on a cached object with given key only if the passed in filter (if any) passes.
`IgniteInternalFuture<Boolean>` | GridCacheAdapter.`lockAsync(K key, long timeout, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Asynchronously acquires lock on a cached object with given key only if the passed in filter (if any) passes.
`IgniteInternalFuture<Boolean>` | GridCacheProjectionImpl.`lockAsync(K key, long timeout, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously acquires lock on a cached object with given key only if the passed in filter (if any) passes.
`IgniteInternalFuture<Boolean>` | GridCacheProxyImpl.`lockAsync(K key, long timeout, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously acquires lock on a cached object with given key only if the passed in filter (if any) passes.
`abstract IgniteInternalFuture<T>` | GridCacheAdapter.AsyncOp.`op(IgniteTxLocalAdapter<K,V> tx)`
`IgniteInternalFuture<?>` | GridCacheProcessor.`orderedPreloadFuture(int order)` Gets preload finish future for preload-ordered cache with given order.
`IgniteInternalFuture<?>` | GridCacheSharedContext.`partitionReleaseFuture(long topVer)` Waits for partition locks and transactions release.
`IgniteInternalFuture<Object>` | GridCacheSharedContext.`preloadersStartFuture()`
`IgniteInternalFuture<?>` | CacheProjection.`putAllAsync(Map<? extends K,? extends V> m, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Asynchronously stores given key-value pairs in cache.
`IgniteInternalFuture<?>` | GridCacheAdapter.`putAllAsync(Map<? extends K,? extends V> m, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Asynchronously stores given key-value pairs in cache.
`IgniteInternalFuture<?>` | GridCacheProjectionImpl.`putAllAsync(Map<? extends K,? extends V> m, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously stores given key-value pairs in cache.
`IgniteInternalFuture<?>` | GridCacheProxyImpl.`putAllAsync(Map<? extends K,? extends V> m, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously stores given key-value pairs in cache.
`IgniteInternalFuture<?>` | GridCacheProjectionEx.`putAllDrAsync(Map<? extends K,GridCacheDrInfo<V>> drMap)` Store DR data asynchronously.
`IgniteInternalFuture<?>` | GridCacheProjectionImpl.`putAllDrAsync(Map<? extends K,GridCacheDrInfo<V>> drMap)` Store DR data asynchronously.
`IgniteInternalFuture<?>` | GridCacheProxyImpl.`putAllDrAsync(Map<? extends K,GridCacheDrInfo<V>> drMap)` Store DR data asynchronously.
`IgniteInternalFuture<?>` | GridCacheAdapter.`putAllDrAsync(Map<? extends K,GridCacheDrInfo<V>> drMap)` Store DR data asynchronously.
`IgniteInternalFuture<V>` | GridCacheProjectionEx.`putAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<V>` | GridCacheProxyImpl.`putAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<V>` | GridCacheAdapter.`putAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<V>` | GridCacheProjectionImpl.`putAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<V>` | CacheProjection.`putAsync(K key, V val, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Asynchronously stores given key-value pair in cache.
`IgniteInternalFuture<V>` | GridCacheProjectionImpl.`putAsync(K key, V val, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously stores given key-value pair in cache.
`IgniteInternalFuture<V>` | GridCacheProxyImpl.`putAsync(K key, V val, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously stores given key-value pair in cache.
`IgniteInternalFuture<V>` | GridCacheAdapter.`putAsync(K key, V val, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously stores given key-value pair in cache.
`IgniteInternalFuture<V>` | GridCacheProjectionImpl.`putIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<V>` | CacheProjection.`putIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<V>` | GridCacheProxyImpl.`putIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<V>` | GridCacheAdapter.`putIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<Boolean>` | GridCacheProjectionEx.`putxAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<Boolean>` | GridCacheProxyImpl.`putxAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<Boolean>` | GridCacheAdapter.`putxAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<Boolean>` | GridCacheProjectionImpl.`putxAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<Boolean>` | CacheProjection.`putxAsync(K key, V val, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Stores given key-value pair in cache.
`IgniteInternalFuture<Boolean>` | GridCacheAdapter.`putxAsync(K key, V val, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Stores given key-value pair in cache.
`IgniteInternalFuture<Boolean>` | GridCacheProjectionImpl.`putxAsync(K key, V val, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Stores given key-value pair in cache.
`IgniteInternalFuture<Boolean>` | GridCacheProxyImpl.`putxAsync(K key, V val, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Stores given key-value pair in cache.
`IgniteInternalFuture<Boolean>` | GridCacheProjectionImpl.`putxIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<Boolean>` | CacheProjection.`putxIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<Boolean>` | GridCacheProxyImpl.`putxIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<Boolean>` | GridCacheAdapter.`putxIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<Object>` | GridCacheAdapter.`readThroughAllAsync(Collection<? extends K> keys, boolean reload, boolean skipVals, IgniteInternalTx<K,V> tx, UUID subjId, String taskName, IgniteBiInClosure<K,V> vis)`
`IgniteInternalFuture<Object>` | GridCacheExplicitLockSpan.`releaseFuture()` Gets span release future.
`IgniteInternalFuture<?>` | GridCacheProjectionImpl.`reloadAllAsync()` Asynchronously reloads all specified entries from underlying persistent storage.
`IgniteInternalFuture<?>` | CacheProjection.`reloadAllAsync()` Asynchronously reloads all specified entries from underlying persistent storage.
`IgniteInternalFuture<?>` | GridCacheProxyImpl.`reloadAllAsync()` Asynchronously reloads all specified entries from underlying persistent storage.
`IgniteInternalFuture<?>` | GridCacheAdapter.`reloadAllAsync()` Asynchronously reloads all specified entries from underlying persistent storage.
`IgniteInternalFuture<?>` | GridCacheProjectionImpl.`reloadAllAsync(Collection<? extends K> keys)` Asynchronously reloads all specified entries from underlying persistent storage.
`IgniteInternalFuture<?>` | CacheProjection.`reloadAllAsync(Collection<? extends K> keys)` Asynchronously reloads all specified entries from underlying persistent storage.
`IgniteInternalFuture<?>` | GridCacheProxyImpl.`reloadAllAsync(Collection<? extends K> keys)` Asynchronously reloads all specified entries from underlying persistent storage.
`IgniteInternalFuture<?>` | GridCacheAdapter.`reloadAllAsync(Collection<? extends K> keys)`
`IgniteInternalFuture<Map<K,V>>` | GridCacheAdapter.`reloadAllAsync(Collection<? extends K> keys, boolean ret, boolean skipVals, UUID subjId, String taskName)`
`IgniteInternalFuture<V>` | GridCacheProjectionImpl.`reloadAsync(K key)` Asynchronously reloads a single key from persistent storage.
`IgniteInternalFuture<V>` | CacheProjection.`reloadAsync(K key)` Asynchronously reloads a single key from persistent storage.
`IgniteInternalFuture<V>` | GridCacheProxyImpl.`reloadAsync(K key)` Asynchronously reloads a single key from persistent storage.
`IgniteInternalFuture<V>` | GridCacheAdapter.`reloadAsync(K key)`
`IgniteInternalFuture<?>` | GridCacheProjectionImpl.`removeAllAsync()`
`IgniteInternalFuture<?>` | CacheProjection.`removeAllAsync()`
`IgniteInternalFuture<?>` | GridCacheProxyImpl.`removeAllAsync()`
`IgniteInternalFuture<?>` | CacheProjection.`removeAllAsync(Collection<? extends K> keys, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Asynchronously removes given key mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<?>` | GridCacheAdapter.`removeAllAsync(Collection<? extends K> keys, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Asynchronously removes given key mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<?>` | GridCacheProjectionImpl.`removeAllAsync(Collection<? extends K> keys, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously removes given key mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<?>` | GridCacheProxyImpl.`removeAllAsync(Collection<? extends K> keys, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously removes given key mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<?>` | GridCacheProjectionImpl.`removeAllAsync(IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Asynchronously removes mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<?>` | CacheProjection.`removeAllAsync(IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Asynchronously removes mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<?>` | GridCacheAdapter.`removeAllAsync(IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Asynchronously removes mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<?>` | GridCacheProxyImpl.`removeAllAsync(IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously removes mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<?>` | GridCacheProjectionEx.`removeAllDrAsync(Map<? extends K,GridCacheVersion> drMap)` Removes DR data asynchronously.
`IgniteInternalFuture<?>` | GridCacheProjectionImpl.`removeAllDrAsync(Map<? extends K,GridCacheVersion> drMap)` Removes DR data asynchronously.
`IgniteInternalFuture<?>` | GridCacheProxyImpl.`removeAllDrAsync(Map<? extends K,GridCacheVersion> drMap)` Removes DR data asynchronously.
`IgniteInternalFuture<?>` | GridCacheAdapter.`removeAllDrAsync(Map<? extends K,GridCacheVersion> drMap)` Removes DR data asynchronously.
`IgniteInternalFuture<V>` | GridCacheProjectionEx.`removeAsync(K key, GridCacheEntryEx<K,V> entry, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<V>` | GridCacheProjectionImpl.`removeAsync(K key, GridCacheEntryEx<K,V> entry, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<V>` | GridCacheProxyImpl.`removeAsync(K key, GridCacheEntryEx<K,V> entry, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<V>` | GridCacheAdapter.`removeAsync(K key, GridCacheEntryEx<K,V> entry, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<V>` | CacheProjection.`removeAsync(K key, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Asynchronously removes given key mapping from cache.
`IgniteInternalFuture<V>` | GridCacheAdapter.`removeAsync(K key, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Asynchronously removes given key mapping from cache.
`IgniteInternalFuture<V>` | GridCacheProjectionImpl.`removeAsync(K key, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously removes given key mapping from cache.
`IgniteInternalFuture<V>` | GridCacheProxyImpl.`removeAsync(K key, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously removes given key mapping from cache.
`IgniteInternalFuture<Boolean>` | GridCacheProjectionImpl.`removeAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<Boolean>` | CacheProjection.`removeAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<Boolean>` | GridCacheProxyImpl.`removeAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<Boolean>` | GridCacheAdapter.`removeAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<?>` | GridCacheMvccManager.`removeAtomicFuture(GridCacheVersion futVer)`
`IgniteInternalFuture<Boolean>` | GridCacheProjectionEx.`removexAsync(K key, GridCacheEntryEx<K,V> entry, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<Boolean>` | GridCacheProjectionImpl.`removexAsync(K key, GridCacheEntryEx<K,V> entry, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<Boolean>` | GridCacheProxyImpl.`removexAsync(K key, GridCacheEntryEx<K,V> entry, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<Boolean>` | GridCacheAdapter.`removexAsync(K key, GridCacheEntryEx<K,V> entry, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<Boolean>` | CacheProjection.`removexAsync(K key, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Asynchronously removes given key mapping from cache.
`IgniteInternalFuture<Boolean>` | GridCacheAdapter.`removexAsync(K key, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Asynchronously removes given key mapping from cache.
`IgniteInternalFuture<Boolean>` | GridCacheProjectionImpl.`removexAsync(K key, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously removes given key mapping from cache.
`IgniteInternalFuture<Boolean>` | GridCacheProxyImpl.`removexAsync(K key, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously removes given key mapping from cache.
`IgniteInternalFuture<GridCacheReturn<V>>` | GridCacheProjectionEx.`removexAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<GridCacheReturn<V>>` | GridCacheProjectionImpl.`removexAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<GridCacheReturn<V>>` | GridCacheProxyImpl.`removexAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<GridCacheReturn<V>>` | GridCacheAdapter.`removexAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<V>` | GridCacheProjectionImpl.`replaceAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
`IgniteInternalFuture<V>` | CacheProjection.`replaceAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
`IgniteInternalFuture<V>` | GridCacheProxyImpl.`replaceAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
`IgniteInternalFuture<V>` | GridCacheAdapter.`replaceAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
`IgniteInternalFuture<Boolean>` | GridCacheProjectionImpl.`replaceAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<Boolean>` | CacheProjection.`replaceAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<Boolean>` | GridCacheProxyImpl.`replaceAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<Boolean>` | GridCacheAdapter.`replaceAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<Boolean>` | GridCacheProjectionImpl.`replacexAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.
`IgniteInternalFuture<Boolean>` | CacheProjection.`replacexAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.
`IgniteInternalFuture<Boolean>` | GridCacheProxyImpl.`replacexAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.
`IgniteInternalFuture<Boolean>` | GridCacheAdapter.`replacexAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.
`IgniteInternalFuture<GridCacheReturn<V>>` | GridCacheProjectionEx.`replacexAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<GridCacheReturn<V>>` | GridCacheProjectionImpl.`replacexAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<GridCacheReturn<V>>` | GridCacheProxyImpl.`replacexAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<GridCacheReturn<V>>` | GridCacheAdapter.`replacexAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<Object>` | GridCachePreloader.`request(Collection<? extends K> keys, long topVer)` Requests that preloader sends the request for the key.
`IgniteInternalFuture<Object>` | GridCachePreloaderAdapter.`request(Collection<? extends K> keys, long topVer)` Requests that preloader sends the request for the key.
`IgniteInternalFuture` | GridCacheSharedContext.`rollbackTxAsync(IgniteInternalTx<K,V> tx)`
`IgniteInternalFuture<Integer>` | GridCacheProjectionImpl.`sizeAsync(CachePeekMode[] peekModes)`
`IgniteInternalFuture<Integer>` | CacheProjection.`sizeAsync(CachePeekMode[] peekModes)`
`IgniteInternalFuture<Integer>` | GridCacheProxyImpl.`sizeAsync(CachePeekMode[] peekModes)`
`IgniteInternalFuture<Integer>` | GridCacheAdapter.`sizeAsync(CachePeekMode[] peekModes)`
`IgniteInternalFuture<Object>` | GridCachePreloader.`startFuture()`
`IgniteInternalFuture<Object>` | GridCachePreloaderAdapter.`startFuture()`
`IgniteInternalFuture<?>` | GridCachePreloader.`syncFuture()`
`IgniteInternalFuture<?>` | GridCachePreloaderAdapter.`syncFuture()`
`abstract IgniteInternalFuture<Boolean>` | GridCacheAdapter.`txLockAsync(Collection<? extends K> keys, long timeout, IgniteTxLocalEx<K,V> tx, boolean isRead, boolean retval, TransactionIsolation isolation, boolean invalidate, long accessTtl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)`
`IgniteInternalFuture<V>` | GridCacheContext.`wrapClone(IgniteInternalFuture<V> f)`
`IgniteInternalFuture<Map<K,V>>` | GridCacheContext.`wrapCloneMap(IgniteInternalFuture<Map<K,V>> f)`

Methods in org.apache.ignite.internal.processors.cache that return types with arguments of type IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`static IgniteInClosure<IgniteInternalFuture<?>>` | GridCacheUtils.`errorLogger(IgniteLogger log, Class<? extends Exception>... excl)`
`List<IgniteInternalFuture<?>>` | GridCachePartitionExchangeManager.`exchangeFutures()`
`<T> Collection<? extends IgniteInternalFuture<T>>` | GridCacheMvccManager.`futures(GridCacheVersion ver)` Gets all futures for given lock version, possibly empty collection.

Methods in org.apache.ignite.internal.processors.cache with parameters of type IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridCacheAdapter.UpdateTimeStatClosure.`apply(IgniteInternalFuture<T> fut)` Closure body.
`void` | GridCacheAdapter.FutureHolder.`future(IgniteInternalFuture fut)` Sets future.
`protected void` | GridCacheAdapter.`saveFuture(GridCacheAdapter.FutureHolder holder, IgniteInternalFuture<?> fut)` Saves future in thread local holder and adds listener that will clear holder when future is finished.
`IgniteInternalFuture<V>` | GridCacheContext.`wrapClone(IgniteInternalFuture<V> f)`
`IgniteInternalFuture<Map<K,V>>` | GridCacheContext.`wrapCloneMap(IgniteInternalFuture<Map<K,V>> f)`

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

Classes in org.apache.ignite.internal.processors.cache.distributed that implement IgniteInternalFuture
Modifier and Type | Class and Description
--- | ---
`class` | `GridCacheOptimisticCheckPreparedTxFuture<K,V>` Future verifying that all remote transactions related to some optimistic transaction were prepared.

Methods in org.apache.ignite.internal.processors.cache.distributed that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<?>` | GridCacheTxFinishSync.`awaitAckAsync(UUID nodeId, long threadId)`
`IgniteInternalFuture<IgniteInternalTx>` | GridDistributedTxRemoteAdapter.`commitAsync()` Asynchronously commits this transaction by initiating `two-phase-commit` process.
`IgniteInternalFuture<Boolean>` | GridDistributedCacheAdapter.`lockAllAsync(Collection<? extends K> keys, long timeout, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` All or nothing synchronous lock for passed in keys.
`protected abstract IgniteInternalFuture<Boolean>` | GridDistributedCacheAdapter.`lockAllAsync(Collection<? extends K> keys, long timeout, IgniteTxLocalEx<K,V> tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)`
`IgniteInternalFuture<IgniteInternalTx<K,V>>` | GridDistributedTxRemoteAdapter.`prepareAsync()` Prepare stage.
`IgniteInternalFuture<?>` | GridDistributedCacheAdapter.`removeAllAsync()`
`IgniteInternalFuture<IgniteInternalTx>` | GridDistributedTxRemoteAdapter.`rollbackAsync()` Asynchronously rollback this transaction.
`IgniteInternalFuture<Boolean>` | GridDistributedCacheAdapter.`txLockAsync(Collection<? extends K> keys, long timeout, IgniteTxLocalEx<K,V> tx, boolean isRead, boolean retval, TransactionIsolation isolation, boolean isInvalidate, long accessTtl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)`

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

Subinterfaces of IgniteInternalFuture in org.apache.ignite.internal.processors.cache.distributed.dht
Modifier and Type | Interface and Description
--- | ---
`interface` | `GridDhtFuture<T>` Keys to retry.
`interface` | `GridDhtTopologyFuture` Future that implements a barrier after which dht topology is safe to use.

Classes in org.apache.ignite.internal.processors.cache.distributed.dht that implement IgniteInternalFuture
Modifier and Type | Class and Description
--- | ---
`class` | `GridDhtAssignmentFetchFuture<K,V>` Future that fetches affinity assignment from remote cache nodes.
`class` | `GridDhtEmbeddedFuture<A,B>` Embedded DHT future.
`class` | `GridDhtFinishedFuture<T>` Finished DHT future.
`class` | `GridDhtGetFuture<K,V>`
`class` | `GridDhtLockFuture<K,V>` Cache lock future.
`class` | `GridDhtTxFinishFuture<K,V>`
`class` | `GridDhtTxPrepareFuture<K,V>`
`class` | `GridPartitionedGetFuture<K,V>` Colocated get future.

Methods in org.apache.ignite.internal.processors.cache.distributed.dht that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<Boolean>` | GridDhtTxLocalAdapter.`addEntry(long msgId, IgniteTxEntry<K,V> e)`
`protected IgniteInternalFuture<Boolean>` | GridDhtTxLocal.`addReader(long msgId, GridDhtCacheEntry<K,V> cached, IgniteTxEntry<K,V> entry, long topVer)` Adds reader to cached entry.
`protected abstract IgniteInternalFuture<Boolean>` | GridDhtTxLocalAdapter.`addReader(long msgId, GridDhtCacheEntry<K,V> cached, IgniteTxEntry<K,V> entry, long topVer)` Adds reader to cached entry.
`IgniteInternalFuture<Boolean>` | GridDhtCacheEntry.`addReader(UUID nodeId, long msgId, long topVer)`
`IgniteInternalFuture<IgniteInternalTx>` | GridDhtTxLocal.`commitAsync()` Asynchronously commits this transaction by initiating `two-phase-commit` process.
`IgniteInternalFuture<Map<K,V>>` | GridDhtCacheAdapter.`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, GridCacheEntryEx<K,V> entry, UUID subjId, String taskName, boolean deserializePortable, boolean skipVals)` This method is used internally.
`IgniteInternalFuture<Boolean>` | GridDhtTransactionalCacheAdapter.`lockAllAsync(Collection<? extends K> keys, long timeout, IgniteTxLocalEx<K,V> txx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)`
`IgniteInternalFuture<GridNearLockResponse<K,V>>` | GridDhtTransactionalCacheAdapter.`lockAllAsync(GridCacheContext<K,V> cacheCtx, ClusterNode nearNode, GridNearLockRequest<K,V> req, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter0)`
`IgniteInternalFuture<?>` | GridDhtCacheAdapter.`multiUpdateFinishFuture(long topVer)` Creates multi update finish future.
`IgniteInternalFuture<IgniteInternalTx<K,V>>` | GridDhtTxLocal.`prepareAsync()` Prepare stage.

`IgniteInternalFuture<IgniteInternalTx<K,V>>`

GridDhtTxLocal.`prepareAsync(Iterable<IgniteTxEntry<K,V>> reads, Iterable<IgniteTxEntry<K,V>> writes, Map<IgniteTxKey<K>,GridCacheVersion> verMap, long msgId, IgniteUuid nearMiniId, Map<UUID,Collection<UUID>> txNodes, boolean last, Collection<UUID> lastBackups, IgniteInClosure<GridNearTxPrepareResponse<K,V>> completeCb)`
Prepares next batch of entries in dht transaction.

`IgniteInternalFuture<IgniteInternalTx>` | GridDhtTxLocal.`rollbackAsync()` Asynchronously rollback this transaction.

Constructors in org.apache.ignite.internal.processors.cache.distributed.dht with parameters of type IgniteInternalFuture
Constructor and Description
`GridDhtEmbeddedFuture(GridKernalContext ctx, IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,A> c)`
`GridDhtEmbeddedFuture(GridKernalContext ctx, IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,A> c, Collection<Integer> invalidParts)`
`GridDhtEmbeddedFuture(IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c, GridKernalContext ctx)`

Constructor parameters in org.apache.ignite.internal.processors.cache.distributed.dht with type arguments of type IgniteInternalFuture
Constructor and Description
`GridDhtEmbeddedFuture(IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c, GridKernalContext ctx)`

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.cache.distributed.dht.atomic

Classes in org.apache.ignite.internal.processors.cache.distributed.dht.atomic that implement IgniteInternalFuture
Modifier and Type | Class and Description
--- | ---
`class` | `GridDhtAtomicUpdateFuture<K,V>` DHT atomic cache backup update future.
`class` | `GridNearAtomicUpdateFuture<K,V>` DHT atomic cache near update future.

Methods in org.apache.ignite.internal.processors.cache.distributed.dht.atomic that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`protected <T> IgniteInternalFuture<T>` | GridDhtAtomicCache.`asyncOp(CO<IgniteInternalFuture<T>> op)`
`IgniteInternalFuture<Map<K,V>>` | GridDhtAtomicCache.`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, GridCacheEntryEx<K,V> entry, UUID subjId, String taskName, boolean deserializePortable, boolean skipVals)` This method is used internally.
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | GridDhtAtomicCache.`invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | GridDhtAtomicCache.`invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>>` | GridDhtAtomicCache.`invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`protected IgniteInternalFuture<Boolean>` | GridDhtAtomicCache.`lockAllAsync(Collection<? extends K> keys, long timeout, IgniteTxLocalEx<K,V> tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)`
`IgniteInternalFuture<?>` | GridDhtAtomicCache.`putAllAsync(Map<? extends K,? extends V> m, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously stores given key-value pairs in cache.
`IgniteInternalFuture<?>` | GridDhtAtomicCache.`putAllDrAsync(Map<? extends K,GridCacheDrInfo<V>> drMap)` Store DR data asynchronously.
`IgniteInternalFuture<V>` | GridDhtAtomicCache.`putAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<V>` | GridDhtAtomicCache.`putIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<Boolean>` | GridDhtAtomicCache.`putxAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<Boolean>` | GridDhtAtomicCache.`putxIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<?>` | GridDhtAtomicCache.`removeAllAsync(Collection<? extends K> keys, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously removes given key mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<?>` | GridDhtAtomicCache.`removeAllAsync(IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously removes mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<?>` | GridDhtAtomicCache.`removeAllDrAsync(Map<? extends K,GridCacheVersion> drMap)` Removes DR data asynchronously.
`IgniteInternalFuture<V>` | GridDhtAtomicCache.`removeAsync(K key, GridCacheEntryEx<K,V> entry, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<Boolean>` | GridDhtAtomicCache.`removeAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<Boolean>` | GridDhtAtomicCache.`removexAsync(K key, GridCacheEntryEx<K,V> entry, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<GridCacheReturn<V>>` | GridDhtAtomicCache.`removexAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<V>` | GridDhtAtomicCache.`replaceAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
`IgniteInternalFuture<Boolean>` | GridDhtAtomicCache.`replaceAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<Boolean>` | GridDhtAtomicCache.`replacexAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.
`IgniteInternalFuture<GridCacheReturn<V>>` | GridDhtAtomicCache.`replacexAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.

Method parameters in org.apache.ignite.internal.processors.cache.distributed.dht.atomic with type arguments of type IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`protected <T> IgniteInternalFuture<T>` | GridDhtAtomicCache.`asyncOp(CO<IgniteInternalFuture<T>> op)`

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.cache.distributed.dht.colocated

Classes in org.apache.ignite.internal.processors.cache.distributed.dht.colocated that implement IgniteInternalFuture
Modifier and Type | Class and Description
--- | ---
`class` | `GridDhtColocatedLockFuture<K,V>` Colocated cache lock future.

Methods in org.apache.ignite.internal.processors.cache.distributed.dht.colocated that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<Map<K,V>>` | GridDhtColocatedCache.`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, GridCacheEntryEx<K,V> entry, UUID subjId, String taskName, boolean deserializePortable, boolean skipVals)` This method is used internally.
`IgniteInternalFuture<Map<K,V>>` | GridDhtColocatedCache.`loadAsync(Collection<? extends K> keys, boolean readThrough, boolean reload, boolean forcePrimary, long topVer, UUID subjId, String taskName, boolean deserializePortable, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals)`
`IgniteInternalFuture<Boolean>` | GridDhtColocatedCache.`lockAllAsync(Collection<? extends K> keys, long timeout, IgniteTxLocalEx<K,V> tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` This is an entry point to pessimistic locking within transaction.

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.cache.distributed.dht.preloader

Classes in org.apache.ignite.internal.processors.cache.distributed.dht.preloader that implement IgniteInternalFuture
Modifier and Type | Class and Description
--- | ---
`class` | `GridDhtForceKeysFuture<K,V>` Force keys request future.
`class` | `GridDhtPartitionsExchangeFuture<K,V>` Future for exchanging partition maps.

Methods in org.apache.ignite.internal.processors.cache.distributed.dht.preloader that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<Object>` | GridDhtPreloader.`startFuture()`
`IgniteInternalFuture<?>` | GridDhtPreloader.`syncFuture()`

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

Classes in org.apache.ignite.internal.processors.cache.distributed.near that implement IgniteInternalFuture
Modifier and Type | Class and Description
--- | ---
`class` | `GridNearGetFuture<K,V>`
`class` | `GridNearLockFuture<K,V>` Cache lock future.
`class` | `GridNearTxFinishFuture<K,V>`
`class` | `GridNearTxPrepareFuture<K,V>`

Methods in org.apache.ignite.internal.processors.cache.distributed.near that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`protected IgniteInternalFuture<Boolean>` | GridNearTxLocal.`addReader(long msgId, GridDhtCacheEntry<K,V> cached, IgniteTxEntry<K,V> entry, long topVer)` Adds reader to cached entry.
`IgniteInternalFuture<IgniteInternalTx>` | GridNearTxLocal.`commitAsync()` Asynchronously commits this transaction by initiating `two-phase-commit` process.
`IgniteInternalFuture<IgniteInternalTx>` | GridNearTxLocal.`commitAsyncLocal()` Commits local part of colocated transaction.
`IgniteInternalFuture<Map<K,V>>` | GridNearTransactionalCache.`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, GridCacheEntryEx<K,V> entry, UUID subjId, String taskName, boolean deserializePortable, boolean skipVals)`
`protected IgniteInternalFuture<Map<K,V>>` | GridNearAtomicCache.`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, GridCacheEntryEx<K,V> entry, UUID subjId, String taskName, boolean deserializePortable, boolean skipVals)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | GridNearAtomicCache.`invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | GridNearAtomicCache.`invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>>` | GridNearAtomicCache.`invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`IgniteInternalFuture<Map<K,V>>` | GridNearCacheAdapter.`loadAsync(IgniteInternalTx tx, Collection<? extends K> keys, boolean reload, boolean forcePrimary, UUID subjId, String taskName, boolean deserializePortable, javax.cache.expiry.ExpiryPolicy expiryPlc, boolean skipVal)`
`IgniteInternalFuture<?>` | GridNearCacheAdapter.`loadCacheAsync(IgniteBiPredicate<K,V> p, long ttl, Object[] args)` Asynchronously delegates to `CacheStore.loadCache(org.apache.ignite.lang.IgniteBiInClosure, Object...)` method to reload state from the underlying persistent storage.
`IgniteInternalFuture<Boolean>` | GridNearTxLocal.`loadMissing(GridCacheContext<K,V> cacheCtx, boolean readThrough, boolean async, Collection<? extends K> keys, boolean deserializePortable, boolean skipVals, IgniteBiInClosure<K,V> c)`
`protected IgniteInternalFuture<Boolean>` | GridNearTransactionalCache.`lockAllAsync(Collection<? extends K> keys, long timeout, IgniteTxLocalEx<K,V> tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)`
`protected IgniteInternalFuture<Boolean>` | GridNearAtomicCache.`lockAllAsync(Collection<? extends K> keys, long timeout, IgniteTxLocalEx<K,V> tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)`
`IgniteInternalFuture<GridCacheReturn<V>>` | GridNearTxLocal.`lockAllAsync(GridCacheContext<K,V> cacheCtx, Collection<? extends K> keys, boolean implicit, boolean read, long accessTtl)`
`IgniteInternalFuture<IgniteInternalTx<K,V>>` | GridNearTxLocal.`prepareAsync()` Prepare stage.
`IgniteInternalFuture<IgniteInternalTx<K,V>>` | GridNearTxLocal.`prepareAsyncLocal(Collection<IgniteTxEntry<K,V>> reads, Collection<IgniteTxEntry<K,V>> writes, Map<UUID,Collection<UUID>> txNodes, boolean last, Collection<UUID> lastBackups, IgniteInClosure<GridNearTxPrepareResponse<K,V>> completeCb)` Prepares next batch of entries in dht transaction.
`IgniteInternalFuture<?>` | GridNearAtomicCache.`putAllAsync(Map<? extends K,? extends V> m, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously stores given key-value pairs in cache.
`IgniteInternalFuture<?>` | GridNearAtomicCache.`putAllDrAsync(Map<? extends K,GridCacheDrInfo<V>> drMap)` Store DR data asynchronously.
`IgniteInternalFuture<V>` | GridNearAtomicCache.`putAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<V>` | GridNearAtomicCache.`putIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<Boolean>` | GridNearAtomicCache.`putxAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<Boolean>` | GridNearAtomicCache.`putxIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<Object>` | GridNearCacheAdapter.`readThroughAllAsync(Collection<? extends K> keys, boolean reload, boolean skipVals, IgniteInternalTx<K,V> tx, UUID subjId, String taskName, IgniteBiInClosure<K,V> vis)`
`IgniteInternalFuture<?>` | GridNearCacheAdapter.`reloadAllAsync()` Asynchronously reloads all specified entries from underlying persistent storage.
`IgniteInternalFuture<?>` | GridNearCacheAdapter.`reloadAllAsync(Collection<? extends K> keys)` Asynchronously reloads all specified entries from underlying persistent storage.
`IgniteInternalFuture<?>` | GridNearAtomicCache.`removeAllAsync()`
`IgniteInternalFuture<?>` | GridNearAtomicCache.`removeAllAsync(Collection<? extends K> keys, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously removes given key mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<?>` | GridNearAtomicCache.`removeAllAsync(IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously removes mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<?>` | GridNearAtomicCache.`removeAllDrAsync(Map<? extends K,GridCacheVersion> drMap)` Removes DR data asynchronously.
`IgniteInternalFuture<V>` | GridNearAtomicCache.`removeAsync(K key, GridCacheEntryEx<K,V> entry, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<Boolean>` | GridNearAtomicCache.`removeAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<Boolean>` | GridNearAtomicCache.`removexAsync(K key, GridCacheEntryEx<K,V> entry, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<GridCacheReturn<V>>` | GridNearAtomicCache.`removexAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<V>` | GridNearAtomicCache.`replaceAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
`IgniteInternalFuture<Boolean>` | GridNearAtomicCache.`replaceAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<Boolean>` | GridNearAtomicCache.`replacexAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.
`IgniteInternalFuture<GridCacheReturn<V>>` | GridNearAtomicCache.`replacexAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<IgniteInternalTx>` | GridNearTxLocal.`rollbackAsync()` Asynchronously rollback this transaction.
`IgniteInternalFuture<IgniteInternalTx>` | GridNearTxLocal.`rollbackAsyncLocal()` Rolls back local part of colocated transaction.

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.cache.local

Classes in org.apache.ignite.internal.processors.cache.local that implement IgniteInternalFuture
Modifier and Type | Class and Description
--- | ---
`class` | `GridLocalLockFuture<K,V>` Cache lock future.

Methods in org.apache.ignite.internal.processors.cache.local that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<Boolean>` | GridLocalCache.`lockAllAsync(Collection<? extends K> keys, long timeout, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` All or nothing synchronous lock for passed in keys.
`IgniteInternalFuture<Boolean>` | GridLocalCache.`lockAllAsync(Collection<? extends K> keys, long timeout, IgniteTxLocalEx<K,V> tx, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)`
`IgniteInternalFuture<?>` | GridLocalCache.`removeAllAsync()`
`IgniteInternalFuture<Boolean>` | GridLocalCache.`txLockAsync(Collection<? extends K> keys, long timeout, IgniteTxLocalEx<K,V> tx, boolean isRead, boolean retval, TransactionIsolation isolation, boolean invalidate, long accessTtl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)`

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.cache.local.atomic

Methods in org.apache.ignite.internal.processors.cache.local.atomic that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`protected IgniteInternalFuture` | GridLocalAtomicCache.`asyncOp(Callable<?> op)`
`IgniteInternalFuture<Map<K,V>>` | GridLocalAtomicCache.`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, GridCacheEntryEx<K,V> entry, UUID subjId, String taskName, boolean deserializePortable, boolean skipVals)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | GridLocalAtomicCache.`invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` | GridLocalAtomicCache.`invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>>` | GridLocalAtomicCache.`invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`IgniteInternalFuture<Boolean>` | GridLocalAtomicCache.`lockAllAsync(Collection<? extends K> keys, long timeout, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` All or nothing synchronous lock for passed in keys.
`IgniteInternalFuture<?>` | GridLocalAtomicCache.`putAllAsync(Map<? extends K,? extends V> m, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously stores given key-value pairs in cache.
`IgniteInternalFuture<V>` | GridLocalAtomicCache.`putAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<V>` | GridLocalAtomicCache.`putIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<Boolean>` | GridLocalAtomicCache.`putxAsync(K key, V val, GridCacheEntryEx<K,V> entry, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<Boolean>` | GridLocalAtomicCache.`putxIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<?>` | GridLocalAtomicCache.`removeAllAsync()`
`IgniteInternalFuture<?>` | GridLocalAtomicCache.`removeAllAsync(Collection<? extends K> keys, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously removes given key mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<?>` | GridLocalAtomicCache.`removeAllAsync(IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)` Asynchronously removes mappings from cache for entries for which the optionally passed in filters do pass.
`IgniteInternalFuture<V>` | GridLocalAtomicCache.`removeAsync(K key, GridCacheEntryEx<K,V> entry, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<Boolean>` | GridLocalAtomicCache.`removeAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<Boolean>` | GridLocalAtomicCache.`removexAsync(K key, GridCacheEntryEx<K,V> entry, IgnitePredicate<javax.cache.Cache.Entry<K,V>>... filter)` Internal method that is called from `GridCacheEntryImpl`.
`IgniteInternalFuture<GridCacheReturn<V>>` | GridLocalAtomicCache.`removexAsync(K key, V val)` Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
`IgniteInternalFuture<V>` | GridLocalAtomicCache.`replaceAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
`IgniteInternalFuture<Boolean>` | GridLocalAtomicCache.`replaceAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<Boolean>` | GridLocalAtomicCache.`replacexAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.
`IgniteInternalFuture<GridCacheReturn<V>>` | GridLocalAtomicCache.`replacexAsync(K key, V oldVal, V newVal)` Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the `'oldVal'` passed in.
`IgniteInternalFuture<Boolean>` | GridLocalAtomicCache.`txLockAsync(Collection<? extends K> keys, long timeout, IgniteTxLocalEx<K,V> tx, boolean isRead, boolean retval, TransactionIsolation isolation, boolean invalidate, long accessTtl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)`

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

Subinterfaces of IgniteInternalFuture in org.apache.ignite.internal.processors.cache.query
Modifier and Type | Interface and Description
--- | ---
`interface` | `CacheQueryFuture<T>` Cache query future returned by query execution.

Classes in org.apache.ignite.internal.processors.cache.query that implement IgniteInternalFuture
Modifier and Type | Class and Description
--- | ---
`class` | `GridCacheDistributedFieldsQueryFuture` Distributed fields query future.
`class` | `GridCacheDistributedQueryFuture<K,V,R>` Distributed query future.
`class` | `GridCacheFieldsQueryErrorFuture` Error future for fields query.
`class` | `GridCacheLocalFieldsQueryFuture` Local fields query future.
`class` | `GridCacheLocalQueryFuture<K,V,R>` Local query future.
`class` | `GridCacheQueryErrorFuture<T>` Error future.
`class` | `GridCacheQueryFutureAdapter<K,V,R>` Query future adapter.

Methods in org.apache.ignite.internal.processors.cache.query that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<GridCacheSqlResult>` | GridCacheQueriesImpl.`execute(String space, GridCacheTwoStepQuery qry)`
`IgniteInternalFuture<GridCacheSqlResult>` | GridCacheQueriesProxy.`execute(String space, GridCacheTwoStepQuery qry)`
`IgniteInternalFuture<GridCacheSqlResult>` | GridCacheQueriesEx.`execute(String space, GridCacheTwoStepQuery qry)`
`IgniteInternalFuture<GridCacheSqlResult>` | GridCacheQueriesEx.`executeTwoStepQuery(String space, String sqlQry, Object... params)`
`IgniteInternalFuture<GridCacheSqlResult>` | GridCacheQueriesImpl.`executeTwoStepQuery(String space, String sqlQry, Object[] params)`
`IgniteInternalFuture<GridCacheSqlResult>` | GridCacheQueriesProxy.`executeTwoStepQuery(String space, String sqlQry, Object[] params)`
`IgniteInternalFuture<List<GridQueryFieldMetadata>>` | GridCacheFieldsQueryErrorFuture.`metadata()`
`IgniteInternalFuture<List<GridQueryFieldMetadata>>` | GridCacheQueryMetadataAware.`metadata()`
`IgniteInternalFuture<List<GridQueryFieldMetadata>>` | GridCacheDistributedFieldsQueryFuture.`metadata()`
`IgniteInternalFuture<List<GridQueryFieldMetadata>>` | GridCacheLocalFieldsQueryFuture.`metadata()`
`IgniteInternalFuture<?>` | GridCacheQueryManager.`rebuildAllIndexes()` Rebuilds all search indexes of all types.
`IgniteInternalFuture<?>` | GridCacheQueriesImpl.`rebuildAllIndexes()` Forces this cache to rebuild search indexes of all types.
`IgniteInternalFuture<?>` | CacheQueries.`rebuildAllIndexes()` Forces this cache to rebuild search indexes of all types.
`IgniteInternalFuture<?>` | GridCacheQueriesProxy.`rebuildAllIndexes()` Forces this cache to rebuild search indexes of all types.
`IgniteInternalFuture<?>` | GridCacheQueryManager.`rebuildIndexes(Class<?> valType)` Rebuilds all search indexes of given value type.
`IgniteInternalFuture<?>` | GridCacheQueriesImpl.`rebuildIndexes(Class<?> cls)` Forces this cache to rebuild all search indexes of given value type.
`IgniteInternalFuture<?>` | CacheQueries.`rebuildIndexes(Class<?> cls)` Forces this cache to rebuild all search indexes of given value type.
`IgniteInternalFuture<?>` | GridCacheQueriesProxy.`rebuildIndexes(Class<?> cls)` Forces this cache to rebuild all search indexes of given value type.
`IgniteInternalFuture<?>` | GridCacheQueryManager.`rebuildIndexes(String typeName)` Rebuilds all search indexes of given value type.
`IgniteInternalFuture<?>` | GridCacheQueriesImpl.`rebuildIndexes(String typeName)` Forces this cache to rebuild all search indexes of given value type.
`IgniteInternalFuture<?>` | CacheQueries.`rebuildIndexes(String typeName)` Forces this cache to rebuild all search indexes of given value type.
`IgniteInternalFuture<?>` | GridCacheQueriesProxy.`rebuildIndexes(String typeName)` Forces this cache to rebuild all search indexes of given value type.

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

Methods in org.apache.ignite.internal.processors.cache.transactions that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<T>` | IgniteTxLocalAdapter.PostLockClosure1.`apply(Boolean locked, Exception e)` Closure body.
`IgniteInternalFuture<T>` | IgniteTxLocalAdapter.PostLockClosure2.`apply(Boolean locked, Exception e)` Closure body.
`IgniteInternalFuture<T>` | IgniteTxLocalAdapter.PostMissClosure.`apply(T t, Exception e)` Closure body.
`IgniteInternalFuture<?>` | IgniteTxManager.`awaitFinishAckAsync(UUID rmtNodeId, long threadId)` Asynchronously waits for last finish request ack.
`IgniteInternalFuture<IgniteInternalTx>` | IgniteInternalTx.`commitAsync()` Asynchronously commits this transaction by initiating `two-phase-commit` process.

`protected IgniteInternalFuture<Set<K>>`

IgniteTxLocalAdapter.`enlistWrite(GridCacheContext<K,V> cacheCtx, Collection<? extends K> keys, GridCacheEntryEx<K,V> cached, javax.cache.expiry.ExpiryPolicy expiryPlc, boolean implicit, Map<? extends K,? extends V> lookup, Map<? extends K,javax.cache.processor.EntryProcessor<K,V,Object>> invokeMap, Object[] invokeArgs, boolean retval, boolean lockOnly, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter, GridCacheReturn<V> ret, Collection<K> enlisted, Map<? extends K,GridCacheDrInfo<V>> drPutMap, Map<? extends K,GridCacheVersion> drRmvMap)`
Internal routine for `putAll(..)`

`IgniteInternalFuture<IgniteInternalTx>` | IgniteTxHandler.`finish(UUID nodeId, GridNearTxLocal<K,V> locTx, GridNearTxFinishRequest<K,V> req)`
`IgniteInternalFuture<IgniteInternalTx>` | IgniteTxHandler.`finishColocatedLocal(boolean commit, GridNearTxLocal<K,V> tx)`
`IgniteInternalFuture<IgniteInternalTx>` | IgniteTxAdapter.`finishFuture()`
`IgniteInternalFuture<IgniteInternalTx>` | IgniteInternalTx.`finishFuture()`
`IgniteInternalFuture<Boolean>` | IgniteTxManager.`finishTxs(long topVer)` Creates a future that will wait for all ongoing transactions that maybe affected by topology update to be finished.
`IgniteInternalFuture<Map<K,V>>` | IgniteTxLocalEx.`getAllAsync(GridCacheContext<K,V> cacheCtx, Collection<? extends K> keys, GridCacheEntryEx<K,V> cached, boolean deserializePortable, boolean skipVals)`
`IgniteInternalFuture<Map<K,V>>` | IgniteTxLocalAdapter.`getAllAsync(GridCacheContext<K,V> cacheCtx, Collection<? extends K> keys, GridCacheEntryEx<K,V> cached, boolean deserializePortable, boolean skipVals)`
`IgniteInternalFuture<?>` | IgniteTxLocalEx.`groupLockAsync(GridCacheContext<K,V> cacheCtx, Collection<K> keys)` Performs keys locking for affinity-based group lock transactions.
`IgniteInternalFuture<?>` | IgniteTxLocalAdapter.`groupLockAsync(GridCacheContext<K,V> cacheCtx, Collection<K> keys)` Performs keys locking for affinity-based group lock transactions.
`<T> IgniteInternalFuture<GridCacheReturn<Map<K,javax.cache.processor.EntryProcessorResult<T>>>>` | IgniteTxLocalEx.`invokeAsync(GridCacheContext<K,V> cacheCtx, Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,Object>> map, Object... invokeArgs)`
`<T> IgniteInternalFuture<GridCacheReturn<Map<K,javax.cache.processor.EntryProcessorResult<T>>>>` | IgniteTxLocalAdapter.`invokeAsync(GridCacheContext<K,V> cacheCtx, Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,Object>> map, Object... invokeArgs)`
`IgniteInternalFuture<Boolean>` | IgniteTxLocalEx.`loadMissing(GridCacheContext<K,V> cacheCtx, boolean readThrough, boolean async, Collection<? extends K> keys, boolean deserializePortable, boolean skipVals, IgniteBiInClosure<K,V> c)`
`IgniteInternalFuture<Boolean>` | IgniteTxLocalAdapter.`loadMissing(GridCacheContext<K,V> cacheCtx, boolean readThrough, boolean async, Collection<? extends K> keys, boolean deserializePortable, boolean skipVals, IgniteBiInClosure<K,V> c)`
`protected abstract IgniteInternalFuture<T>` | IgniteTxLocalAdapter.PostLockClosure2.`postLock()` Post lock callback.
`protected abstract IgniteInternalFuture<T>` | IgniteTxLocalAdapter.PostMissClosure.`postMiss(T t)` Post lock callback.
`IgniteInternalFuture<IgniteInternalTx<K,V>>` | IgniteInternalTx.`prepareAsync()` Prepare stage.
`IgniteInternalFuture<IgniteInternalTx<K,V>>` | IgniteTxHandler.`prepareTx(UUID nearNodeId, GridNearTxLocal<K,V> locTx, GridNearTxPrepareRequest<K,V> req, IgniteInClosure<GridNearTxPrepareResponse<K,V>> completeCb)`
`IgniteInternalFuture<IgniteInternalTx>` | IgniteTxHandler.`processNearTxFinishRequest(UUID nodeId, GridNearTxFinishRequest<K,V> req)`
`IgniteInternalFuture<IgniteInternalTx<K,V>>` | IgniteTxHandler.`processNearTxPrepareRequest(UUID nearNodeId, GridNearTxPrepareRequest<K,V> req)`
`IgniteInternalFuture<GridCacheReturn<V>>` | IgniteTxLocalEx.`putAllAsync(GridCacheContext<K,V> cacheCtx, Map<? extends K,? extends V> map, boolean retval, GridCacheEntryEx<K,V> cached, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)`
`IgniteInternalFuture<GridCacheReturn<V>>` | IgniteTxLocalAdapter.`putAllAsync(GridCacheContext<K,V> cacheCtx, Map<? extends K,? extends V> map, boolean retval, GridCacheEntryEx<K,V> cached, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)`
`IgniteInternalFuture<?>` | IgniteTxLocalEx.`putAllDrAsync(GridCacheContext<K,V> cacheCtx, Map<? extends K,GridCacheDrInfo<V>> drMap)`
`IgniteInternalFuture<?>` | IgniteTxLocalAdapter.`putAllDrAsync(GridCacheContext<K,V> cacheCtx, Map<? extends K,GridCacheDrInfo<V>> drMap)`
`IgniteInternalFuture<GridCacheReturn<V>>` | IgniteTxLocalEx.`removeAllAsync(GridCacheContext<K,V> cacheCtx, Collection<? extends K> keys, GridCacheEntryEx<K,V> cached, boolean retval, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)`
`IgniteInternalFuture<GridCacheReturn<V>>` | IgniteTxLocalAdapter.`removeAllAsync(GridCacheContext<K,V> cacheCtx, Collection<? extends K> keys, GridCacheEntryEx<K,V> cached, boolean retval, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)`
`IgniteInternalFuture<?>` | IgniteTxLocalEx.`removeAllDrAsync(GridCacheContext<K,V> cacheCtx, Map<? extends K,GridCacheVersion> drMap)`
`IgniteInternalFuture<?>` | IgniteTxLocalAdapter.`removeAllDrAsync(GridCacheContext<K,V> cacheCtx, Map<? extends K,GridCacheVersion> drMap)`
`IgniteInternalFuture<IgniteInternalTx>` | IgniteInternalTx.`rollbackAsync()` Asynchronously rollback this transaction.

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.closure

Methods in org.apache.ignite.internal.processors.closure that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`<T,R> IgniteInternalFuture<Collection<R>>` | GridClosureProcessor.`broadcast(IgniteClosure<T,R> job, T arg, Collection<ClusterNode> nodes)`
`<T,R> IgniteInternalFuture<Collection<R>>` | GridClosureProcessor.`broadcastNoFailover(IgniteClosure<T,R> job, T arg, Collection<ClusterNode> nodes)`
`<R> IgniteInternalFuture<R>` | GridClosureProcessor.`callAsyncNoFailover(GridClosureCallMode mode, Callable<R> job, Collection<ClusterNode> nodes, boolean sys)`
`<R> IgniteInternalFuture<Collection<R>>` | GridClosureProcessor.`callAsyncNoFailover(GridClosureCallMode mode, Collection<? extends Callable<R>> jobs, Collection<ClusterNode> nodes, boolean sys)`
`<R> IgniteInternalFuture<R>` | GridClosureProcessor.`callLocalSafe(Callable<R> c)` Executes closure on system pool.
`<R> IgniteInternalFuture<R>` | GridClosureProcessor.`callLocalSafe(Callable<R> c, boolean sys)` Executes closure on system pool.
`<R> IgniteInternalFuture<R>` | GridClosureProcessor.`callLocalSafe(Callable<R> c, GridClosurePolicy plc)` Companion to `GridClosureProcessor.callLocal(Callable, boolean)` but in case of rejected execution re-runs the closure in the current thread (blocking).
`IgniteInternalFuture<?>` | GridClosureProcessor.`runLocalSafe(Runnable c)` Executes closure on system pool.
`IgniteInternalFuture<?>` | GridClosureProcessor.`runLocalSafe(Runnable c, boolean sys)` Companion to `GridClosureProcessor.runLocal(Runnable, boolean)` but in case of rejected execution re-runs the closure in the current thread (blocking).
`IgniteInternalFuture<?>` | GridClosureProcessor.`runLocalSafe(Runnable c, GridClosurePolicy plc)` Companion to `GridClosureProcessor.runLocal(Runnable, boolean)` but in case of rejected execution re-runs the closure in the current thread (blocking).

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

Methods in org.apache.ignite.internal.processors.continuous that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<UUID>` | GridContinuousProcessor.`startRoutine(GridContinuousHandler hnd, int bufSize, long interval, boolean autoUnsubscribe, IgnitePredicate<ClusterNode> prjPred)`
`IgniteInternalFuture<?>` | GridContinuousProcessor.`stopRoutine(UUID routineId)`

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.dataload

Methods in org.apache.ignite.internal.processors.dataload that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<?>` | IgniteDataLoaderImpl.`internalFuture()`

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.hadoop

Methods in org.apache.ignite.internal.processors.hadoop that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`abstract IgniteInternalFuture<?>` | IgniteHadoopProcessorAdapter.`finishFuture(GridHadoopJobId jobId)` Gets Hadoop job finish future.
`IgniteInternalFuture<?>` | IgniteHadoopNoopProcessor.`finishFuture(GridHadoopJobId jobId)` Gets Hadoop job finish future.
`IgniteInternalFuture<?>` | GridHadoop.`finishFuture(GridHadoopJobId jobId)` Gets Hadoop finish future for particular job.
`abstract IgniteInternalFuture<?>` | IgniteHadoopProcessorAdapter.`submit(GridHadoopJobId jobId, GridHadoopJobInfo jobInfo)` Submits job to job tracker.
`IgniteInternalFuture<?>` | IgniteHadoopNoopProcessor.`submit(GridHadoopJobId jobId, GridHadoopJobInfo jobInfo)` Submits job to job tracker.
`IgniteInternalFuture<?>` | GridHadoop.`submit(GridHadoopJobId jobId, GridHadoopJobInfo jobInfo)` Submits job to job tracker.

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

Methods in org.apache.ignite.internal.processors.igfs that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<?>` | IgfsImpl.`awaitDeletesAsync()` Asynchronously await for all entries existing in trash to be removed.
`IgniteInternalFuture<?>` | IgfsEx.`awaitDeletesAsync()` Asynchronously await for all entries existing in trash to be removed.
`IgniteInternalFuture<?>` | IgfsAsyncImpl.`awaitDeletesAsync()` Asynchronously await for all entries existing in trash to be removed.
`IgniteInternalFuture<byte[]>` | IgfsDataManager.`dataBlock(IgfsFileInfo fileInfo, IgfsPath path, long blockIdx, IgfsReader secReader)` Get data block for specified file ID and block index.
`protected IgniteInternalFuture<byte[]>` | IgfsInputStreamImpl.`dataBlock(IgfsFileInfo fileInfo, long blockIdx)` Get data block for specified block index.
`IgniteInternalFuture<Object>` | IgfsDataManager.`delete(IgfsFileInfo fileInfo)` Delete file's data from data cache.
`IgniteInternalFuture<IgfsMessage>` | IgfsServerHandler.`handleAsync(IgfsClientSession ses, IgfsMessage msg, DataInput in)` Asynchronously handles incoming message.
`IgniteInternalFuture<Boolean>` | IgfsDataManager.`writeStart(IgfsFileInfo fileInfo)` Registers write future in igfs data manager.

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

Methods in org.apache.ignite.internal.processors.query that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<GridCacheSqlResult>` | GridQueryProcessor.`queryTwoStep(String space, GridCacheTwoStepQuery qry)`
`IgniteInternalFuture<GridCacheSqlResult>` | GridQueryIndexing.`queryTwoStep(String space, GridCacheTwoStepQuery qry)` Runs two step query.
`IgniteInternalFuture<GridCacheSqlResult>` | GridQueryProcessor.`queryTwoStep(String space, String sqlQry, Object[] params)`
`IgniteInternalFuture<GridCacheSqlResult>` | GridQueryIndexing.`queryTwoStep(String space, String sqlQry, Object[] params)`
`IgniteInternalFuture<?>` | GridQueryProcessor.`rebuildAllIndexes()` Rebuilds all search indexes for given spi.
`IgniteInternalFuture<?>` | GridQueryProcessor.`rebuildIndexes(String space, String valTypeName)` Rebuilds all search indexes of given value type for given space of spi.

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.rest

Methods in org.apache.ignite.internal.processors.rest that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<GridRestResponse>` | GridRestProtocolHandler.`handleAsync(GridRestRequest req)`

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.rest.handlers

Methods in org.apache.ignite.internal.processors.rest.handlers that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<GridRestResponse>` | GridRestCommandHandler.`handleAsync(GridRestRequest req)`

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.rest.handlers.cache

Methods in org.apache.ignite.internal.processors.rest.handlers.cache that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<GridRestResponse>` | GridCacheCommandHandler.`handleAsync(GridRestRequest req)`
`IgniteInternalFuture<GridRestResponse>` | GridCacheQueryCommandHandler.`handleAsync(GridRestRequest req)`

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.rest.handlers.datastructures

Methods in org.apache.ignite.internal.processors.rest.handlers.datastructures that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<GridRestResponse>` | DataStructuresCommandHandler.`handleAsync(GridRestRequest req)`

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.rest.handlers.task

Methods in org.apache.ignite.internal.processors.rest.handlers.task that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<GridRestResponse>` | GridTaskCommandHandler.`handleAsync(GridRestRequest req)`

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.rest.handlers.top

Methods in org.apache.ignite.internal.processors.rest.handlers.top that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<GridRestResponse>` | GridTopologyCommandHandler.`handleAsync(GridRestRequest req)`

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.rest.handlers.version

Methods in org.apache.ignite.internal.processors.rest.handlers.version that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<GridRestResponse>` | GridVersionCommandHandler.`handleAsync(GridRestRequest req)`

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

Classes in org.apache.ignite.internal.processors.service that implement IgniteInternalFuture
Modifier and Type | Class and Description
--- | ---
`class` | `GridServiceDeploymentFuture` Service deployment future.

Methods in org.apache.ignite.internal.processors.service that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`IgniteInternalFuture<?>` | GridServiceProcessor.`cancel(String name)`
`IgniteInternalFuture<?>` | GridServiceProcessor.`cancelAll()`
`IgniteInternalFuture<?>` | GridServiceProcessor.`deploy(ServiceConfiguration cfg)`
`IgniteInternalFuture<?>` | GridServiceProcessor.`deployClusterSingleton(ClusterGroup prj, String name, Service svc)`
`IgniteInternalFuture<?>` | GridServiceProcessor.`deployKeyAffinitySingleton(String name, Service svc, String cacheName, Object affKey)`
`IgniteInternalFuture<?>` | GridServiceProcessor.`deployMultiple(ClusterGroup prj, String name, Service svc, int totalCnt, int maxPerNodeCnt)`
`IgniteInternalFuture<?>` | GridServiceProcessor.`deployNodeSingleton(ClusterGroup prj, String name, Service svc)`

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.streamer

Classes in org.apache.ignite.internal.processors.streamer that implement IgniteInternalFuture
Modifier and Type | Class and Description
--- | ---
`class` | `GridStreamerStageExecutionFuture` Streamer execution future.

### Uses of IgniteInternalFuture in org.apache.ignite.internal.util

Methods in org.apache.ignite.internal.util with parameters of type IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`static void` | IgniteUtils.`asyncLogError(IgniteInternalFuture<?> f, IgniteLogger log)` Adds listener to asynchronously log errors.

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

Classes in org.apache.ignite.internal.util.future that implement IgniteInternalFuture
Modifier and Type | Class and Description
--- | ---
`class` | `GridCompoundFuture<T,R>` Future composed of multiple inner futures.
`class` | `GridCompoundIdentityFuture<T>` Future composed of multiple inner futures.
`class` | `GridEmbeddedFuture<A,B>` Future which waits for embedded future to complete and then asynchronously executes provided closure with embedded future result.
`class` | `GridFinishedFuture<T>` Future that is completed at creation time.
`class` | `GridFinishedFutureEx<T>` Future that is completed at creation time.
`class` | `GridFutureAdapter<R>` Future adapter.
`class` | `GridFutureAdapterEx<R>` Future adapter without kernal context.

Fields in org.apache.ignite.internal.util.future declared as IgniteInternalFuture
Modifier and Type | Field and Description
--- | ---
`protected IgniteInternalFuture<V>` | IgniteFutureImpl.`fut`

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

Methods in org.apache.ignite.internal.util.future that return types with arguments of type IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`Collection<IgniteInternalFuture<T>>` | GridCompoundFuture.`futures()` Gets collection of futures.
`Collection<IgniteInternalFuture<T>>` | GridCompoundFuture.`pending()` Gets pending (unfinished) futures.

Methods in org.apache.ignite.internal.util.future with parameters of type IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridCompoundFuture.`add(IgniteInternalFuture<T> fut)` Adds a future to this compound future.
`void` | GridCompoundFuture.`addAll(IgniteInternalFuture<T>... futs)` Adds futures to this compound future.
`void` | GridFutureChainListener.`apply(IgniteInternalFuture<T> t)` Closure body.

Method parameters in org.apache.ignite.internal.util.future with type arguments of type IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`void` | GridCompoundFuture.`addAll(Iterable<IgniteInternalFuture<T>> futs)` Adds futures to this compound future.
`<T> IgniteInternalFuture<T>` | GridFutureAdapter.`chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb)` Make a chained future to convert result of this future (when complete) into a new format.
`<T> IgniteInternalFuture<T>` | GridFutureAdapterEx.`chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb)` Make a chained future to convert result of this future (when complete) into a new format.
`<R> IgniteInternalFuture<R>` | GridFinishedFutureEx.`chain(IgniteClosure<? super IgniteInternalFuture<T>,R> doneCb)` Make a chained future to convert result of this future (when complete) into a new format.
`<R> IgniteInternalFuture<R>` | GridFinishedFuture.`chain(IgniteClosure<? super IgniteInternalFuture<T>,R> doneCb)` Make a chained future to convert result of this future (when complete) into a new format.
`void` | GridFutureAdapter.`listenAsync(IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)` Registers listener closure to be asynchronously notified whenever future completes.
`void` | GridFutureAdapterEx.`listenAsync(IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)` Registers listener closure to be asynchronously notified whenever future completes.
`void` | GridFinishedFutureEx.`listenAsync(IgniteInClosure<? super IgniteInternalFuture<T>> lsnr)` Registers listener closure to be asynchronously notified whenever future completes.
`void` | GridFinishedFuture.`listenAsync(IgniteInClosure<? super IgniteInternalFuture<T>> lsnr)` Registers listener closure to be asynchronously notified whenever future completes.

Constructors in org.apache.ignite.internal.util.future with parameters of type IgniteInternalFuture
Constructor and Description
`GridEmbeddedFuture(boolean syncNotify, IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c, GridKernalContext ctx)` Embeds futures.
`GridEmbeddedFuture(GridKernalContext ctx, IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,A> c)`
`GridEmbeddedFuture(GridKernalContext ctx, IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c1, IgniteBiClosure<A,Exception,A> c2)` Embeds futures.
`GridEmbeddedFuture(IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c, GridKernalContext ctx)` Embeds futures.
`IgniteFutureImpl(IgniteInternalFuture<V> fut)`

Constructor parameters in org.apache.ignite.internal.util.future with type arguments of type IgniteInternalFuture
Constructor and Description
`GridCompoundFuture(GridKernalContext ctx, IgniteReducer<T,R> rdc, Iterable<IgniteInternalFuture<T>> futs)`
`GridEmbeddedFuture(boolean syncNotify, IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c, GridKernalContext ctx)` Embeds futures.
`GridEmbeddedFuture(GridKernalContext ctx, IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c1, IgniteBiClosure<A,Exception,A> c2)` Embeds futures.
`GridEmbeddedFuture(IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c, GridKernalContext ctx)` Embeds futures.
`GridFutureChainListener(GridKernalContext ctx, GridFutureAdapter<R> fut, IgniteClosure<? super IgniteInternalFuture<T>,R> doneCb)` Constructs chain listener.

### Uses of IgniteInternalFuture in org.apache.ignite.internal.util.lang

Methods in org.apache.ignite.internal.util.lang that return IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`static <T> IgniteInternalFuture<T>` | GridFunc.`awaitOne(IgniteInternalFuture<T>... futs)` Waits for one completed future from passed and returns it.
`static <T> IgniteInternalFuture<T>` | GridFunc.`awaitOne(Iterable<IgniteInternalFuture<T>> futs)` Waits for the first completed future from passed and returns it.

Methods in org.apache.ignite.internal.util.lang that return types with arguments of type IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`static <T> IgniteClosure<IgniteInternalFuture<T>,Future<T>>` | GridFunc.`future()` Gets closure that converts `IgniteInternalFuture` to `Future`.
`static IgnitePredicate<IgniteInternalFuture<?>>` | GridFunc.`unfinishedFutures()` Returns predicate for filtering unfinished futures.

Methods in org.apache.ignite.internal.util.lang with parameters of type IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`static <T> Future<T>` | GridFunc.`as(IgniteInternalFuture<T> fut)` Converts given object with interface `IgniteInternalFuture` into an object implementing `Future`.
`static <T> void` | GridFunc.`awaitAll(IgniteInternalFuture<T>... futs)` Waits until all passed futures will be executed.
`static <T> IgniteInternalFuture<T>` | GridFunc.`awaitOne(IgniteInternalFuture<T>... futs)` Waits for one completed future from passed and returns it.

Method parameters in org.apache.ignite.internal.util.lang with type arguments of type IgniteInternalFuture
Modifier and Type | Method and Description
--- | ---
`static <T> void` | GridFunc.`awaitAll(Collection<IgniteInternalFuture<T>> futs)` Waits until all passed futures will be executed.
`static <T> void` | GridFunc.`awaitAll(long timeout, Collection<IgniteInternalFuture<T>> futs)` Waits until all passed futures will be executed.
`static <T,R> R` | GridFunc.`awaitAll(long timeout, IgniteReducer<T,R> rdc, Collection<IgniteInternalFuture<T>> futs)` Awaits for all futures to complete and optionally reduces all results into one.
`static <T> IgniteInternalFuture<T>` | GridFunc.`awaitOne(Iterable<IgniteInternalFuture<T>> futs)` Waits for the first completed future from passed and returns it.

### Uses of IgniteInternalFuture in org.apache.ignite.internal.util.worker

Classes in org.apache.ignite.internal.util.worker that implement IgniteInternalFuture
Modifier and Type | Class and Description
--- | ---
`class` | `GridWorkerFuture<T>` Future for locally executed closure that defines cancellation logic.

2015 Copyright © Apache Software Foundation

Follow @ApacheIgnite

Ignite Fabric | : ver. 1.0.0-RC1
Release Date | : February 17 2015