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

Packages that use IgniteInternalFuture
org.apache.ignite.internal: Contains main implementation.
org.apache.ignite.internal.cluster
org.apache.ignite.internal.managers: TODO.
org.apache.ignite.internal.managers.communication: TODO.
org.apache.ignite.internal.managers.deployment: TODO.
org.apache.ignite.internal.managers.discovery: TODO.
org.apache.ignite.internal.managers.eventstorage: TODO.
org.apache.ignite.internal.processors: 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.persistence
org.apache.ignite.internal.processors.cache.persistence.pagemem
org.apache.ignite.internal.processors.cache.persistence.snapshot
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.cluster
org.apache.ignite.internal.processors.continuous
org.apache.ignite.internal.processors.datastreamer: Data streamer processor.
org.apache.ignite.internal.processors.datastructures
org.apache.ignite.internal.processors.hadoop: Contains Hadoop APIs.
org.apache.ignite.internal.processors.igfs: Contains high performance file system processor.
org.apache.ignite.internal.processors.platform
org.apache.ignite.internal.processors.platform.compute
org.apache.ignite.internal.processors.platform.utils
org.apache.ignite.internal.processors.query
org.apache.ignite.internal.processors.query.schema
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.cluster
org.apache.ignite.internal.processors.rest.handlers.datastructures
org.apache.ignite.internal.processors.rest.handlers.log
org.apache.ignite.internal.processors.rest.handlers.query
org.apache.ignite.internal.processors.rest.handlers.redis: Contains Redis protocol commands.
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.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.nio: NIO server interfaces and common utility classes for NIO.
org.apache.ignite.internal.util.worker: Common utility classes for threads.
org.apache.ignite.spi.communication.tcp: Contains default TCP/IP-based implementation for communication SPI.

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

Classes in org.apache.ignite.internal that implement IgniteInternalFuture
`class` `ComputeTaskInternalFuture<R>` This class provide implementation for task future.

Methods in org.apache.ignite.internal that return IgniteInternalFuture
`<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.
`<T> IgniteInternalFuture<T>` IgniteInternalFuture.`chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb, Executor exec)` Make a chained future to convert result of this future (when complete) into a new format.
`IgniteInternalFuture<Boolean>` IgniteKernal.`destroyCacheAsync(String cacheName, boolean sql, boolean checkThreadTx)`
`IgniteInternalFuture<?>` IgniteKernal.`destroyCachesAsync(Collection<String> cacheNames, boolean checkThreadTx)`
`static IgniteInternalFuture<String>` IgniteDiagnosticMessage.`dumpCommunicationInfo(GridKernalContext ctx, UUID nodeId)`
`IgniteInternalFuture<?>` IgniteKernal.`getOrCreateCacheAsync(String cacheName, boolean checkThreadTx)`
`IgniteInternalFuture<?>` GridComponent.`onReconnected(boolean clusterRestarted)` Client reconnected callback.
`IgniteInternalFuture<?>` GridPluginComponent.`onReconnected(boolean clusterRestarted)` Client reconnected callback.
`IgniteInternalFuture` IgniteKernal.`sendIoTest(ClusterNode node, byte[] payload, boolean procFromNioThread)`
`IgniteInternalFuture` IgniteKernal.`sendIoTest(List<ClusterNode> nodes, byte[] payload, boolean procFromNioThread)`

Methods in org.apache.ignite.internal with parameters of type IgniteInternalFuture
`protected <R> IgniteFuture<R>` IgniteComputeImpl.`createFuture(IgniteInternalFuture<R> fut)`
`protected <R> IgniteFuture<R>` AsyncSupportAdapter.`createFuture(IgniteInternalFuture<R> fut)`
`<R> R` AsyncSupportAdapter.`saveOrGet(IgniteInternalFuture<R> fut)`

Method parameters in org.apache.ignite.internal with type arguments of type IgniteInternalFuture
`<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.
`<T> IgniteInternalFuture<T>` IgniteInternalFuture.`chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb, Executor exec)` Make a chained future to convert result of this future (when complete) into a new format.
`void` IgniteInternalFuture.`listen(IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)` Registers listener closure to be asynchronously notified whenever future completes.
`void` IgniteDiagnosticPrepareContext.`send(GridKernalContext ctx, IgniteInClosure<IgniteInternalFuture<String>> lsnr)`

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

Methods in org.apache.ignite.internal.cluster that return IgniteInternalFuture
`IgniteInternalFuture<?>` ClusterTopologyCheckedException.`retryReadyFuture()`

Methods in org.apache.ignite.internal.cluster with parameters of type IgniteInternalFuture
`void` ClusterTopologyCheckedException.`retryReadyFuture(IgniteInternalFuture<?> readyFut)`

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

Methods in org.apache.ignite.internal.managers that return IgniteInternalFuture
`IgniteInternalFuture<?>` GridManagerAdapter.`onReconnected(boolean clusterRestarted)` Client reconnected callback.

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

Methods in org.apache.ignite.internal.managers.communication that return IgniteInternalFuture
`IgniteInternalFuture<List<IgniteIoTestMessage>>` GridIoManager.`sendIoTest(ClusterNode node, byte[] payload, boolean procFromNioThread)`
`IgniteInternalFuture` GridIoManager.`sendIoTest(List<ClusterNode> nodes, byte[] payload, boolean procFromNioThread)`

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

Methods in org.apache.ignite.internal.managers.deployment that return IgniteInternalFuture
`IgniteInternalFuture<?>` GridDeploymentManager.`onReconnected(boolean clusterRestarted)` Client reconnected callback.

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

Methods in org.apache.ignite.internal.managers.discovery that return IgniteInternalFuture
`IgniteInternalFuture<Long>` GridDiscoveryManager.`topologyFuture(long awaitVer)` Gets future that will be completed when current topology version becomes greater or equal to argument passed.
`IgniteInternalFuture<Boolean>` DiscoveryLocalJoinData.`transitionWaitFuture()`

Constructors in org.apache.ignite.internal.managers.discovery with parameters of type IgniteInternalFuture
Constructor and Description
`DiscoveryLocalJoinData(DiscoveryEvent evt, DiscoCache discoCache, IgniteInternalFuture<Boolean> transitionWaitFut, boolean active)`

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

Methods in org.apache.ignite.internal.managers.eventstorage that return IgniteInternalFuture
`<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

Methods in org.apache.ignite.internal.processors that return IgniteInternalFuture
`IgniteInternalFuture<?>` GridProcessorAdapter.`onReconnected(boolean clusterRestarted)` Client reconnected callback.

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

Methods in org.apache.ignite.internal.processors.affinity that return IgniteInternalFuture
`IgniteInternalFuture<AffinityTopologyVersion>` GridAffinityAssignmentCache.`readyFuture(AffinityTopologyVersion 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
`interface` `GridCacheAtomicFuture<R>` Update future for atomic cache.
`interface` `GridCacheFuture<R>` This interface should be implemented by all distributed futures.
`interface` `GridCacheVersionedFuture<T>` Distributed future aware of lock version.

Classes in org.apache.ignite.internal.processors.cache that implement IgniteInternalFuture
`class` `CacheObjectsReleaseFuture<T,R>`
`class` `GridCacheCompoundFuture<T,R>`
`class` `GridCacheCompoundIdentityFuture<T>`
`class` `GridCacheFutureAdapter<R>`
`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
`IgniteInternalFuture<AffinityTopologyVersion>` GridCacheAffinityManager.`affinityReadyFuture(AffinityTopologyVersion topVer)` Gets affinity ready future, a future that will be completed after affinity with given topology version is calculated.
`IgniteInternalFuture<?>` GridCachePartitionExchangeManager.`affinityReadyFuture(AffinityTopologyVersion ver)`
`IgniteInternalFuture<AffinityTopologyVersion>` GridCacheAffinityManager.`affinityReadyFuture(long topVer)` Gets affinity ready future, a future that will be completed after affinity with given topology version is calculated.
`IgniteInternalFuture<AffinityTopologyVersion>` GridCacheAffinityManager.`affinityReadyFuturex(AffinityTopologyVersion topVer)` Gets affinity ready future that will be completed after affinity with given topology version is calculated.
`protected <T> IgniteInternalFuture<T>` GridCacheAdapter.`asyncOp(GridNearTxLocal tx, GridCacheAdapter.AsyncOp<T> op, CacheOperationContext opCtx, boolean retry)`
`protected <T> IgniteInternalFuture<T>` GridCacheAdapter.`asyncOpAcquire(boolean retry)` Tries to acquire asynchronous operations permit, if limited.
`IgniteInternalFuture<?>` GridCacheMvccManager.`atomicFuture(long futId)` Gets future by given future ID.
`IgniteInternalFuture<Boolean>` GridCacheProcessor.`changeWalMode(Collection<String> cacheNames, boolean enabled)` Change WAL mode.
`IgniteInternalFuture<?>` IgniteInternalCache.`clearAllAsync(Set<? extends K> keys)`
`IgniteInternalFuture<?>` GridCacheProxyImpl.`clearAllAsync(Set<? extends K> keys)`
`IgniteInternalFuture<?>` GridCacheAdapter.`clearAllAsync(Set<? extends K> keys)`
`IgniteInternalFuture<?>` IgniteInternalCache.`clearAsync()`
`IgniteInternalFuture<?>` GridCacheProxyImpl.`clearAsync()`
`IgniteInternalFuture<?>` GridCacheAdapter.`clearAsync()`
`IgniteInternalFuture<?>` IgniteInternalCache.`clearAsync(K key)`
`IgniteInternalFuture<?>` GridCacheProxyImpl.`clearAsync(K key)`
`IgniteInternalFuture<?>` GridCacheAdapter.`clearAsync(K key)`
`IgniteInternalFuture<IgniteInternalTx>` GridCacheSharedContext.`commitTxAsync(GridNearTxLocal tx)`
`IgniteInternalFuture<Void>` GridCacheAtomicFuture.`completeFuture(AffinityTopologyVersion topVer)` Gets future that will be completed when it is safe when update is finished on the given version of topology.
`IgniteInternalFuture<Boolean>` IgniteInternalCache.`containsKeyAsync(K key)`
`IgniteInternalFuture<Boolean>` GridCacheProxyImpl.`containsKeyAsync(K key)`
`IgniteInternalFuture<Boolean>` GridCacheAdapter.`containsKeyAsync(K key)`
`IgniteInternalFuture<Boolean>` IgniteInternalCache.`containsKeysAsync(Collection<? extends K> keys)`
`IgniteInternalFuture<Boolean>` GridCacheProxyImpl.`containsKeysAsync(Collection<? extends K> keys)`
`IgniteInternalFuture<Boolean>` GridCacheAdapter.`containsKeysAsync(Collection<? extends K> keys)`
`IgniteInternalFuture<?>` GridCacheProcessor.`createFromTemplate(String cacheName)` Dynamically starts cache using template configuration.
`IgniteInternalFuture<Void>` GridCachePartitionExchangeManager.`deferStopCachesOnClientReconnect(Collection<GridCacheAdapter> caches)`
`IgniteInternalFuture<?>` GridCacheProcessor.`dynamicChangeCaches(List<DynamicCacheChangeRequest> reqs)` Starts cache stop request as cache change batch.
`IgniteInternalFuture<Boolean>` GridCacheProcessor.`dynamicDestroyCache(String cacheName, boolean sql, boolean checkThreadTx, boolean restart)`
`IgniteInternalFuture<?>` GridCacheProcessor.`dynamicDestroyCaches(Collection<String> cacheNames, boolean checkThreadTx, boolean restart)`
`IgniteInternalFuture<?>` GridCacheProcessor.`dynamicDestroyCaches(Collection<String> cacheNames, boolean checkThreadTx, boolean restart, boolean destroy)`
`IgniteInternalFuture<Boolean>` GridCacheProcessor.`dynamicStartCache(CacheConfiguration ccfg, String cacheName, NearCacheConfiguration nearCfg, boolean failIfExists, boolean failIfNotStarted, boolean checkThreadTx)` Dynamically starts cache.
`IgniteInternalFuture<Boolean>` GridCacheProcessor.`dynamicStartCache(CacheConfiguration ccfg, String cacheName, NearCacheConfiguration nearCfg, CacheType cacheType, boolean sql, boolean failIfExists, boolean failIfNotStarted, boolean checkThreadTx)` Dynamically starts cache.
`IgniteInternalFuture<?>` GridCacheProcessor.`dynamicStartCaches(Collection<CacheConfiguration> ccfgList, boolean failIfExists, boolean checkThreadTx, boolean disabledAfterStart)` Dynamically starts multiple caches.
`IgniteInternalFuture<Boolean>` GridCacheProcessor.`dynamicStartSqlCache(CacheConfiguration ccfg)` Dynamically starts cache as a result of SQL `CREATE TABLE` command.
`IgniteInternalFuture<?>` GridCacheMvccManager.`finishAtomicUpdates(AffinityTopologyVersion topVer)`
`IgniteInternalFuture<?>` GridCacheMvccManager.`finishDataStreamerUpdates(AffinityTopologyVersion topVer)`
`IgniteInternalFuture<?>` GridCacheMvccManager.`finishExplicitLocks(AffinityTopologyVersion topVer)` Creates a future that will wait for all explicit locks acquired on given topology version to be released.
`IgniteInternalFuture<?>` GridCacheMvccManager.`finishKeys(Collection<KeyCacheObject> keys, int cacheId, AffinityTopologyVersion topVer)`
`IgniteInternalFuture<?>` GridCacheMvccManager.`finishLocks(AffinityTopologyVersion topVer)`
`IgniteInternalFuture<Boolean>` GridCachePreloaderAdapter.`forceRebalance()` Force Rebalance process.
`IgniteInternalFuture<Boolean>` GridCachePreloader.`forceRebalance()` Force Rebalance process.
`IgniteInternalFuture<Boolean>` GridCachePartitionExchangeManager.`forceRebalance(GridDhtPartitionExchangeId exchId)`
`IgniteInternalFuture<GridCacheReturn>` GridCacheReturnCompletableWrapper.`fut()` Allows wait for properly initialized value.
`IgniteInternalFuture` GridCacheAdapter.FutureHolder.`future()` Gets future.
`IgniteInternalFuture<Map<K,V>>` IgniteInternalCache.`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 deserializeBinary, boolean recovery, boolean needVer)`
`protected IgniteInternalFuture<Map<K,V>>` GridCacheAdapter.`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, UUID subjId, String taskName, boolean deserializeBinary, boolean recovery, boolean skipVals, boolean needVer)`
`IgniteInternalFuture<Map<K,V>>` GridCacheAdapter.`getAllAsync(Collection<? extends K> keys, ReaderArguments readerArgs, boolean readThrough, boolean checkTx, UUID subjId, String taskName, boolean deserializeBinary, boolean recovery, boolean forcePrimary, IgniteCacheExpiryPolicy expiry, boolean skipVals, boolean needVer)`
`protected <K1,V1> IgniteInternalFuture<Map<K1,V1>>` GridCacheAdapter.`getAllAsync0(Collection<KeyCacheObject> keys, ReaderArguments readerArgs, boolean readThrough, boolean checkTx, UUID subjId, String taskName, boolean deserializeBinary, IgniteCacheExpiryPolicy expiry, boolean skipVals, boolean keepCacheObjects, boolean recovery, boolean needVer)`
`IgniteInternalFuture<Map<K,V>>` IgniteInternalCache.`getAllOutTxAsync(Set<? extends K> keys)` Gets values from cache.
`IgniteInternalFuture<Map<K,V>>` GridCacheProxyImpl.`getAllOutTxAsync(Set<? extends K> keys)` Gets values from cache.
`IgniteInternalFuture<Map<K,V>>` GridCacheAdapter.`getAllOutTxAsync(Set<? extends K> keys)` Gets values from cache.
`IgniteInternalFuture<V>` IgniteInternalCache.`getAndPutAsync(K key, V val)` Asynchronously stores given key-value pair in cache.
`IgniteInternalFuture<V>` GridCacheProxyImpl.`getAndPutAsync(K key, V val)` Asynchronously stores given key-value pair in cache.
`IgniteInternalFuture<V>` GridCacheAdapter.`getAndPutAsync(K key, V val)` Asynchronously stores given key-value pair in cache.
`protected IgniteInternalFuture<V>` GridCacheAdapter.`getAndPutAsync(K key, V val, CacheEntryPredicate filter)`
`IgniteInternalFuture<V>` GridCacheAdapter.`getAndPutAsync0(K key, V val, CacheEntryPredicate filter)`
`IgniteInternalFuture<V>` IgniteInternalCache.`getAndPutIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<V>` GridCacheProxyImpl.`getAndPutIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<V>` GridCacheAdapter.`getAndPutIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<V>` IgniteInternalCache.`getAndRemoveAsync(K key)` Asynchronously removes given key mapping from cache.
`IgniteInternalFuture<V>` GridCacheProxyImpl.`getAndRemoveAsync(K key)` Asynchronously removes given key mapping from cache.
`IgniteInternalFuture<V>` GridCacheAdapter.`getAndRemoveAsync(K key)` Asynchronously removes given key mapping from cache.
`protected IgniteInternalFuture<V>` GridCacheAdapter.`getAndRemoveAsync0(K key)`
`IgniteInternalFuture<V>` IgniteInternalCache.`getAndReplaceAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
`IgniteInternalFuture<V>` GridCacheProxyImpl.`getAndReplaceAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
`IgniteInternalFuture<V>` GridCacheAdapter.`getAndReplaceAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
`IgniteInternalFuture<V>` IgniteInternalCache.`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 deserializeBinary, boolean needVer)`
`protected IgniteInternalFuture<V>` GridCacheAdapter.`getAsync(K key, boolean forcePrimary, boolean skipTx, UUID subjId, String taskName, boolean deserializeBinary, boolean skipVals, boolean needVer)`
`IgniteInternalFuture<Collection<CacheEntry<K,V>>>` IgniteInternalCache.`getEntriesAsync(Collection<? extends K> keys)` Asynchronously retrieves values mapped to the specified keys from cache.
`IgniteInternalFuture<Collection<CacheEntry<K,V>>>` GridCacheProxyImpl.`getEntriesAsync(Collection<? extends K> keys)` Asynchronously retrieves values mapped to the specified keys from cache.
`IgniteInternalFuture<Collection<CacheEntry<K,V>>>` GridCacheAdapter.`getEntriesAsync(Collection<? extends K> keys)` Asynchronously retrieves values mapped to the specified keys from cache.
`IgniteInternalFuture<CacheEntry<K,V>>` IgniteInternalCache.`getEntryAsync(K key)` Asynchronously retrieves value mapped to the specified key from cache.
`IgniteInternalFuture<CacheEntry<K,V>>` GridCacheProxyImpl.`getEntryAsync(K key)` Asynchronously retrieves value mapped to the specified key from cache.
`IgniteInternalFuture<CacheEntry<K,V>>` GridCacheAdapter.`getEntryAsync(K key)` Asynchronously retrieves value mapped to the specified key from cache.
`IgniteInternalFuture<V>` IgniteInternalCache.`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.
`IgniteInternalFuture<?>` GridCacheProcessor.`getOrCreateFromTemplate(String cacheName, boolean checkThreadTx)` Dynamically starts cache using template configuration.
`IgniteInternalFuture<Boolean>` WalStateManager.`init(Collection<String> cacheNames, boolean enabled)` Initiate WAL mode change operation.
`IgniteInternalFuture<Map<Integer,Map<Integer,List<UUID>>>>` CacheAffinitySharedManager.`initAffinityOnNodeLeft(GridDhtPartitionsExchangeFuture fut)`
`IgniteInternalFuture<?>` CacheAffinitySharedManager.`initCoordinatorCaches(GridDhtPartitionsExchangeFuture fut, boolean newAff)`
`<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>` IgniteInternalCache.`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>>>` IgniteInternalCache.`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>>` IgniteInternalCache.`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<?>` IgniteInternalCache.`localLoadCacheAsync(IgniteBiPredicate<K,V> p, Object... args)` Asynchronously delegates to `CacheStore.loadCache(IgniteBiInClosure, Object...)` method to reload state from the underlying persistent storage.
`IgniteInternalFuture<?>` GridCacheProxyImpl.`localLoadCacheAsync(IgniteBiPredicate<K,V> p, Object[] args)` Asynchronously delegates to `CacheStore.loadCache(IgniteBiInClosure, Object...)` method to reload state from the underlying persistent storage.
`IgniteInternalFuture<?>` GridCacheAdapter.`localLoadCacheAsync(IgniteBiPredicate<K,V> p, Object[] args)` Asynchronously delegates to `CacheStore.loadCache(IgniteBiInClosure, Object...)` method to reload state from the underlying persistent storage.
`IgniteInternalFuture<Boolean>` IgniteInternalCache.`lockAllAsync(Collection<? extends K> keys, long timeout)` All or nothing synchronous lock for passed in keys.
`IgniteInternalFuture<Boolean>` GridCacheProxyImpl.`lockAllAsync(Collection<? extends K> keys, long timeout)` All or nothing synchronous lock for passed in keys.
`IgniteInternalFuture<Boolean>` IgniteInternalCache.`lockAsync(K key, long timeout)` 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)` 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)` Asynchronously acquires lock on a cached object with given key only if the passed in filter (if any) passes.
`IgniteInternalFuture<?>` GridCacheSharedContext.`nextAffinityReadyFuture(AffinityTopologyVersion curVer)` Gets ready future for the next affinity topology version (used in cases when a node leaves grid).
`IgniteInternalFuture<?>` GridCacheProcessor.`onReconnected(boolean clusterRestarted)` Client reconnected callback.
`abstract IgniteInternalFuture<T>` GridCacheAdapter.AsyncOp.`op(GridNearTxLocal tx, AffinityTopologyVersion readyTopVer)`
`IgniteInternalFuture<T>` GridCacheAdapter.AsyncOp.`op(GridNearTxLocal tx, CacheOperationContext opCtx)`
`IgniteInternalFuture<?>` GridCacheSharedContext.`partitionReleaseFuture(AffinityTopologyVersion topVer)` Captures all ongoing operations that we need to wait before we can proceed to the next topology version.
`IgniteInternalFuture<?>` IgniteInternalCache.`putAllAsync(Map<? extends K,? extends V> m)` Asynchronously stores given key-value pairs in cache.
`IgniteInternalFuture<?>` GridCacheProxyImpl.`putAllAsync(Map<? extends K,? extends V> m)` Asynchronously stores given key-value pairs in cache.
`IgniteInternalFuture<?>` GridCacheAdapter.`putAllAsync(Map<? extends K,? extends V> m)` Asynchronously stores given key-value pairs in cache.
`protected IgniteInternalFuture<?>` GridCacheAdapter.`putAllAsync0(Map<? extends K,? extends V> m)`
`IgniteInternalFuture<?>` IgniteInternalCache.`putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)` Store DR data asynchronously.
`IgniteInternalFuture<?>` GridCacheProxyImpl.`putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)` Store DR data asynchronously.
`IgniteInternalFuture<?>` GridCacheAdapter.`putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)` Store DR data asynchronously.
`IgniteInternalFuture<Boolean>` IgniteInternalCache.`putAsync(K key, V val)` Stores given key-value pair in cache.
`IgniteInternalFuture<Boolean>` GridCacheProxyImpl.`putAsync(K key, V val)` Stores given key-value pair in cache.
`IgniteInternalFuture<Boolean>` GridCacheAdapter.`putAsync(K key, V val)` Stores given key-value pair in cache.
`IgniteInternalFuture<Boolean>` GridCacheAdapter.`putAsync(K key, V val, CacheEntryPredicate filter)`
`IgniteInternalFuture<Boolean>` GridCacheAdapter.`putAsync0(K key, V val, CacheEntryPredicate filter)`
`IgniteInternalFuture<Boolean>` IgniteInternalCache.`putIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<Boolean>` GridCacheProxyImpl.`putIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<Boolean>` GridCacheAdapter.`putIfAbsentAsync(K key, V val)` Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
`IgniteInternalFuture<?>` IgniteInternalCache.`rebalance()` Forces this cache node to re-balance its partitions.
`IgniteInternalFuture<?>` GridCacheProxyImpl.`rebalance()` Forces this cache node to re-balance its partitions.
`IgniteInternalFuture<?>` GridCacheAdapter.`rebalance()` Forces this cache node to re-balance its partitions.
`IgniteInternalFuture<Boolean>` GridCachePreloaderAdapter.`rebalanceFuture()`
`IgniteInternalFuture<Boolean>` GridCachePreloader.`rebalanceFuture()`
`IgniteInternalFuture<?>` GridCachePartitionExchangeManager.`reconnectExchangeFuture()`
`IgniteInternalFuture<Object>` GridCacheExplicitLockSpan.`releaseFuture()` Gets span release future.
`IgniteInternalFuture<?>` IgniteInternalCache.`removeAllAsync()`
`IgniteInternalFuture<?>` GridCacheProxyImpl.`removeAllAsync()`
`IgniteInternalFuture<?>` IgniteInternalCache.`removeAllAsync(Collection<? extends K> keys)` Asynchronously removes given key mappings from cache for entries.
`IgniteInternalFuture<?>` GridCacheProxyImpl.`removeAllAsync(Collection<? extends K> keys)` Asynchronously removes given key mappings from cache for entries.
`IgniteInternalFuture<?>` GridCacheAdapter.`removeAllAsync(Collection<? extends K> keys)` Asynchronously removes given key mappings from cache for entries.
`protected IgniteInternalFuture<Object>` GridCacheAdapter.`removeAllAsync0(Collection<? extends K> keys)`
`IgniteInternalFuture<?>` IgniteInternalCache.`removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)` Removes DR data asynchronously.
`IgniteInternalFuture<?>` GridCacheProxyImpl.`removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)` Removes DR data asynchronously.
`IgniteInternalFuture<?>` GridCacheAdapter.`removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)` Removes DR data asynchronously.
`IgniteInternalFuture<Boolean>` IgniteInternalCache.`removeAsync(K key)` Asynchronously removes given key mapping from cache.
`IgniteInternalFuture<Boolean>` GridCacheProxyImpl.`removeAsync(K key)` Asynchronously removes given key mapping from cache.
`IgniteInternalFuture<Boolean>` GridCacheAdapter.`removeAsync(K key)` Asynchronously removes given key mapping from cache.
`IgniteInternalFuture<Boolean>` GridCacheAdapter.`removeAsync(K key, CacheEntryPredicate filter)`
`IgniteInternalFuture<Boolean>` IgniteInternalCache.`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.
`protected IgniteInternalFuture<Boolean>` GridCacheAdapter.`removeAsync0(K key, CacheEntryPredicate filter)`
`IgniteInternalFuture<?>` GridCacheMvccManager.`removeAtomicFuture(long futId)`
`IgniteInternalFuture<Boolean>` IgniteInternalCache.`replaceAsync(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.`replaceAsync(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.`replaceAsync(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>` IgniteInternalCache.`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<?>` GridCacheProcessor.`resetCacheState(Collection<String> cacheNames)` Resets cache state after the cache has been moved to recovery state.
`IgniteInternalFuture` GridCacheSharedContext.`rollbackTxAsync(GridNearTxLocal tx)`
`IgniteInternalFuture<Integer>` IgniteInternalCache.`sizeAsync(CachePeekMode[] peekModes)`
`IgniteInternalFuture<Integer>` GridCacheProxyImpl.`sizeAsync(CachePeekMode[] peekModes)`
`IgniteInternalFuture<Integer>` GridCacheAdapter.`sizeAsync(CachePeekMode[] peekModes)`
`IgniteInternalFuture<Long>` IgniteInternalCache.`sizeLongAsync(CachePeekMode[] peekModes)`
`IgniteInternalFuture<Long>` GridCacheProxyImpl.`sizeLongAsync(CachePeekMode[] peekModes)`
`IgniteInternalFuture<Long>` GridCacheAdapter.`sizeLongAsync(CachePeekMode[] peekModes)`
`IgniteInternalFuture<Long>` IgniteInternalCache.`sizeLongAsync(int partition, CachePeekMode[] peekModes)`
`IgniteInternalFuture<Long>` GridCacheProxyImpl.`sizeLongAsync(int partition, CachePeekMode[] peekModes)`
`IgniteInternalFuture<Long>` GridCacheAdapter.`sizeLongAsync(int part, CachePeekMode[] peekModes)`
`IgniteInternalFuture<Object>` GridCachePreloaderAdapter.`startFuture()`
`IgniteInternalFuture<Object>` GridCachePreloader.`startFuture()`
`IgniteInternalFuture<?>` GridCachePreloaderAdapter.`syncFuture()`
`IgniteInternalFuture<?>` GridCachePreloader.`syncFuture()`
`abstract IgniteInternalFuture<Boolean>` GridCacheAdapter.`txLockAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isRead, boolean retval, TransactionIsolation isolation, boolean invalidate, long createTtl, long accessTtl)`

Methods in org.apache.ignite.internal.processors.cache that return types with arguments of type IgniteInternalFuture
`static IgniteInClosure<IgniteInternalFuture<?>>` GridCacheUtils.`errorLogger(IgniteLogger log, Class<? extends Exception>... excl)`

Methods in org.apache.ignite.internal.processors.cache with parameters of type IgniteInternalFuture
`void` GridCacheAdapter.UpdateTimeStatClosure.`apply(IgniteInternalFuture<T> fut)` Closure body.
`protected <R> IgniteFuture<R>` IgniteCacheProxyImpl.`createFuture(IgniteInternalFuture<R> fut)`
`void` GridCacheAdapter.FutureHolder.`future(IgniteInternalFuture fut)` Sets future.
`protected void` GridCacheAdapter.`saveFuture(GridCacheAdapter.FutureHolder holder, IgniteInternalFuture<?> fut, boolean retry)` Saves future in thread local holder and adds listener that will clear holder when future is finished.

Constructors in org.apache.ignite.internal.processors.cache with parameters of type IgniteInternalFuture
Constructor and Description
`IgniteCacheFutureImpl(IgniteInternalFuture<V> fut)` Constructor.

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

Classes in org.apache.ignite.internal.processors.cache.distributed that implement IgniteInternalFuture
`class` `GridCacheTxRecoveryFuture` Future verifying that all remote transactions related to transaction were prepared or committed.

Methods in org.apache.ignite.internal.processors.cache.distributed that return IgniteInternalFuture
`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)` All or nothing synchronous lock for passed in keys.
`protected abstract IgniteInternalFuture<Boolean>` GridDistributedCacheAdapter.`lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long createTtl, long accessTtl)`
`IgniteInternalFuture<?>` GridDistributedCacheAdapter.`removeAllAsync()`
`IgniteInternalFuture<IgniteInternalTx>` GridDistributedTxRemoteAdapter.`rollbackAsync()` Asynchronously rollback this transaction.
`IgniteInternalFuture<?>` GridDistributedTxRemoteAdapter.`salvageTx()`
`IgniteInternalFuture<Boolean>` GridDistributedCacheAdapter.`txLockAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isRead, boolean retval, TransactionIsolation isolation, boolean isInvalidate, long createTtl, long accessTtl)`

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

Subinterfaces of IgniteInternalFuture in org.apache.ignite.internal.processors.cache.distributed.dht
`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
`class` `CacheDistributedGetFutureAdapter<K,V>`
`class` `ClientCacheDhtTopologyFuture` Topology future created for client cache start.
`class` `GridDhtAssignmentFetchFuture` 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` `GridDhtGetSingleFuture<K,V>`
`class` `GridDhtLockFuture` Cache lock future.
`class` `GridDhtTopologyFutureAdapter`
`class` `GridDhtTxFinishFuture<K,V>`
`class` `GridDhtTxPrepareFuture`
`class` `GridPartitionedGetFuture<K,V>` Colocated get future.
`class` `GridPartitionedSingleGetFuture`

Methods in org.apache.ignite.internal.processors.cache.distributed.dht that return IgniteInternalFuture
`IgniteInternalFuture<Boolean>` GridDhtTxLocalAdapter.`addEntry(long msgId, IgniteTxEntry e)`
`protected IgniteInternalFuture<Boolean>` GridDhtTxLocal.`addReader(long msgId, GridDhtCacheEntry cached, IgniteTxEntry entry, AffinityTopologyVersion topVer)` Adds reader to cached entry.
`protected abstract IgniteInternalFuture<Boolean>` GridDhtTxLocalAdapter.`addReader(long msgId, GridDhtCacheEntry cached, IgniteTxEntry entry, AffinityTopologyVersion topVer)` Adds reader to cached entry.
`IgniteInternalFuture<Boolean>` GridDhtCacheEntry.`addReader(UUID nodeId, long msgId, AffinityTopologyVersion topVer)`
`protected IgniteInternalFuture<GridNearTxPrepareResponse>` GridDhtTxLocalAdapter.`chainOnePhasePrepare(GridDhtTxPrepareFuture prepFut)`
`IgniteInternalFuture<IgniteInternalTx>` GridDhtTxLocal.`commitAsync()` Asynchronously commits this transaction by initiating `two-phase-commit` process.
`IgniteInternalFuture<IgniteInternalTx>` GridDhtTxLocal.`commitDhtLocalAsync()`
`IgniteInternalFuture<?>` GridDhtTxLocal.`currentPrepareFuture()`
`IgniteInternalFuture<Map<K,V>>` GridDhtCacheAdapter.`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, UUID subjId, String taskName, boolean deserializeBinary, boolean recovery, boolean skipVals, boolean needVer)`
`IgniteInternalFuture<Boolean>` GridDhtTransactionalCacheAdapter.`lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx txx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long createTtl, long accessTtl)`
`IgniteInternalFuture<GridNearLockResponse>` GridDhtTransactionalCacheAdapter.`lockAllAsync(GridCacheContext<?,?> cacheCtx, ClusterNode nearNode, GridNearLockRequest req, CacheEntryPredicate[] filter0)`
`IgniteInternalFuture<?>` GridDhtCacheAdapter.`multiUpdateFinishFuture(AffinityTopologyVersion topVer)` Creates multi update finish future.
`IgniteInternalFuture<GridNearTxPrepareResponse>` GridDhtTxLocal.`prepareAsync(GridNearTxPrepareRequest req)` Prepares next batch of entries in dht transaction.
`IgniteInternalFuture<?>` GridDhtLocalPartition.`rent(boolean updateSeq)`
`IgniteInternalFuture<IgniteInternalTx>` GridDhtTxLocal.`rollbackAsync()` Asynchronously rollback this transaction.
`IgniteInternalFuture<IgniteInternalTx>` GridDhtTxLocal.`rollbackDhtLocalAsync()`
`IgniteInternalFuture<?>` GridDhtTxLocal.`salvageTx()`

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

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

### 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
`class` `GridDhtAtomicAbstractUpdateFuture` DHT atomic cache backup update future.
`class` `GridNearAtomicAbstractUpdateFuture` Base for near atomic update futures.
`class` `GridNearAtomicSingleUpdateFuture` DHT atomic cache near update future.
`class` `GridNearAtomicUpdateFuture` DHT atomic cache near update future.

Methods in org.apache.ignite.internal.processors.cache.distributed.dht.atomic that return IgniteInternalFuture
`IgniteInternalFuture<Void>` GridDhtAtomicAbstractUpdateFuture.`completeFuture(AffinityTopologyVersion topVer)` Gets future that will be completed when it is safe when update is finished on the given version of topology.
`IgniteInternalFuture<Void>` GridNearAtomicAbstractUpdateFuture.`completeFuture(AffinityTopologyVersion topVer)` Gets future that will be completed when it is safe when update is finished on the given version of topology.
`IgniteInternalFuture<Map<K,V>>` GridDhtAtomicCache.`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, UUID subjId, String taskName, boolean deserializeBinary, boolean recovery, boolean skipVals, boolean needVer)`
`IgniteInternalFuture<V>` GridDhtAtomicCache.`getAndPutAsync0(K key, V val, CacheEntryPredicate filter)`
`IgniteInternalFuture<V>` GridDhtAtomicCache.`getAndRemoveAsync0(K key)`
`protected IgniteInternalFuture<V>` GridDhtAtomicCache.`getAsync(K key, boolean forcePrimary, boolean skipTx, UUID subjId, String taskName, boolean deserializeBinary, boolean skipVals, boolean needVer)`
`<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<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long createTtl, long accessTtl)`
`IgniteInternalFuture<?>` GridDhtAtomicCache.`putAllAsync0(Map<? extends K,? extends V> m)`
`IgniteInternalFuture<?>` GridDhtAtomicCache.`putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> conflictMap)` Store DR data asynchronously.
`IgniteInternalFuture<Boolean>` GridDhtAtomicCache.`putAsync0(K key, V val, CacheEntryPredicate filter)`
`IgniteInternalFuture<Object>` GridDhtAtomicCache.`removeAllAsync0(Collection<? extends K> keys)`
`IgniteInternalFuture<?>` GridDhtAtomicCache.`removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> conflictMap)` Removes DR data asynchronously.
`IgniteInternalFuture<Boolean>` GridDhtAtomicCache.`removeAsync0(K key, CacheEntryPredicate filter)`

### 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
`class` `GridDhtColocatedLockFuture` Colocated cache lock future.

Methods in org.apache.ignite.internal.processors.cache.distributed.dht.colocated that return IgniteInternalFuture
`IgniteInternalFuture<Map<K,V>>` GridDhtColocatedCache.`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, UUID subjId, String taskName, boolean deserializeBinary, boolean recovery, boolean skipVals, boolean needVer)`
`protected IgniteInternalFuture<V>` GridDhtColocatedCache.`getAsync(K key, boolean forcePrimary, boolean skipTx, UUID subjId, String taskName, boolean deserializeBinary, boolean skipVals, boolean needVer)`
`IgniteInternalFuture<Map<K,V>>` GridDhtColocatedCache.`loadAsync(Collection<KeyCacheObject> keys, boolean readThrough, boolean forcePrimary, AffinityTopologyVersion topVer, UUID subjId, String taskName, boolean deserializeBinary, boolean recovery, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean needVer)`
`IgniteInternalFuture<Map<K,V>>` GridDhtColocatedCache.`loadAsync(Collection<KeyCacheObject> keys, boolean readThrough, boolean forcePrimary, AffinityTopologyVersion topVer, UUID subjId, String taskName, boolean deserializeBinary, boolean recovery, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean needVer, boolean keepCacheObj)`
`IgniteInternalFuture<Object>` GridDhtColocatedCache.`loadAsync(KeyCacheObject key, boolean readThrough, boolean forcePrimary, AffinityTopologyVersion topVer, UUID subjId, String taskName, boolean deserializeBinary, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean needVer, boolean keepCacheObj, boolean recovery)`
`IgniteInternalFuture<Boolean>` GridDhtColocatedCache.`lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long createTtl, long accessTtl)` 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
`class` `GridDhtForceKeysFuture<K,V>` Force keys request future.
`static class` `GridDhtPartitionDemander.RebalanceFuture`
`class` `GridDhtPartitionsExchangeFuture` Future for exchanging partition maps.
`class` `InitNewCoordinatorFuture`
`class` `StopCachesOnClientReconnectExchangeTask`

Methods in org.apache.ignite.internal.processors.cache.distributed.dht.preloader that return IgniteInternalFuture
`IgniteInternalFuture<Boolean>` GridDhtPreloader.`forceRebalance()` Force Rebalance process.
`IgniteInternalFuture<Boolean>` GridDhtPreloader.`rebalanceFuture()`
`IgniteInternalFuture<Object>` GridDhtPreloader.`startFuture()`
`IgniteInternalFuture<?>` GridDhtPreloader.`syncFuture()`

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

Subinterfaces of IgniteInternalFuture in org.apache.ignite.internal.processors.cache.distributed.near
`interface` `NearTxFinishFuture`

Classes in org.apache.ignite.internal.processors.cache.distributed.near that implement IgniteInternalFuture
`class` `GridNearGetFuture<K,V>`
`class` `GridNearLockFuture` Cache lock future.
`class` `GridNearOptimisticSerializableTxPrepareFuture`
`class` `GridNearOptimisticTxPrepareFuture`
`class` `GridNearOptimisticTxPrepareFutureAdapter`
`protected static class` `GridNearOptimisticTxPrepareFutureAdapter.KeyLockFuture` Keys lock future.
`class` `GridNearPessimisticTxPrepareFuture`
`class` `GridNearTxFastFinishFuture`
`class` `GridNearTxFinishFuture<K,V>`
`class` `GridNearTxPrepareFutureAdapter` Common code for tx prepare in optimistic and pessimistic modes.

Methods in org.apache.ignite.internal.processors.cache.distributed.near that return IgniteInternalFuture
`protected IgniteInternalFuture<Boolean>` GridNearTxLocal.`addReader(long msgId, GridDhtCacheEntry cached, IgniteTxEntry entry, AffinityTopologyVersion 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<IgniteInternalTx>` GridNearTxLocal.`commitNearTxLocalAsync()`
`IgniteInternalFuture<?>` GridNearTxLocal.`currentPrepareFuture()`
`IgniteInternalFuture<Map<K,V>>` GridNearTransactionalCache.`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, UUID subjId, String taskName, boolean deserializeBinary, boolean recovery, boolean skipVals, boolean needVer)`
`protected IgniteInternalFuture<Map<K,V>>` GridNearAtomicCache.`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, UUID subjId, String taskName, boolean deserializeBinary, boolean recovery, boolean skipVals, boolean needVer)`
`<K,V> IgniteInternalFuture<Map<K,V>>` GridNearTxLocal.`getAllAsync(GridCacheContext cacheCtx, AffinityTopologyVersion entryTopVer, Collection<KeyCacheObject> keys, boolean deserializeBinary, boolean skipVals, boolean keepCacheObjects, boolean skipStore, boolean recovery, boolean needVer)`
`IgniteInternalFuture<V>` GridNearAtomicCache.`getAndPutAsync0(K key, V val, CacheEntryPredicate filter)`
`IgniteInternalFuture<V>` GridNearAtomicCache.`getAndRemoveAsync(K key)` Asynchronously removes given key mapping from cache.
`<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)`
`<K,V> IgniteInternalFuture<GridCacheReturn>` GridNearTxLocal.`invokeAsync(GridCacheContext cacheCtx, AffinityTopologyVersion entryTopVer, K key, javax.cache.processor.EntryProcessor<K,V,Object> entryProcessor, Object... invokeArgs)`
`<K,V,T> IgniteInternalFuture<GridCacheReturn>` GridNearTxLocal.`invokeAsync(GridCacheContext cacheCtx, AffinityTopologyVersion entryTopVer, Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,Object>> map, Object... invokeArgs)`
`<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<KeyCacheObject> keys, boolean forcePrimary, UUID subjId, String taskName, boolean deserializeBinary, boolean recovery, javax.cache.expiry.ExpiryPolicy expiryPlc, boolean skipVal, boolean skipStore, boolean needVer)`
`IgniteInternalFuture<Void>` GridNearTxLocal.`loadMissing(GridCacheContext cacheCtx, AffinityTopologyVersion topVer, boolean readThrough, boolean async, Collection<KeyCacheObject> keys, boolean skipVals, boolean needVer, boolean keepBinary, boolean recovery, javax.cache.expiry.ExpiryPolicy expiryPlc, GridInClosure3<KeyCacheObject,Object,GridCacheVersion> c)`
`IgniteInternalFuture<?>` GridNearCacheAdapter.`localLoadCacheAsync(IgniteBiPredicate<K,V> p, Object[] args)` Asynchronously delegates to `CacheStore.loadCache(IgniteBiInClosure, Object...)` method to reload state from the underlying persistent storage.
`protected IgniteInternalFuture<Boolean>` GridNearTransactionalCache.`lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long createTtl, long accessTtl)`
`protected IgniteInternalFuture<Boolean>` GridNearAtomicCache.`lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long createTtl, long accessTtl)`
`<K> IgniteInternalFuture<GridCacheReturn>` GridNearTxLocal.`lockAllAsync(GridCacheContext cacheCtx, Collection<? extends K> keys, boolean retval, boolean read, long createTtl, long accessTtl, boolean skipStore, boolean keepBinary)`
`IgniteInternalFuture<GridNearTxPrepareResponse>` GridNearTxLocal.`prepareAsyncLocal(GridNearTxPrepareRequest req)` Prepares next batch of entries in dht transaction.
`IgniteInternalFuture<?>` GridNearTxLocal.`prepareNearTxLocal()`
`<K,V> IgniteInternalFuture<GridCacheReturn>` GridNearTxLocal.`putAllAsync(GridCacheContext cacheCtx, AffinityTopologyVersion entryTopVer, Map<? extends K,? extends V> map, boolean retval)`
`IgniteInternalFuture<?>` GridNearAtomicCache.`putAllAsync(Map<? extends K,? extends V> m)` Asynchronously stores given key-value pairs in cache.
`IgniteInternalFuture<?>` GridNearAtomicCache.`putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)` Store DR data asynchronously.
`IgniteInternalFuture<?>` GridNearTxLocal.`putAllDrAsync(GridCacheContext cacheCtx, Map<KeyCacheObject,GridCacheDrInfo> drMap)`
`<K,V> IgniteInternalFuture<GridCacheReturn>` GridNearTxLocal.`putAsync(GridCacheContext cacheCtx, AffinityTopologyVersion entryTopVer, K key, V val, boolean retval, CacheEntryPredicate filter)`
`IgniteInternalFuture<Boolean>` GridNearAtomicCache.`putAsync0(K key, V val, CacheEntryPredicate filter)`
`IgniteInternalFuture<?>` GridNearAtomicCache.`removeAllAsync()`
`IgniteInternalFuture<?>` GridNearAtomicCache.`removeAllAsync(Collection<? extends K> keys)` Asynchronously removes given key mappings from cache for entries.
`<K,V> IgniteInternalFuture<GridCacheReturn>` GridNearTxLocal.`removeAllAsync(GridCacheContext cacheCtx, AffinityTopologyVersion entryTopVer, Collection<? extends K> keys, boolean retval, CacheEntryPredicate filter, boolean singleRmv)`
`IgniteInternalFuture<?>` GridNearAtomicCache.`removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)` Removes DR data asynchronously.
`IgniteInternalFuture<?>` GridNearTxLocal.`removeAllDrAsync(GridCacheContext cacheCtx, Map<KeyCacheObject,GridCacheVersion> drMap)`
`IgniteInternalFuture<Boolean>` GridNearAtomicCache.`removeAsync(K key, CacheEntryPredicate filter)`
`IgniteInternalFuture<IgniteInternalTx>` GridNearTxLocal.`rollbackAsync()` Asynchronously rollback this transaction.
`IgniteInternalFuture<IgniteInternalTx>` GridNearTxLocal.`rollbackAsyncLocal()` Rolls back local part of colocated transaction.
`IgniteInternalFuture<IgniteInternalTx>` GridNearTxLocal.`rollbackNearTxLocalAsync()`
`IgniteInternalFuture<?>` GridNearTxLocal.`salvageTx()`

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

Classes in org.apache.ignite.internal.processors.cache.local that implement IgniteInternalFuture
`class` `GridLocalLockFuture<K,V>` Cache lock future.

Methods in org.apache.ignite.internal.processors.cache.local that return IgniteInternalFuture
`IgniteInternalFuture<Boolean>` GridLocalCache.`lockAllAsync(Collection<? extends K> keys, long timeout)` All or nothing synchronous lock for passed in keys.
`IgniteInternalFuture<Boolean>` GridLocalCache.`lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, CacheEntryPredicate[] filter)`
`IgniteInternalFuture<?>` GridLocalCache.`removeAllAsync()`
`IgniteInternalFuture<Boolean>` GridLocalCache.`txLockAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isRead, boolean retval, TransactionIsolation isolation, boolean invalidate, long createTtl, long accessTtl)`

### 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
`IgniteInternalFuture<Map<K,V>>` GridLocalAtomicCache.`getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, UUID subjId, String taskName, boolean deserializeBinary, boolean recovery, boolean skipVals, boolean needVer)`
`IgniteInternalFuture<V>` GridLocalAtomicCache.`getAndPutAsync0(K key, V val, CacheEntryPredicate filter)`
`IgniteInternalFuture<V>` GridLocalAtomicCache.`getAndRemoveAsync0(K key)`
`<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)` All or nothing synchronous lock for passed in keys.
`IgniteInternalFuture<?>` GridLocalAtomicCache.`putAllAsync0(Map<? extends K,? extends V> m)`
`IgniteInternalFuture<Boolean>` GridLocalAtomicCache.`putAsync0(K key, V val, CacheEntryPredicate filter)`
`IgniteInternalFuture<?>` GridLocalAtomicCache.`removeAllAsync()`
`IgniteInternalFuture<Object>` GridLocalAtomicCache.`removeAllAsync0(Collection<? extends K> keys)`
`IgniteInternalFuture<Boolean>` GridLocalAtomicCache.`removeAsync0(K key, CacheEntryPredicate filter)`
`IgniteInternalFuture<Boolean>` GridLocalAtomicCache.`txLockAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isRead, boolean retval, TransactionIsolation isolation, boolean invalidate, long createTtl, long accessTtl)`

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

Methods in org.apache.ignite.internal.processors.cache.persistence that return IgniteInternalFuture
`IgniteInternalFuture<Void>` GridCacheDatabaseSharedManager.`enableCheckpoints(boolean enable)` For test use only.
`IgniteInternalFuture` IgniteCacheDatabaseSharedManager.`indexRebuildFuture(int cacheId)`
`IgniteInternalFuture` GridCacheDatabaseSharedManager.`indexRebuildFuture(int cacheId)`
`IgniteInternalFuture` IgniteCacheDatabaseSharedManager.`wakeupForCheckpoint(String reason)`
`IgniteInternalFuture` GridCacheDatabaseSharedManager.`wakeupForCheckpoint(String reason)`
`IgniteInternalFuture` GridCacheDatabaseSharedManager.Checkpointer.`wakeupForSnapshotCreation(SnapshotOperation snapshotOperation)`

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

Methods in org.apache.ignite.internal.processors.cache.persistence.pagemem that return IgniteInternalFuture
`IgniteInternalFuture<Void>` PageMemoryImpl.`clearAsync(GridPredicate3<Integer,Long,Integer> pred, boolean cleanDirty)` Asynchronously clears pages satisfying the given predicate.
`IgniteInternalFuture<Void>` PageMemoryEx.`clearAsync(GridPredicate3<Integer,Long,Integer> pred, boolean cleanDirty)` Asynchronously clears pages satisfying the given predicate.

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

Methods in org.apache.ignite.internal.processors.cache.persistence.snapshot that return IgniteInternalFuture
`IgniteInternalFuture` IgniteCacheSnapshotManager.`startLocalSnapshotOperation(UUID initiatorNodeId, T snapshotOperation)`
`IgniteInternalFuture` IgniteCacheSnapshotManager.`tryStartLocalSnapshotOperation(DiscoveryEvent discoveryEvent)` Try to start local snapshot operation if it's required by discovery event.

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

Subinterfaces of IgniteInternalFuture in org.apache.ignite.internal.processors.cache.query
`interface` `CacheQueryFuture<T>` Cache query future returned by query execution.

Classes in org.apache.ignite.internal.processors.cache.query that implement IgniteInternalFuture
`class` `GridCacheDistributedFieldsQueryFuture` Distributed fields query future.
`class` `GridCacheDistributedQueryFuture<K,V,R>` Distributed query future.
`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
`IgniteInternalFuture<List<GridQueryFieldMetadata>>` GridCacheDistributedFieldsQueryFuture.`metadata()`
`IgniteInternalFuture<List<GridQueryFieldMetadata>>` GridCacheLocalFieldsQueryFuture.`metadata()`
`IgniteInternalFuture<List<GridQueryFieldMetadata>>` GridCacheQueryMetadataAware.`metadata()`

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

Methods in org.apache.ignite.internal.processors.cache.transactions that return IgniteInternalFuture
`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.
`IgniteInternalFuture<?>` IgniteInternalTx.`currentPrepareFuture()`
`IgniteInternalFuture<?>` IgniteTxAdapter.`currentPrepareFuture()`
`IgniteInternalFuture<TxDeadlock>` IgniteTxManager.`detectDeadlock(IgniteInternalTx tx, Set<IgniteTxKey> keys)` Performs deadlock detection for given keys.
`IgniteInternalFuture<IgniteInternalTx>` IgniteTxHandler.`finish(UUID nodeId, GridNearTxLocal locTx, GridNearTxFinishRequest req)`
`IgniteInternalFuture<IgniteInternalTx>` IgniteTxHandler.`finishColocatedLocal(boolean commit, GridNearTxLocal tx)`
`IgniteInternalFuture<IgniteInternalTx>` IgniteInternalTx.`finishFuture()`
`IgniteInternalFuture<IgniteInternalTx>` IgniteTxAdapter.`finishFuture()`
`IgniteInternalFuture<Boolean>` IgniteTxManager.`finishTxs(AffinityTopologyVersion topVer)` Creates a future that will wait for all ongoing transactions that maybe affected by topology update to be finished.
`protected abstract IgniteInternalFuture<T>` IgniteTxLocalAdapter.PostLockClosure2.`postLock()` Post lock callback.
`protected abstract IgniteInternalFuture<T>` IgniteTxLocalAdapter.PostMissClosure.`postMiss(T t)` Post lock callback.
`IgniteInternalFuture<GridNearTxPrepareResponse>` IgniteTxHandler.`prepareColocatedTx(GridNearTxLocal locTx, GridNearTxPrepareRequest req)` Prepares local colocated tx.
`IgniteInternalFuture<GridNearTxPrepareResponse>` IgniteTxHandler.`prepareNearTxLocal(GridNearTxPrepareRequest req)`
`IgniteInternalFuture<?>` IgniteTxManager.`remoteTxFinishFuture(GridCacheVersion nearVer)`
`IgniteInternalFuture<IgniteInternalTx>` IgniteInternalTx.`rollbackAsync()` Asynchronously rollback this transaction.
`IgniteInternalFuture<?>` IgniteInternalTx.`salvageTx()`
`IgniteInternalFuture<Boolean>` IgniteTxManager.`txCommitted(GridCacheVersion xidVer)`
`IgniteInternalFuture<Boolean>` IgniteTxManager.`txsPreparedOrCommitted(GridCacheVersion nearVer, int txNum)` Checks if transactions with given near version ID was prepared or committed.

Methods in org.apache.ignite.internal.processors.cache.transactions that return types with arguments of type IgniteInternalFuture
`Collection<IgniteInternalFuture<?>>` IgniteTxManager.`deadlockDetectionFutures()`

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

Methods in org.apache.ignite.internal.processors.closure that return IgniteInternalFuture
`<T,R> IgniteInternalFuture<Collection<R>>` GridClosureProcessor.`broadcast(IgniteClosure<T,R> job, T arg, Collection<ClusterNode> nodes, String execName)`
`<R> IgniteInternalFuture<R>` GridClosureProcessor.`callAsyncNoFailover(GridClosureCallMode mode, Callable<R> job, Collection<ClusterNode> nodes, boolean sys, long timeout, boolean skipAuth)`
`<R> IgniteInternalFuture<Collection<R>>` GridClosureProcessor.`callAsyncNoFailover(GridClosureCallMode mode, Collection<? extends Callable<R>> jobs, Collection<ClusterNode> nodes, boolean sys, long timeout)`
`<R> IgniteInternalFuture<R>` GridClosureProcessor.`callLocal(Callable<R> c, byte plc)`
`<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, byte plc)` Companion to `GridClosureProcessor.callLocal(Callable, boolean)` but in case of rejected execution re-runs the closure in the current thread (blocking).
`IgniteInternalFuture<?>` GridClosureProcessor.`runLocal(Runnable c, byte plc)`
`IgniteInternalFuture<?>` GridClosureProcessor.`runLocalSafe(Runnable c)` Executes closure on system pool.
`IgniteInternalFuture<?>` GridClosureProcessor.`runLocalSafe(Runnable c, boolean sys)` In case of rejected execution re-runs the closure in the current thread (blocking).
`IgniteInternalFuture<?>` GridClosureProcessor.`runLocalSafe(Runnable c, byte plc)` In case of rejected execution re-runs the closure in the current thread (blocking).

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

Methods in org.apache.ignite.internal.processors.cluster that return IgniteInternalFuture
`IgniteInternalFuture<?>` GridClusterStateProcessor.`changeGlobalState(boolean activate, Collection<? extends BaselineNode> baselineNodes, boolean forceChangeBaselineTopology)`
`IgniteInternalFuture<?>` IGridClusterStateProcessor.`changeGlobalState(boolean activate, Collection<? extends BaselineNode> baselineNodes, boolean forceChangeBaselineTopology)`
`IgniteInternalFuture<Boolean>` GridClusterStateProcessor.`onLocalJoin(DiscoCache discoCache)`
`IgniteInternalFuture<Boolean>` IGridClusterStateProcessor.`onLocalJoin(DiscoCache discoCache)`
`IgniteInternalFuture<String>` ClusterProcessor.`requestDiagnosticInfo(UUID nodeId, IgniteClosure<GridKernalContext,IgniteDiagnosticInfo> c, String baseMsg)` Sends diagnostic message closure to remote node.
`protected IgniteInternalFuture<?>` GridClusterStateProcessor.`wrapStateChangeFuture(IgniteInternalFuture fut, ChangeGlobalStateMessage msg)`

Methods in org.apache.ignite.internal.processors.cluster with parameters of type IgniteInternalFuture
`void` GridClusterStateProcessor.`onExchangeFinishedOnCoordinator(IgniteInternalFuture exchangeFuture, boolean hasMovingPartitions)`
`void` IGridClusterStateProcessor.`onExchangeFinishedOnCoordinator(IgniteInternalFuture exchangeFuture, boolean hasMovingPartitions)`
`protected IgniteInternalFuture<?>` GridClusterStateProcessor.`wrapStateChangeFuture(IgniteInternalFuture fut, ChangeGlobalStateMessage msg)`

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

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

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

Methods in org.apache.ignite.internal.processors.datastreamer that return IgniteInternalFuture
`IgniteInternalFuture<?>` DataStreamerImpl.`internalFuture()`

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

Methods in org.apache.ignite.internal.processors.datastructures that return IgniteInternalFuture
`IgniteInternalFuture<?>` DataStructuresProcessor.`onReconnected(boolean clusterRestarted)` Client reconnected callback.

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

Methods in org.apache.ignite.internal.processors.hadoop that return IgniteInternalFuture
`abstract IgniteInternalFuture<?>` HadoopProcessorAdapter.`finishFuture(HadoopJobId jobId)` Gets Hadoop job finish future.
`IgniteInternalFuture<?>` HadoopNoopProcessor.`finishFuture(HadoopJobId jobId)` Gets Hadoop job finish future.
`IgniteInternalFuture<?>` Hadoop.`finishFuture(HadoopJobId jobId)` Gets Hadoop finish future for particular job.
`abstract IgniteInternalFuture<?>` HadoopProcessorAdapter.`submit(HadoopJobId jobId, HadoopJobInfo jobInfo)` Submits job to job tracker.
`IgniteInternalFuture<?>` HadoopNoopProcessor.`submit(HadoopJobId jobId, HadoopJobInfo jobInfo)` Submits job to job tracker.
`IgniteInternalFuture<?>` Hadoop.`submit(HadoopJobId jobId, HadoopJobInfo 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
`IgniteInternalFuture<byte[]>` IgfsDataManager.`dataBlock(IgfsEntryInfo fileInfo, IgfsPath path, long blockIdx, IgfsSecondaryFileSystemPositionedReadable secReader)` Get data block for specified file ID and block index.
`protected IgniteInternalFuture<byte[]>` IgfsInputStreamImpl.`dataBlock(long blockIdx)` Get data block for specified block index.
`IgniteInternalFuture<Object>` IgfsDataManager.`delete(IgfsEntryInfo 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(IgniteUuid fileId)` Registers write future in igfs data manager.

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

Methods in org.apache.ignite.internal.processors.platform that return IgniteInternalFuture
`IgniteInternalFuture<?>` PlatformProcessorImpl.`onReconnected(boolean clusterRestarted)` Client reconnected callback.

Methods in org.apache.ignite.internal.processors.platform with parameters of type IgniteInternalFuture
`protected PlatformListenable` PlatformAbstractTarget.`readAndListenFuture(BinaryRawReader reader, IgniteInternalFuture fut)` Reads future information and listens.

### Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.platform.compute

Classes in org.apache.ignite.internal.processors.platform.compute that implement IgniteInternalFuture
`protected class` `PlatformCompute.ComputeConvertingFuture` Wraps ComputeTaskFuture as IgniteInternalFuture.

Methods in org.apache.ignite.internal.processors.platform.compute that return IgniteInternalFuture
`IgniteInternalFuture` PlatformCompute.ComputeConvertingFuture.`chain(IgniteClosure doneCb)` Make a chained future to convert result of this future (when complete) into a new format.
`IgniteInternalFuture` PlatformCompute.ComputeConvertingFuture.`chain(IgniteClosure doneCb, Executor exec)` Make a chained future to convert result of this future (when complete) into a new format.

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

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

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

Methods in org.apache.ignite.internal.processors.query that return IgniteInternalFuture
`IgniteInternalFuture<?>` GridQueryProcessor.`dynamicColumnAdd(String cacheName, String schemaName, String tblName, List<QueryField> cols, boolean ifTblExists, boolean ifNotExists)` Entry point for add column procedure.
`IgniteInternalFuture<?>` GridQueryProcessor.`dynamicColumnRemove(String cacheName, String schemaName, String tblName, List<String> cols, boolean ifTblExists, boolean ifExists)` Entry point for drop column procedure.
`IgniteInternalFuture<?>` GridQueryProcessor.`dynamicIndexCreate(String cacheName, String schemaName, String tblName, QueryIndex idx, boolean ifNotExists, int parallel)` Entry point for index procedure.
`IgniteInternalFuture<?>` GridQueryProcessor.`dynamicIndexDrop(String cacheName, String schemaName, String idxName, boolean ifExists)` Entry point for index drop procedure
`IgniteInternalFuture<?>` GridQueryProcessor.`rebuildIndexesFromHash(Collection<Integer> cacheIds)` Rebuilds indexes for provided caches from corresponding hash indexes.

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

Classes in org.apache.ignite.internal.processors.query.schema that implement IgniteInternalFuture
`class` `SchemaOperationClientFuture` Schema operation client future.

Methods in org.apache.ignite.internal.processors.query.schema that return IgniteInternalFuture
`IgniteInternalFuture` SchemaOperationWorker.`future()`

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

Methods in org.apache.ignite.internal.processors.rest that return IgniteInternalFuture
`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
`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
`IgniteInternalFuture<GridRestResponse>` GridCacheCommandHandler.`handleAsync(GridRestRequest req)`

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

Methods in org.apache.ignite.internal.processors.rest.handlers.cluster that return IgniteInternalFuture
`IgniteInternalFuture<GridRestResponse>` GridChangeStateCommandHandler.`handleAsync(GridRestRequest restRest)`

### 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
`IgniteInternalFuture<GridRestResponse>` DataStructuresCommandHandler.`handleAsync(GridRestRequest req)`

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

Methods in org.apache.ignite.internal.processors.rest.handlers.log that return IgniteInternalFuture
`IgniteInternalFuture<GridRestResponse>` GridLogCommandHandler.`handleAsync(GridRestRequest req)`

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

Methods in org.apache.ignite.internal.processors.rest.handlers.query that return IgniteInternalFuture
`IgniteInternalFuture<GridRestResponse>` QueryCommandHandler.`handleAsync(GridRestRequest req)`

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

Methods in org.apache.ignite.internal.processors.rest.handlers.redis that return IgniteInternalFuture
`IgniteInternalFuture<GridRedisMessage>` GridRedisConnectionCommandHandler.`handleAsync(GridNioSession ses, GridRedisMessage msg)`
`IgniteInternalFuture<GridRedisMessage>` GridRedisRestCommandHandler.`handleAsync(GridNioSession ses, GridRedisMessage msg)`
`IgniteInternalFuture<GridRedisMessage>` GridRedisCommandHandler.`handleAsync(GridNioSession ses, GridRedisMessage msg)`

### 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
`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
`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
`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
`class` `GridServiceDeploymentCompoundFuture` Service deployment compound future.
`class` `GridServiceDeploymentFuture` Service deployment future.

Methods in org.apache.ignite.internal.processors.service that return IgniteInternalFuture
`IgniteInternalFuture<?>` GridServiceProcessor.`cancel(String name)`
`IgniteInternalFuture<?>` GridServiceProcessor.`cancelAll()`
`IgniteInternalFuture<?>` GridServiceProcessor.`cancelAll(Collection<String> svcNames)`
`IgniteInternalFuture<?>` GridServiceProcessor.`deployAll(ClusterGroup prj, Collection<ServiceConfiguration> cfgs)`
`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)`

Methods in org.apache.ignite.internal.processors.service with parameters of type IgniteInternalFuture
`protected boolean` GridServiceDeploymentCompoundFuture.`processFailure(Throwable err, IgniteInternalFuture<Object> fut)` Processes error thrown by some of the inner futures.

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

Methods in org.apache.ignite.internal.util with parameters of type IgniteInternalFuture
`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
`class` `CountDownFuture`
`class` `GridCompoundFuture<T,R>` Future composed of multiple inner futures.
`class` `GridCompoundIdentityFuture<T>` Compound future with reducer which accepts and produces results of the same type.
`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` `GridFutureAdapter<R>` Future adapter.

Fields in org.apache.ignite.internal.util.future declared as IgniteInternalFuture
`protected IgniteInternalFuture<V>` IgniteFutureImpl.`fut`

Methods in org.apache.ignite.internal.util.future that return IgniteInternalFuture
`<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>` GridFutureAdapter.`chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb, Executor exec)` 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.
`<T1> IgniteInternalFuture<T1>` GridFinishedFuture.`chain(IgniteClosure<? super IgniteInternalFuture<T>,T1> doneCb, Executor exec)` Make a chained future to convert result of this future (when complete) into a new format.
`protected <T> IgniteInternalFuture<T>` IgniteFutureImpl.`chainInternal(IgniteClosure<? super IgniteFuture<V>,T> doneCb, Executor exec)`
`protected IgniteInternalFuture<T>` GridCompoundFuture.`future(int idx)` Returns future at the specified position in this list.
`IgniteInternalFuture<V>` IgniteFutureImpl.`internalFuture()`

Methods in org.apache.ignite.internal.util.future that return types with arguments of type IgniteInternalFuture
`Collection<IgniteInternalFuture<T>>` GridCompoundFuture.`futures()` Gets collection of futures.

Methods in org.apache.ignite.internal.util.future with parameters of type IgniteInternalFuture
`void` GridCompoundFuture.`add(IgniteInternalFuture<T> fut)` Adds a future to this compound future.
`void` GridCompoundFuture.`apply(IgniteInternalFuture<T> fut)` Closure body.
`protected boolean` GridCompoundFuture.`processFailure(Throwable err, IgniteInternalFuture<T> fut)` Processes error thrown by some of the inner futures.

Method parameters in org.apache.ignite.internal.util.future with type arguments of type IgniteInternalFuture
`<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>` GridFutureAdapter.`chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb, Executor exec)` 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.
`<T1> IgniteInternalFuture<T1>` GridFinishedFuture.`chain(IgniteClosure<? super IgniteInternalFuture<T>,T1> doneCb, Executor exec)` Make a chained future to convert result of this future (when complete) into a new format.
`void` GridFutureAdapter.`listen(IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)` Registers listener closure to be asynchronously notified whenever future completes.
`void` GridFinishedFuture.`listen(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(IgniteBiClosure<B,Exception,A> c, IgniteInternalFuture<B> embedded)`
`GridEmbeddedFuture(IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c)` Embeds futures.
`GridEmbeddedFuture(IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c1, IgniteBiClosure<A,Exception,A> c2)` Embeds futures.
`GridEmbeddedFuture(IgniteInternalFuture<B> embedded, IgniteOutClosure<IgniteInternalFuture<A>> c)`
`IgniteFutureImpl(IgniteInternalFuture<V> fut)`

Constructor parameters in org.apache.ignite.internal.util.future with type arguments of type IgniteInternalFuture
Constructor and Description
`GridEmbeddedFuture(IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c)` Embeds futures.
`GridEmbeddedFuture(IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c1, IgniteBiClosure<A,Exception,A> c2)` Embeds futures.
`GridEmbeddedFuture(IgniteInternalFuture<B> embedded, IgniteOutClosure<IgniteInternalFuture<A>> c)`

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

Method parameters in org.apache.ignite.internal.util.lang with type arguments of type IgniteInternalFuture
`static <T> void` GridFunc.`awaitAll(Collection<IgniteInternalFuture<T>> futs)` Deprecated.
`static <T> void` GridFunc.`awaitAll(long timeout, Collection<IgniteInternalFuture<T>> futs)` Deprecated.
`static <T,R> R` GridFunc.`awaitAll(long timeout, IgniteReducer<T,R> rdc, Collection<IgniteInternalFuture<T>> futs)` Deprecated.

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

Subinterfaces of IgniteInternalFuture in org.apache.ignite.internal.util.nio
`interface` `GridNioFuture<R>` NIO future.

Classes in org.apache.ignite.internal.util.nio that implement IgniteInternalFuture
`class` `GridNioEmbeddedFuture<R>` Future that delegates to some other future.
`class` `GridNioFinishedFuture<R>` Future that represents already completed result.
`class` `GridNioFutureImpl<R>` Default future implementation.

Methods in org.apache.ignite.internal.util.nio that return IgniteInternalFuture
`IgniteInternalFuture<String>` GridNioServer.`dumpNodeStats(String msg, IgnitePredicate<GridNioSession> p)`
`IgniteInternalFuture<String>` GridNioServer.`dumpStats()`
`IgniteInternalFuture<String>` GridNioServer.`dumpStats(String msg, IgnitePredicate<GridNioSession> p)`

Method parameters in org.apache.ignite.internal.util.nio with type arguments of type IgniteInternalFuture
`GridNioFuture<GridNioSession>` GridNioServer.`createSession(SocketChannel ch, Map<Integer,Object> meta, boolean async, IgniteInClosure<? super IgniteInternalFuture<GridNioSession>> lsnr)` Establishes a session.
`void` GridNioServer.`sendSystem(GridNioSession ses, Message msg, IgniteInClosure<? super IgniteInternalFuture<?>> lsnr)` Adds message at the front of the queue without acquiring back pressure semaphore.

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

Classes in org.apache.ignite.internal.util.worker that implement IgniteInternalFuture
`class` `GridWorkerFuture<T>` Future for locally executed closure that defines cancellation logic.

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

Methods in org.apache.ignite.spi.communication.tcp that return IgniteInternalFuture
`IgniteInternalFuture<String>` TcpCommunicationSpi.`dumpNodeStatistics(UUID nodeId)`

2018 Copyright © Apache Software Foundation

Follow @ApacheIgnite

Ignite Fabric | : ver. 2.4.0
Release Date | : March 5 2018