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

Packages that use IgniteInternalFuture

Package	Description
org.apache.ignite.internal	Contains main implementation.
org.apache.ignite.internal.cache.query.index
org.apache.ignite.internal.cache.query.index.sorted
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.encryption	Encryption manager classes.
org.apache.ignite.internal.managers.eventstorage	TODO.
org.apache.ignite.internal.managers.indexing	Indexing manager classes.
org.apache.ignite.internal.processors	Package with Apache Ignite internal Processors.
org.apache.ignite.internal.processors.affinity	Data affinity processor.
org.apache.ignite.internal.processors.authentication
org.apache.ignite.internal.processors.cache	This package contain cache-related processors & persistence implementation.
org.apache.ignite.internal.processors.cache.binary	Implementation of binary processor.
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.dht.topology
org.apache.ignite.internal.processors.cache.distributed.near
org.apache.ignite.internal.processors.cache.distributed.near.consistency
org.apache.ignite.internal.processors.cache.persistence	This package contain cache with persistence implementation.
org.apache.ignite.internal.processors.cache.persistence.checkpoint
org.apache.ignite.internal.processors.cache.persistence.defragmentation
org.apache.ignite.internal.processors.cache.persistence.file
org.apache.ignite.internal.processors.cache.persistence.metastorage.pendingtask
org.apache.ignite.internal.processors.cache.persistence.pagemem	This package contains page memory implementation for case persitence is enabled.
org.apache.ignite.internal.processors.cache.persistence.snapshot
org.apache.ignite.internal.processors.cache.persistence.snapshot.dump
org.apache.ignite.internal.processors.cache.query
org.apache.ignite.internal.processors.cache.query.continuous
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.localtask
org.apache.ignite.internal.processors.metastorage.persistence
org.apache.ignite.internal.processors.odbc
org.apache.ignite.internal.processors.platform
org.apache.ignite.internal.processors.platform.client
org.apache.ignite.internal.processors.platform.client.cache
org.apache.ignite.internal.processors.platform.client.tx
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.running
org.apache.ignite.internal.processors.query.schema
org.apache.ignite.internal.processors.query.stat
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.auth	REST authentication command.
org.apache.ignite.internal.processors.rest.handlers.beforeStart
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.memory
org.apache.ignite.internal.processors.rest.handlers.probe
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.user	REST user commands.
org.apache.ignite.internal.processors.rest.handlers.version	REST version command.
org.apache.ignite.internal.processors.security
org.apache.ignite.internal.processors.service
org.apache.ignite.internal.processors.timeout	TODO.
org.apache.ignite.internal.util	System-wide utility routine and helper classes.
org.apache.ignite.internal.util.distributed
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.
org.apache.ignite.spi.communication.tcp.internal	Contains connection health-checkers for TCP/IP-based implementation of communication SPI.
org.apache.ignite.spi.discovery.tcp.internal	Contains internal implementation.

Uses of IgniteInternalFuture in org.apache.ignite.internal

Classes in org.apache.ignite.internal that implement IgniteInternalFuture

Modifier and Type	Class	Description
class	ComputeTaskInternalFuture<R>	This class provide implementation for task future.

Methods in org.apache.ignite.internal that return IgniteInternalFuture

Modifier and Type	Method	Description
<R> IgniteInternalFuture<R>	IgniteComputeHandler.affinityCallAsync(@NotNull Collection<String> cacheNames, int partId, IgniteCallable<R> job)	Affinity call implementation.
<R> IgniteInternalFuture<R>	IgniteComputeHandler.affinityCallAsync(@NotNull Collection<String> cacheNames, Object affKey, IgniteCallable<R> job)	Affinity call implementation.
<R> IgniteInternalFuture<R>	IgniteComputeHandler.affinityCallAsync(String cacheName, Object affKey, IgniteCallable<R> job)	Affinity call implementation.
IgniteInternalFuture<?>	IgniteComputeHandler.affinityRunAsync(@NotNull Collection<String> cacheNames, int partId, IgniteRunnable job)	Affinity run implementation.
IgniteInternalFuture<?>	IgniteComputeHandler.affinityRunAsync(@NotNull Collection<String> cacheNames, Object affKey, IgniteRunnable job)	Affinity run implementation.
IgniteInternalFuture<?>	IgniteComputeHandler.affinityRunAsync(String cacheName, Object affKey, IgniteRunnable job)	Affinity run implementation.
<T,R> IgniteInternalFuture<Collection<R>>	IgniteComputeHandler.applyAsync(IgniteClosure<T,R> job, @Nullable Collection<? extends T> args)	Apply implementation.
<R,T> IgniteInternalFuture<R>	IgniteComputeHandler.applyAsync(IgniteClosure<T,R> job, T arg)	Apply implementation.
<R1,R2,T> IgniteInternalFuture<R2>	IgniteComputeHandler.applyAsync(IgniteClosure<T,R1> job, Collection<? extends T> args, IgniteReducer<R1,R2> rdc)	Apply with reducer implementation.
<R> IgniteInternalFuture<Collection<R>>	IgniteComputeHandler.broadcastAsync(IgniteCallable<R> job)	Broadcast implementation.
<R,T> IgniteInternalFuture<Collection<R>>	IgniteComputeHandler.broadcastAsync(IgniteClosure<T,R> job, T arg)	Broadcast implementation.
IgniteInternalFuture<?>	IgniteComputeHandler.broadcastAsync(IgniteRunnable job)	Broadcast implementation.
<R> IgniteInternalFuture<Collection<R>>	IgniteComputeHandler.callAsync(Collection<? extends IgniteCallable<R>> jobs)	Call implementation.
<R1,R2> IgniteInternalFuture<R2>	IgniteComputeHandler.callAsync(Collection<? extends IgniteCallable<R1>> jobs, IgniteReducer<R1,R2> rdc)	Call with reducer implementation.
<R> IgniteInternalFuture<R>	IgniteComputeHandler.callAsync(IgniteCallable<R> job)	Call implementation.
<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.
<T> IgniteInternalFuture<T>	IgniteInternalFuture.chain(IgniteOutClosure<T> doneCb)	Make a chained future to convert result of this future (when complete) into a new format.
<T> IgniteInternalFuture<T>	IgniteInternalFuture.chain(IgniteOutClosure<T> doneCb, Executor exec)	Make a chained future to convert result of this future (when complete) into a new format.
<T> IgniteInternalFuture<T>	IgniteInternalFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb)	Make a chained future that is completed when doneCb is executed.
<T> IgniteInternalFuture<T>	IgniteInternalFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb, Executor exec)	Make a chained future that is completed when doneCb is executed.
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)
<T,R> IgniteInternalFuture<R>	IgniteComputeHandler.executeAsync(Class<? extends ComputeTask<T,R>> taskCls, T arg)	Execute implementation.
<T,R> IgniteInternalFuture<R>	IgniteComputeHandler.executeAsync(String taskName, T arg)	Execute implementation.
IgniteInternalFuture<?>	IgniteKernal.getOrCreateCacheAsync(String cacheName, String templateName, CacheConfigurationOverride cfgOverride, boolean checkThreadTx)
@Nullable IgniteInternalFuture<?>	GridComponent.onReconnected(boolean clusterRestarted)	Client reconnected callback.
IgniteInternalFuture<?>	GridPluginComponent.onReconnected(boolean clusterRestarted)	Client reconnected callback.
IgniteInternalFuture<?>	IgniteComputeHandler.runAsync(Collection<? extends IgniteRunnable> jobs)	Run implementation.
IgniteInternalFuture<?>	IgniteComputeHandler.runAsync(IgniteRunnable job)	Run implementation.
IgniteInternalFuture	IgniteKernal.sendIoTest(List<ClusterNode> nodes, byte[] payload, boolean procFromNioThread)
IgniteInternalFuture	IgniteKernal.sendIoTest(ClusterNode node, byte[] payload, boolean procFromNioThread)

Methods in org.apache.ignite.internal with parameters of type IgniteInternalFuture

Modifier and Type	Method	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	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.
<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.
<T> IgniteInternalFuture<T>	IgniteInternalFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb)	Make a chained future that is completed when doneCb is executed.
<T> IgniteInternalFuture<T>	IgniteInternalFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb)	Make a chained future that is completed when doneCb is executed.
<T> IgniteInternalFuture<T>	IgniteInternalFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb, Executor exec)	Make a chained future that is completed when doneCb is executed.
<T> IgniteInternalFuture<T>	IgniteInternalFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb, Executor exec)	Make a chained future that is completed when doneCb is executed.
void	IgniteInternalFuture.listen(IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)	Registers listener closure to be asynchronously notified whenever future completes.
void	IgniteDiagnosticPrepareContext.send(GridKernalContext ctx, @Nullable IgniteInClosure<IgniteInternalFuture<String>> lsnr)

Uses of IgniteInternalFuture in org.apache.ignite.internal.cache.query.index

Methods in org.apache.ignite.internal.cache.query.index that return IgniteInternalFuture

Modifier and Type	Method	Description
@Nullable IgniteInternalFuture<?>	IndexProcessor.rebuildIndexesForCache(GridCacheContext<?,?> cctx, boolean force, IndexRebuildCancelToken cancelTok)	Start rebuild of indexes for specified cache.

Uses of IgniteInternalFuture in org.apache.ignite.internal.cache.query.index.sorted

Methods in org.apache.ignite.internal.cache.query.index.sorted that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<DurableBackgroundTaskResult>	DurableBackgroundCleanupIndexTreeTask.executeAsync(GridKernalContext ctx)	Deprecated. Asynchronous task execution.
IgniteInternalFuture<DurableBackgroundTaskResult<Long>>	DurableBackgroundCleanupIndexTreeTaskV2.executeAsync(GridKernalContext ctx)	Asynchronous task execution.

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

Methods in org.apache.ignite.internal.cluster that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<?>	ClusterTopologyCheckedException.retryReadyFuture()
static <T extends Serializable> IgniteInternalFuture<Void>	DistributedConfigurationUtils.setDefaultValue(DistributedProperty<T> prop, T val, IgniteLogger log)

Methods in org.apache.ignite.internal.cluster with parameters of type IgniteInternalFuture

Modifier and Type	Method	Description
void	ClusterTopologyCheckedException.retryReadyFuture(IgniteInternalFuture<?> readyFut)

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

Methods in org.apache.ignite.internal.managers that return IgniteInternalFuture

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

Modifier and Type	Method	Description
IgniteInternalFuture<?>	GridIoManager.onReconnected(boolean clusterRestarted)	Client reconnected callback.
IgniteInternalFuture	GridIoManager.sendIoTest(List<ClusterNode> nodes, byte[] payload, boolean procFromNioThread)
IgniteInternalFuture<List<IgniteIoTestMessage>>	GridIoManager.sendIoTest(ClusterNode node, 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

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

Modifier and Type	Method	Description
IgniteInternalFuture<Long>	GridDiscoveryManager.topologyFuture(long awaitVer)	Gets future that will be completed when current topology version becomes greater or equal to argument passed.
@Nullable IgniteInternalFuture<Boolean>	DiscoveryLocalJoinData.transitionWaitFuture()

Constructors in org.apache.ignite.internal.managers.discovery with parameters of type IgniteInternalFuture

Constructor	Description
DiscoveryLocalJoinData(DiscoveryEvent evt, DiscoCache discoCache, @Nullable IgniteInternalFuture<Boolean> transitionWaitFut, boolean active)

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

Classes in org.apache.ignite.internal.managers.encryption that implement IgniteInternalFuture

Modifier and Type	Class	Description
protected static class	GridEncryptionManager.KeyChangeFuture	Key change future.

Methods in org.apache.ignite.internal.managers.encryption that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<T2<Collection<byte[]>,byte[]>>	GridEncryptionManager.generateKeys(int keyCnt)
IgniteInternalFuture<?>	GridEncryptionManager.onReconnected(boolean clusterRestarted)	Client reconnected callback.
IgniteInternalFuture<Void>	GridEncryptionManager.reencryptionFuture(int grpId)
IgniteInternalFuture<Void>	CacheGroupPageScanner.schedule(int grpId)	Schedule scanning partitions.
IgniteInternalFuture<Void>	CacheGroupPageScanner.statusFuture(int grpId)

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	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(@Nullable IgnitePredicate<T> p, @org.jetbrains.annotations.Nullable int... types)

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

Methods in org.apache.ignite.internal.managers.indexing that return IgniteInternalFuture

Modifier and Type	Method	Description
@Nullable IgniteInternalFuture<?>	IndexesRebuildTask.rebuild(GridCacheContext<?,?> cctx, boolean force, IndexRebuildCancelToken cancelTok)	Start to rebuild.

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

Methods in org.apache.ignite.internal.processors that return IgniteInternalFuture

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

Modifier and Type	Method	Description
IgniteInternalFuture<org.apache.ignite.internal.processors.affinity.GridAffinityProcessor.AffinityInfo>	GridAffinityProcessor.affinityCacheFuture(String cacheName, @Nullable AffinityTopologyVersion topVer)
@Nullable 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.authentication

Methods in org.apache.ignite.internal.processors.authentication that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<?>	IgniteAuthenticationProcessor.onReconnected(boolean active)	Client reconnected callback.

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

Subinterfaces of IgniteInternalFuture in org.apache.ignite.internal.processors.cache

Modifier and Type	Interface	Description
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

Modifier and Type	Class	Description
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

Modifier and Type	Method	Description
IgniteInternalFuture<?>	CachesRegistry.addUnregistered(Collection<DynamicCacheDescriptor> descs)	Adds cache and caches groups that is not registered yet to registry.
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.affinityReadyFuture(AffinityTopologyVersion topVer)	Gets affinity ready future, a future that will be completed after affinity with given topology version is calculated.
@NotNull IgniteInternalFuture<AffinityTopologyVersion>	GridCachePartitionExchangeManager.affinityReadyFuture(AffinityTopologyVersion ver)
@Nullable 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> @Nullable IgniteInternalFuture<T>	GridCacheAdapter.asyncOpAcquire(boolean retry)	Tries to acquire asynchronous operations permit, if limited.
@Nullable IgniteInternalFuture<?>	GridCacheMvccManager.atomicFuture(long futId)	Gets future by given future ID.
IgniteInternalFuture<Boolean>	WalStateManager.changeWalMode(Collection<String> cacheNames, boolean enabled)	Change WAL mode.
IgniteInternalFuture<?>	GridCacheAdapter.clearAllAsync(Set<? extends K> keys)
IgniteInternalFuture<?>	GridCacheProxyImpl.clearAllAsync(Set<? extends K> keys)
IgniteInternalFuture<?>	IgniteInternalCache.clearAllAsync(Set<? extends K> keys)
IgniteInternalFuture<?>	GridCacheAdapter.clearAsync()
IgniteInternalFuture<?>	GridCacheAdapter.clearAsync(K key)
IgniteInternalFuture<?>	GridCacheProxyImpl.clearAsync()
IgniteInternalFuture<?>	GridCacheProxyImpl.clearAsync(K key)
IgniteInternalFuture<?>	IgniteInternalCache.clearAsync()
IgniteInternalFuture<?>	IgniteInternalCache.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>	GridCacheAdapter.containsKeyAsync(K key)
IgniteInternalFuture<Boolean>	GridCacheProxyImpl.containsKeyAsync(K key)
IgniteInternalFuture<Boolean>	IgniteInternalCache.containsKeyAsync(K key)
IgniteInternalFuture<Boolean>	GridCacheAdapter.containsKeysAsync(Collection<? extends K> keys)
IgniteInternalFuture<Boolean>	GridCacheProxyImpl.containsKeysAsync(Collection<? extends K> keys)
IgniteInternalFuture<Boolean>	IgniteInternalCache.containsKeysAsync(Collection<? extends K> keys)
IgniteInternalFuture<?>	GridCacheProcessor.createFromTemplate(String cacheName)	Dynamically starts cache using template configuration.
IgniteInternalFuture<Void>	GridCachePartitionExchangeManager.deferStopCachesOnClientReconnect(Collection<GridCacheAdapter> caches)
@NotNull 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, IgniteUuid restartId)
IgniteInternalFuture<?>	GridCacheProcessor.dynamicDestroyCaches(Collection<String> cacheNames, boolean checkThreadTx)
IgniteInternalFuture<?>	GridCacheProcessor.dynamicDestroyCaches(Collection<String> cacheNames, boolean checkThreadTx, boolean destroy)
IgniteInternalFuture<Boolean>	GridCacheProcessor.dynamicStartCache(@Nullable CacheConfiguration ccfg, String cacheName, @Nullable NearCacheConfiguration nearCfg, boolean failIfExists, boolean failIfNotStarted, boolean checkThreadTx)	Dynamically starts cache.
IgniteInternalFuture<Boolean>	GridCacheProcessor.dynamicStartCache(@Nullable CacheConfiguration ccfg, String cacheName, @Nullable NearCacheConfiguration nearCfg, CacheType cacheType, boolean sql, boolean failIfExists, boolean failIfNotStarted, boolean checkThreadTx)	Dynamically starts cache.
IgniteInternalFuture<Boolean>	GridCacheProcessor.dynamicStartCaches(Collection<CacheConfiguration> ccfgList, boolean failIfExists, boolean checkThreadTx, boolean disabledAfterStart)	Dynamically starts multiple caches.
IgniteInternalFuture<Boolean>	GridCacheProcessor.dynamicStartCachesByStoredConf(Collection<StoredCacheData> storedCacheDataList, boolean failIfExists, boolean checkThreadTx, boolean disabledAfterStart, IgniteUuid restartId)	Dynamically starts multiple caches.
IgniteInternalFuture<Boolean>	GridCacheProcessor.dynamicStartSqlCache(CacheConfiguration ccfg)	Dynamically starts cache as a result of SQL CREATE TABLE command.
IgniteInternalFuture<?>	GridCacheProcessor.finalizePartitionsCounters()	Finalizes partitions update counters.
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<?>	GridCacheMvccManager.finishRemoteTxs(AffinityTopologyVersion topVer)	Creates a future that will wait for finishing all remote transactions (primary -> backup) with topology version less or equal to topVer.
IgniteInternalFuture<Boolean>	GridCachePartitionExchangeManager.forceRebalance(GridDhtPartitionExchangeId exchId)
IgniteInternalFuture<Boolean>	GridCachePreloader.forceRebalance()	Force Rebalance process.
IgniteInternalFuture<Boolean>	GridCachePreloaderAdapter.forceRebalance()	Force Rebalance process.
IgniteInternalFuture<GridCacheReturn>	GridCacheReturnCompletableWrapper.fut()	Allows wait for properly initialized value.
IgniteInternalFuture<?>	GridCacheAdapter.FutureHolder.future()	Gets future.
IgniteInternalFuture<Map<K,V>>	GridCacheAdapter.getAllAsync(@Nullable Collection<? extends K> keys)	Asynchronously retrieves values mapped to the specified keys from cache.
protected abstract IgniteInternalFuture<Map<K,V>>	GridCacheAdapter.getAllAsync(@Nullable Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, String taskName, boolean deserializeBinary, boolean recovery, ReadRepairStrategy readRepairStrategy, boolean skipVals, boolean needVer)
IgniteInternalFuture<Map<K,V>>	GridCacheProxyImpl.getAllAsync(@Nullable Collection<? extends K> keys)	Asynchronously retrieves values mapped to the specified keys from cache.
IgniteInternalFuture<Map<K,V>>	IgniteInternalCache.getAllAsync(@Nullable Collection<? extends K> keys)	Asynchronously retrieves values mapped to the specified keys from cache.
IgniteInternalFuture<Map<K,V>>	GridCacheAdapter.getAllOutTxAsync(Set<? extends K> keys)	Gets values from cache.
@Nullable IgniteInternalFuture<Map<K,V>>	GridCacheProxyImpl.getAllOutTxAsync(Set<? extends K> keys)	Gets values from cache.
IgniteInternalFuture<Map<K,V>>	IgniteInternalCache.getAllOutTxAsync(Set<? extends K> keys)	Gets values from 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, @Nullable CacheEntryPredicate filter)
IgniteInternalFuture<V>	GridCacheProxyImpl.getAndPutAsync(K key, V val)	Asynchronously stores given key-value pair in cache.
IgniteInternalFuture<V>	IgniteInternalCache.getAndPutAsync(K key, V val)	Asynchronously stores given key-value pair in cache.
IgniteInternalFuture<V>	GridCacheAdapter.getAndPutAsync0(K key, V val, @Nullable CacheEntryPredicate filter)
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>	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>	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>	GridCacheAdapter.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>	IgniteInternalCache.getAndRemoveAsync(K key)	Asynchronously removes given key mapping from cache.
protected IgniteInternalFuture<V>	GridCacheAdapter.getAndRemoveAsync0(K key)
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>	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>	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>	GridCacheAdapter.getAsync(K key)	Asynchronously retrieves value mapped to the specified key from cache.
protected IgniteInternalFuture<V>	GridCacheAdapter.getAsync(K key, boolean forcePrimary, boolean skipTx, String taskName, boolean deserializeBinary, boolean skipVals, boolean needVer)
IgniteInternalFuture<V>	GridCacheProxyImpl.getAsync(K key)	Asynchronously retrieves value mapped to the specified key from cache.
IgniteInternalFuture<V>	IgniteInternalCache.getAsync(K key)	Asynchronously retrieves value mapped to the specified key from cache.
IgniteInternalFuture<Collection<CacheEntry<K,V>>>	GridCacheAdapter.getEntriesAsync(@Nullable Collection<? extends K> keys)	Asynchronously retrieves values mapped to the specified keys from cache.
IgniteInternalFuture<Collection<CacheEntry<K,V>>>	GridCacheProxyImpl.getEntriesAsync(@Nullable Collection<? extends K> keys)	Asynchronously retrieves values mapped to the specified keys from cache.
IgniteInternalFuture<Collection<CacheEntry<K,V>>>	IgniteInternalCache.getEntriesAsync(@Nullable Collection<? extends K> keys)	Asynchronously retrieves values mapped to the specified keys from cache.
IgniteInternalFuture<CacheEntry<K,V>>	GridCacheAdapter.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>>	IgniteInternalCache.getEntryAsync(K key)	Asynchronously retrieves value mapped to the specified key from cache.
IgniteInternalFuture<V>	GridCacheAdapter.getForcePrimaryAsync(K key)	Asynchronously gets value from cache.
IgniteInternalFuture<V>	GridCacheProxyImpl.getForcePrimaryAsync(K key)	Asynchronously gets value from cache.
IgniteInternalFuture<V>	IgniteInternalCache.getForcePrimaryAsync(K key)	Asynchronously gets value from cache.
IgniteInternalFuture<?>	GridCacheProcessor.getOrCreateFromTemplate(String cacheName, boolean checkThreadTx)	Dynamically starts cache using template configuration.
IgniteInternalFuture<?>	GridCacheProcessor.getOrCreateFromTemplate(String cacheName, String templateName, CacheConfigurationOverride cfgOverride, boolean checkThreadTx)	Dynamically starts cache using template configuration.
IgniteInternalFuture<?>	CachesRegistry.init(Map<Integer,CacheGroupDescriptor> groupDescriptors, Map<String,DynamicCacheDescriptor> cacheDescriptors)	Removes currently registered cache groups and caches.
IgniteInternalFuture<Map<Integer,Map<Integer,List<UUID>>>>	CacheAffinitySharedManager.initAffinityOnNodeLeft(GridDhtPartitionsExchangeFuture fut)
IgniteInternalFuture<?>	CacheAffinitySharedManager.initCachesOnLocalJoin(Map<Integer,CacheGroupDescriptor> grpDescs, Map<String,DynamicCacheDescriptor> cacheDescs)	Must be called from exchange thread.
IgniteInternalFuture<?>	CacheAffinitySharedManager.initCoordinatorCaches(GridDhtPartitionsExchangeFuture fut, boolean newAff)
IgniteInternalFuture<?>	CacheAffinitySharedManager.initStartedCaches(boolean crd, GridDhtPartitionsExchangeFuture fut, Collection<DynamicCacheDescriptor> descs)	Initialized affinity for cache received from node joining on this exchange.
<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>>>	GridCacheAdapter.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(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(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)
<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>>>	IgniteInternalCache.invokeAllAsync(Set<? extends K> keys, 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)
<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>>	IgniteInternalCache.invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)
IgniteInternalFuture<?>	GridCacheAdapter.loadAll(Set<? extends K> keys, boolean replaceExisting)
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<?>	GridCacheProxyImpl.localLoadCacheAsync(IgniteBiPredicate<K,V> p, @Nullable Object[] args)	Asynchronously delegates to CacheStore.loadCache(IgniteBiInClosure, Object...) method to reload state from the underlying persistent storage.
IgniteInternalFuture<?>	IgniteInternalCache.localLoadCacheAsync(@Nullable IgniteBiPredicate<K,V> p, @Nullable Object... args)	Asynchronously delegates to CacheStore.loadCache(IgniteBiInClosure, Object...) method to reload state from the underlying persistent storage.
IgniteInternalFuture<Boolean>	GridCacheProxyImpl.lockAllAsync(@Nullable Collection<? extends K> keys, long timeout)	All or nothing synchronous lock for passed in keys.
IgniteInternalFuture<Boolean>	IgniteInternalCache.lockAllAsync(@Nullable Collection<? extends K> keys, long timeout)	All or nothing synchronous lock for passed in keys.
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<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>	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<?>	GridCacheSharedContext.nextAffinityReadyFuture(AffinityTopologyVersion curVer)	Gets ready future for the next affinity topology version (used in cases when a node leaves grid).
IgniteInternalFuture<?>	CacheAffinitySharedManager.onCacheChangeRequest(GridDhtPartitionsExchangeFuture fut, boolean crd, ExchangeActions exchActions)	Called on exchange initiated for cache start/stop request.
IgniteInternalFuture<?>	GridCacheProcessor.onReconnected(boolean clusterRestarted)	Client reconnected callback.
IgniteInternalFuture<T>	GridCacheAdapter.AsyncOp.op(GridNearTxLocal tx)
abstract IgniteInternalFuture<T>	GridCacheAdapter.AsyncOp.op(GridNearTxLocal tx, AffinityTopologyVersion readyTopVer)
IgniteInternalFuture<?>	GridCacheSharedContext.partitionRecoveryFuture(AffinityTopologyVersion topVer, ClusterNode node)	Captures all prepared operations that we need to wait before we able to perform PME-free switch.
IgniteInternalFuture<?>	GridCacheSharedContext.partitionReleaseFuture(AffinityTopologyVersion topVer)	Captures all ongoing operations that we need to wait before we can proceed to the next topology version.
IgniteInternalFuture<?>	GridCacheAdapter.preloadPartitionAsync(int part)	Preload cache partition.
IgniteInternalFuture<?>	GridCacheProxyImpl.preloadPartitionAsync(int part)	Preload cache partition.
IgniteInternalFuture<?>	IgniteInternalCache.preloadPartitionAsync(int part)	Preload cache partition.
IgniteInternalFuture<?>	GridCacheAdapter.putAllAsync(Map<? extends K,? extends V> m)	Asynchronously stores given key-value pairs in cache.
IgniteInternalFuture<?>	GridCacheProxyImpl.putAllAsync(@Nullable Map<? extends K,? extends V> m)	Asynchronously stores given key-value pairs in cache.
IgniteInternalFuture<?>	IgniteInternalCache.putAllAsync(@Nullable 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<?>	GridCacheAdapter.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)	Store DR data asynchronously.
IgniteInternalFuture<?>	GridCacheProxyImpl.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)	Store DR data asynchronously.
IgniteInternalFuture<?>	IgniteInternalCache.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)	Store DR data asynchronously.
IgniteInternalFuture<Boolean>	GridCacheAdapter.putAsync(K key, V val)	Stores given key-value pair in cache.
IgniteInternalFuture<Boolean>	GridCacheAdapter.putAsync(K key, V val, @Nullable CacheEntryPredicate filter)
IgniteInternalFuture<Boolean>	GridCacheProxyImpl.putAsync(K key, V val)	Stores given key-value pair in cache.
IgniteInternalFuture<Boolean>	IgniteInternalCache.putAsync(K key, V val)	Stores given key-value pair in cache.
IgniteInternalFuture<Boolean>	GridCacheAdapter.putAsync0(K key, V val, @Nullable CacheEntryPredicate filter)
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<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>	IgniteInternalCache.putIfAbsentAsync(K key, V val)	Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
IgniteInternalFuture<?>	GridCacheAdapter.rebalance()	Forces this cache node to re-balance its partitions.
IgniteInternalFuture<?>	GridCacheProxyImpl.rebalance()	Forces this cache node to re-balance its partitions.
IgniteInternalFuture<?>	IgniteInternalCache.rebalance()	Forces this cache node to re-balance its partitions.
IgniteInternalFuture<Boolean>	GridCachePreloader.rebalanceFuture()
IgniteInternalFuture<Boolean>	GridCachePreloaderAdapter.rebalanceFuture()
IgniteInternalFuture<?>	GridCachePartitionExchangeManager.reconnectExchangeFuture()
IgniteInternalFuture<Object>	GridCacheExplicitLockSpan.releaseFuture()	Gets span release future.
IgniteInternalFuture<?>	GridCacheAdapter.removeAllAsync(@Nullable Collection<? extends K> keys)	Asynchronously removes given key mappings from cache for entries.
IgniteInternalFuture<?>	GridCacheProxyImpl.removeAllAsync()
IgniteInternalFuture<?>	GridCacheProxyImpl.removeAllAsync(@Nullable Collection<? extends K> keys)	Asynchronously removes given key mappings from cache for entries.
IgniteInternalFuture<?>	IgniteInternalCache.removeAllAsync()
IgniteInternalFuture<?>	IgniteInternalCache.removeAllAsync(@Nullable Collection<? extends K> keys)	Asynchronously removes given key mappings from cache for entries.
protected IgniteInternalFuture<Object>	GridCacheAdapter.removeAllAsync0(Collection<? extends K> keys)
IgniteInternalFuture<?>	GridCacheAdapter.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)	Removes DR data asynchronously.
IgniteInternalFuture<?>	GridCacheProxyImpl.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)	Removes DR data asynchronously.
IgniteInternalFuture<?>	IgniteInternalCache.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)	Removes DR data asynchronously.
IgniteInternalFuture<Boolean>	GridCacheAdapter.removeAsync(K key)	Asynchronously removes given key mapping from cache.
IgniteInternalFuture<Boolean>	GridCacheAdapter.removeAsync(K key, @Nullable CacheEntryPredicate filter)
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<Boolean>	GridCacheProxyImpl.removeAsync(K key)	Asynchronously removes given key mapping from cache.
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>	IgniteInternalCache.removeAsync(K key)	Asynchronously removes given key mapping from cache.
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.
protected IgniteInternalFuture<Boolean>	GridCacheAdapter.removeAsync0(K key, @Nullable CacheEntryPredicate filter)
@Nullable IgniteInternalFuture<?>	GridCacheMvccManager.removeAtomicFuture(long futId)
IgniteInternalFuture<Map<K,V>>	GridCacheAdapter.repairableGetAllAsync(@Nullable Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, String taskName, boolean deserializeBinary, boolean recovery, ReadRepairStrategy readRepairStrategy, boolean skipVals, boolean needVer)
IgniteInternalFuture<V>	GridCacheAdapter.repairableGetAsync(K key, boolean deserializeBinary, boolean needVer, ReadRepairStrategy readRepairStrategy)
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>	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>	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>	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>	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>	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<?>	GridCacheProcessor.resetCacheState(Collection<String> cacheNames)	Resets cache state after the cache has been moved to recovery state.
IgniteInternalFuture	GridCacheSharedContext.rollbackTxAsync(GridNearTxLocal tx)
IgniteInternalFuture<Integer>	GridCacheAdapter.sizeAsync(CachePeekMode[] peekModes)
IgniteInternalFuture<Integer>	GridCacheProxyImpl.sizeAsync(CachePeekMode[] peekModes)
IgniteInternalFuture<Integer>	IgniteInternalCache.sizeAsync(CachePeekMode[] peekModes)
IgniteInternalFuture<Long>	GridCacheAdapter.sizeLongAsync(int part, CachePeekMode[] peekModes)
IgniteInternalFuture<Long>	GridCacheAdapter.sizeLongAsync(CachePeekMode[] peekModes)
IgniteInternalFuture<Long>	GridCacheProxyImpl.sizeLongAsync(int partition, CachePeekMode[] peekModes)
IgniteInternalFuture<Long>	GridCacheProxyImpl.sizeLongAsync(CachePeekMode[] peekModes)
IgniteInternalFuture<Long>	IgniteInternalCache.sizeLongAsync(int partition, CachePeekMode[] peekModes)
IgniteInternalFuture<Long>	IgniteInternalCache.sizeLongAsync(CachePeekMode[] peekModes)
IgniteInternalFuture<?>	GridCacheProcessor.startCachesOnLocalJoin(AffinityTopologyVersion exchTopVer, LocalJoinCachesContext locJoinCtx)
IgniteInternalFuture<Object>	GridCachePreloader.startFuture()
IgniteInternalFuture<Object>	GridCachePreloaderAdapter.startFuture()
IgniteInternalFuture<?>	GridCachePreloader.syncFuture()
IgniteInternalFuture<?>	GridCachePreloaderAdapter.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)
IgniteInternalFuture<?>	CachesRegistry.update(ExchangeActions exchActions)	Adds caches and cache groups to start from exchActions.

Methods in org.apache.ignite.internal.processors.cache that return types with arguments of type IgniteInternalFuture

Modifier and Type	Method	Description
static IgniteInClosure<IgniteInternalFuture<?>>	GridCacheUtils.errorLogger(IgniteLogger log, Class<? extends Exception>... excl)
AtomicReference<IgniteInternalFuture<Boolean>>	GridCacheContext.lastRemoveAllJobFut()	Returns future that assigned to last performing GridDistributedCacheAdapter.GlobalRemoveAllJob.

Methods in org.apache.ignite.internal.processors.cache with parameters of type IgniteInternalFuture

Modifier and Type	Method	Description
void	GridCacheAdapter.UpdateTimeStatClosure.apply(IgniteInternalFuture<T> fut)	Closure body.
protected <R> IgniteFuture<R>	IgniteCacheProxyImpl.createFuture(IgniteInternalFuture<R> fut)
void	GridCacheAdapter.FutureHolder.future(@Nullable IgniteInternalFuture<?> fut)	Sets future.
void	GridCacheAdapter.FutureHolder.saveFuture(IgniteInternalFuture<?> fut)	Saves future in the 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	Description
IgniteCacheFutureImpl(IgniteInternalFuture<V> fut, Executor defaultExecutor)	Constructor.

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

Methods in org.apache.ignite.internal.processors.cache.binary that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<?>	CacheObjectBinaryProcessorImpl.onReconnected(boolean clusterRestarted)	Client reconnected callback.

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

Modifier and Type	Method	Description
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, @Nullable IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, @Nullable 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

Modifier and Type	Interface	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	Description
class	CacheDistributedGetFutureAdapter<K,V>
protected class	CacheDistributedGetFutureAdapter.AbstractMiniFuture	Mini-future for get operations.
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

Fields in org.apache.ignite.internal.processors.cache.distributed.dht declared as IgniteInternalFuture

Modifier and Type	Field	Description
protected IgniteInternalFuture<?>	GridDhtTxLocalAdapter.lockFut	Enlist or lock future what is currently in progress.
static IgniteInternalFuture<Boolean>	GridDhtTxLocalAdapter.ROLLBACK_FUT	Asynchronous rollback marker for lock futures.

Methods in org.apache.ignite.internal.processors.cache.distributed.dht that return IgniteInternalFuture

Modifier and Type	Method	Description
@Nullable IgniteInternalFuture<Boolean>	GridDhtTxLocalAdapter.addEntry(long msgId, IgniteTxEntry e)
@Nullable IgniteInternalFuture<Boolean>	GridDhtCacheEntry.addReader(UUID nodeId, long msgId, AffinityTopologyVersion topVer)
protected @Nullable IgniteInternalFuture<Boolean>	GridDhtTxLocal.addReader(long msgId, GridDhtCacheEntry cached, IgniteTxEntry entry, AffinityTopologyVersion topVer)	Adds reader to cached entry.
protected abstract @Nullable IgniteInternalFuture<Boolean>	GridDhtTxLocalAdapter.addReader(long msgId, GridDhtCacheEntry cached, IgniteTxEntry entry, AffinityTopologyVersion topVer)	Adds reader to cached entry.
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()
@Nullable IgniteInternalFuture<?>	GridDhtTxLocal.currentPrepareFuture()
IgniteInternalFuture<Map<K,V>>	GridDhtCacheAdapter.getAllAsync(@Nullable Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, String taskName, boolean deserializeBinary, boolean recovery, ReadRepairStrategy readRepairStrategy, boolean skipVals, boolean needVer)
IgniteInternalFuture<Boolean>	GridDhtTransactionalCacheAdapter.lockAllAsync(@Nullable 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)
IgniteInternalFuture<GridNearTxPrepareResponse>	GridDhtTxLocal.prepareAsync(GridNearTxPrepareRequest req)	Prepares next batch of entries in dht transaction.
IgniteInternalFuture<IgniteInternalTx>	GridDhtTxLocal.rollbackAsync()	Asynchronously rollback this transaction.
IgniteInternalFuture<IgniteInternalTx>	GridDhtTxLocal.rollbackDhtLocalAsync()
IgniteInternalFuture<?>	GridDhtTxLocal.salvageTx()
@Nullable IgniteInternalFuture<?>	GridDhtTxLocalAdapter.tryRollbackAsync()	Prepare async rollback.

Methods in org.apache.ignite.internal.processors.cache.distributed.dht with parameters of type IgniteInternalFuture

Modifier and Type	Method	Description
void	GridDhtTxLocalAdapter.clearLockFuture(@Nullable IgniteInternalFuture cond)	Clears lock future.
protected abstract boolean	CacheDistributedGetFutureAdapter.isMini(IgniteInternalFuture<?> f)
protected boolean	GridPartitionedGetFuture.isMini(IgniteInternalFuture<?> f)
boolean	GridDhtTxLocalAdapter.updateLockFuture(IgniteInternalFuture<?> oldFut, IgniteInternalFuture<?> newFut)	Atomically updates lock future.

Constructors in org.apache.ignite.internal.processors.cache.distributed.dht with parameters of type IgniteInternalFuture

Constructor	Description
GridDhtEmbeddedFuture(IgniteInternalFuture<B> embedded, IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c)
GridDhtEmbeddedFuture(IgniteBiClosure<B,Exception,A> c, IgniteInternalFuture<B> embedded)

Constructor parameters in org.apache.ignite.internal.processors.cache.distributed.dht with type arguments of type IgniteInternalFuture

Constructor	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

Modifier and Type	Class	Description
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

Modifier and Type	Method	Description
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(@Nullable Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, String taskName, boolean deserializeBinary, boolean recovery, ReadRepairStrategy readRepairStrategy, boolean skipVals, boolean needVer)
IgniteInternalFuture<V>	GridDhtAtomicCache.getAndPutAsync0(K key, V val, @Nullable CacheEntryPredicate filter)
IgniteInternalFuture<V>	GridDhtAtomicCache.getAndRemoveAsync0(K key)
protected IgniteInternalFuture<V>	GridDhtAtomicCache.getAsync(K key, boolean forcePrimary, boolean skipTx, 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, @Nullable IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, @Nullable 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, @Nullable 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, @Nullable 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

Modifier and Type	Class	Description
class	GridDhtColocatedLockFuture	Colocated cache lock future.

Methods in org.apache.ignite.internal.processors.cache.distributed.dht.colocated that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<Map<K,V>>	GridDhtColocatedCache.getAllAsync(@Nullable Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, String taskName, boolean deserializeBinary, boolean recovery, ReadRepairStrategy readRepairStrategy, boolean skipVals, boolean needVer)
protected IgniteInternalFuture<V>	GridDhtColocatedCache.getAsync(K key, boolean forcePrimary, boolean skipTx, String taskName, boolean deserializeBinary, boolean skipVals, boolean needVer)
IgniteInternalFuture<Map<K,V>>	GridDhtColocatedCache.loadAsync(@Nullable Collection<KeyCacheObject> keys, boolean readThrough, boolean forcePrimary, AffinityTopologyVersion topVer, String taskName, boolean deserializeBinary, boolean recovery, @Nullable IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean needVer, boolean keepCacheObj, @Nullable String txLbl)
IgniteInternalFuture<Object>	GridDhtColocatedCache.loadAsync(KeyCacheObject key, boolean readThrough, boolean forcePrimary, AffinityTopologyVersion topVer, String taskName, boolean deserializeBinary, @Nullable IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean needVer, boolean keepCacheObj, boolean recovery, @Nullable String txLbl)
IgniteInternalFuture<Boolean>	GridDhtColocatedCache.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, @Nullable IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, @Nullable 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

Modifier and Type	Class	Description
class	GridDhtForceKeysFuture<K,V>	Force keys request future.
static class	GridDhtPartitionDemander.RebalanceFuture	The future is created for each topology version if some partitions should present by affinity and completed when all partitions are transferred.
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

Modifier and Type	Method	Description
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.dht.topology

Methods in org.apache.ignite.internal.processors.cache.distributed.dht.topology that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<?>	GridDhtLocalPartition.clearAsync()	Initiates a partition clearing attempt.
IgniteInternalFuture<?>	PartitionsEvictManager.evictPartitionAsync(CacheGroupContext grp, GridDhtLocalPartition part, GridFutureAdapter<?> finishFut)	Adds partition to eviction queue and starts eviction process if permit available.
IgniteInternalFuture<?>	GridDhtLocalPartition.rent()	Initiates partition eviction process and returns an eviction future.

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

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

Modifier and Type	Interface	Description
interface	NearTxFinishFuture

Classes in org.apache.ignite.internal.processors.cache.distributed.near that implement IgniteInternalFuture

Modifier and Type	Class	Description
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

Modifier and Type	Method	Description
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()
@Nullable IgniteInternalFuture<?>	GridNearTxLocal.currentPrepareFuture()
protected IgniteInternalFuture<Map<K,V>>	GridNearAtomicCache.getAllAsync(@Nullable Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, String taskName, boolean deserializeBinary, boolean recovery, ReadRepairStrategy readRepairStrategy, boolean skipVals, boolean needVer)
IgniteInternalFuture<Map<K,V>>	GridNearTransactionalCache.getAllAsync(@Nullable Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, String taskName, boolean deserializeBinary, boolean recovery, ReadRepairStrategy readRepairStrategy, boolean skipVals, boolean needVer)
<K,V> IgniteInternalFuture<Map<K,V>>	GridNearTxLocal.getAllAsync(GridCacheContext cacheCtx, @Nullable AffinityTopologyVersion entryTopVer, Collection<KeyCacheObject> keys, boolean deserializeBinary, boolean skipVals, boolean keepCacheObjects, boolean skipStore, boolean recovery, ReadRepairStrategy readRepairStrategy, boolean needVer)
IgniteInternalFuture<V>	GridNearAtomicCache.getAndPutAsync0(K key, V val, @Nullable 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)
<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>>	GridNearAtomicCache.invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)
<K,V,T> IgniteInternalFuture<GridCacheReturn>	GridNearTxLocal.invokeAsync(GridCacheContext cacheCtx, @Nullable AffinityTopologyVersion entryTopVer, @Nullable Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,Object>> map, Object... invokeArgs)
<K,V> IgniteInternalFuture<GridCacheReturn>	GridNearTxLocal.invokeAsync(GridCacheContext cacheCtx, @Nullable AffinityTopologyVersion entryTopVer, K key, javax.cache.processor.EntryProcessor<K,V,Object> entryProc, Object... invokeArgs)
IgniteInternalFuture<Map<K,V>>	GridNearCacheAdapter.loadAsync(@Nullable IgniteInternalTx tx, @Nullable Collection<KeyCacheObject> keys, boolean forcePrimary, String taskName, boolean deserializeBinary, boolean recovery, @Nullable javax.cache.expiry.ExpiryPolicy expiryPlc, boolean skipVal, boolean skipStore, boolean needVer)
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>	GridNearAtomicCache.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, @Nullable IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, @Nullable TransactionIsolation isolation, long createTtl, long accessTtl)
protected IgniteInternalFuture<Boolean>	GridNearTransactionalCache.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()
IgniteInternalFuture<?>	GridNearAtomicCache.putAllAsync(Map<? extends K,? extends V> m)	Asynchronously stores given key-value pairs in cache.
<K,V> IgniteInternalFuture<GridCacheReturn>	GridNearTxLocal.putAllAsync(GridCacheContext cacheCtx, @Nullable AffinityTopologyVersion entryTopVer, Map<? extends K,? extends V> map, boolean retval)
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, @Nullable AffinityTopologyVersion entryTopVer, K key, V val, boolean retval, CacheEntryPredicate filter)
IgniteInternalFuture<Boolean>	GridNearAtomicCache.putAsync0(K key, V val, @Nullable 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, @Nullable 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, @Nullable 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<IgniteInternalTx>	GridNearTxLocal.rollbackNearTxLocalAsync(boolean clearThreadMap, boolean onTimeout)
IgniteInternalFuture<?>	GridNearTxLocal.salvageTx()

Methods in org.apache.ignite.internal.processors.cache.distributed.near with parameters of type IgniteInternalFuture

Modifier and Type	Method	Description
protected boolean	GridNearGetFuture.isMini(IgniteInternalFuture<?> f)

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

Classes in org.apache.ignite.internal.processors.cache.distributed.near.consistency that implement IgniteInternalFuture

Modifier and Type	Class	Description
class	GridCompoundReadRepairFuture	Compound future that represents the result of the external fixes for some keys.
class	GridNearReadRepairAbstractFuture
class	GridNearReadRepairCheckOnlyFuture	Checks data consistency.
class	GridNearReadRepairFuture	Checks data consistency.

Methods in org.apache.ignite.internal.processors.cache.distributed.near.consistency that return IgniteInternalFuture

Modifier and Type	Method	Description
<K,V> IgniteInternalFuture<Map<K,V>>	GridNearReadRepairCheckOnlyFuture.multi()	Returns a future represents entries map.
<K,V> IgniteInternalFuture<V>	GridNearReadRepairCheckOnlyFuture.single()	Returns a future represents 1 entry's value.

Methods in org.apache.ignite.internal.processors.cache.distributed.near.consistency with parameters of type IgniteInternalFuture

Modifier and Type	Method	Description
void	GridCompoundReadRepairFuture.add(IgniteInternalFuture<Void> fut)
void	GridCompoundReadRepairFuture.apply(IgniteInternalFuture<Void> fut)	Closure body.
protected void	GridNearReadRepairAbstractFuture.onResult(IgniteInternalFuture<Map<KeyCacheObject,EntryGetResult>> finished)	Collects results of each 'get' future and prepares an overall result of the operation.

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

Methods in org.apache.ignite.internal.processors.cache.persistence that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<Void>	GridCacheDatabaseSharedManager.enableCheckpoints(boolean enable)	For test use only.
@Nullable IgniteInternalFuture	GridCacheDatabaseSharedManager.wakeupForCheckpoint(String reason)
@Nullable IgniteInternalFuture	IgniteCacheDatabaseSharedManager.wakeupForCheckpoint(String reason)

Method parameters in org.apache.ignite.internal.processors.cache.persistence with type arguments of type IgniteInternalFuture

Modifier and Type	Method	Description
<R> CheckpointProgress	GridCacheDatabaseSharedManager.forceNewCheckpoint(String reason, IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)	Schedule a new checkpoint.
<R> @Nullable CheckpointProgress	IgniteCacheDatabaseSharedManager.forceNewCheckpoint(String reason, IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)	Schedule a new checkpoint.
<R> void	GridCacheDatabaseSharedManager.waitForCheckpoint(String reason, IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)	Waits until current state is checkpointed and execution listeners after finish.
<R> void	IgniteCacheDatabaseSharedManager.waitForCheckpoint(String reason, IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)	Waits until current state is checkpointed and execution listeners after finish.

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

Methods in org.apache.ignite.internal.processors.cache.persistence.checkpoint that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<Void>	Checkpointer.enableCheckpoints(boolean enable)	Deprecated. Should be rewritten to public API.
IgniteInternalFuture<Void>	CheckpointManager.enableCheckpoints(boolean enable)	For test use only.
IgniteInternalFuture<Void>	LightweightCheckpointManager.enableCheckpoints(boolean enable)	For test use only.
IgniteInternalFuture<?>	CheckpointContextImpl.finishedStateFut()
IgniteInternalFuture<?>	CheckpointListener.Context.finishedStateFut()

Method parameters in org.apache.ignite.internal.processors.cache.persistence.checkpoint with type arguments of type IgniteInternalFuture

Modifier and Type	Method	Description
<R> CheckpointProgress	CheckpointManager.forceCheckpoint(String reason, IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)	Start the new checkpoint immediately.
<R> CheckpointProgress	LightweightCheckpointManager.forceCheckpoint(String reason, IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)	Start the new checkpoint immediately.
<R> CheckpointProgress	Checkpointer.scheduleCheckpoint(long delayFromNow, String reason, IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)	Change the information for a scheduled checkpoint if it was scheduled further than delayFromNow, or do nothing otherwise.

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

Methods in org.apache.ignite.internal.processors.cache.persistence.defragmentation that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<?>	CachePartitionDefragmentationManager.completionFuture()

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

Methods in org.apache.ignite.internal.processors.cache.persistence.file that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<Void>	FileDownloader.finishFuture()

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

Methods in org.apache.ignite.internal.processors.cache.persistence.metastorage.pendingtask that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<DurableBackgroundTaskResult<R>>	DurableBackgroundTask.executeAsync(GridKernalContext ctx)	Asynchronous task execution.

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

Modifier and Type	Method	Description
IgniteInternalFuture<Void>	PageMemoryEx.clearAsync(LoadedPagesMap.KeyPredicate pred, boolean cleanDirty)	Asynchronously clears pages satisfying the given predicate.
IgniteInternalFuture<Void>	PageMemoryImpl.clearAsync(LoadedPagesMap.KeyPredicate pred, boolean cleanDirty)	Asynchronously clears pages satisfying the given predicate.

Methods in org.apache.ignite.internal.processors.cache.persistence.pagemem with parameters of type IgniteInternalFuture

Modifier and Type	Method	Description
GridMultiCollectionWrapper<FullPageId>	PageMemoryEx.beginCheckpoint(IgniteInternalFuture allowToReplace)	Gets a collection of dirty page IDs since the last checkpoint.
GridMultiCollectionWrapper<FullPageId>	PageMemoryImpl.beginCheckpoint(IgniteInternalFuture allowToReplace)	Gets a collection of dirty page IDs since the last checkpoint.

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

Classes in org.apache.ignite.internal.processors.cache.persistence.snapshot that implement IgniteInternalFuture

Modifier and Type	Class	Description
class	AbstractCreateSnapshotFutureTask
static class	IgniteSnapshotManager.ClusterSnapshotFuture
class	SnapshotFinishedFutureTask
class	SnapshotResponseRemoteFutureTask

Methods in org.apache.ignite.internal.processors.cache.persistence.snapshot that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<SnapshotPartitionsVerifyTaskResult>	IgniteSnapshotManager.checkSnapshot(String name, @Nullable String snpPath)	Checks snapshot.
IgniteInternalFuture<SnapshotPartitionsVerifyTaskResult>	IgniteSnapshotManager.checkSnapshot(String name, @Nullable String snpPath, int incIdx)	Checks snapshot and its increments.
IgniteInternalFuture<SnapshotPartitionsVerifyTaskResult>	IgniteSnapshotManager.checkSnapshot(String name, @Nullable String snpPath, @Nullable Collection<String> grps, boolean includeCustomHandlers, int incIdx, boolean check)	The check snapshot procedure performs compute operation over the whole cluster to verify the snapshot entirety and partitions consistency.
IgniteInternalFuture<Void>	IgniteSnapshotManager.requestRemoteSnapshotFiles(UUID rmtNodeId, UUID reqId, String snpName, @Nullable String rmtSnpPath, Map<Integer,Set<Integer>> parts, BooleanSupplier stopChecker, BiConsumer<@Nullable File,@Nullable Throwable> partHnd)

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

Classes in org.apache.ignite.internal.processors.cache.persistence.snapshot.dump that implement IgniteInternalFuture

Modifier and Type	Class	Description
class	CreateDumpFutureTask	Task creates cache group dump.

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	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	Description
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.
static class	GridCacheQueryManager.QueryResult<K,V>

Methods in org.apache.ignite.internal.processors.cache.query that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<List<GridQueryFieldMetadata>>	GridCacheDistributedFieldsQueryFuture.metadata()
IgniteInternalFuture<List<GridQueryFieldMetadata>>	GridCacheLocalFieldsQueryFuture.metadata()
IgniteInternalFuture<List<GridQueryFieldMetadata>>	GridCacheQueryMetadataAware.metadata()
IgniteInternalFuture<Collection<GridCacheSqlMetadata>>	GridCacheQueryManager.sqlMetadataAsync()	Gets SQL metadata asynchronously.

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

Fields in org.apache.ignite.internal.processors.cache.query.continuous declared as IgniteInternalFuture

Modifier and Type	Field	Description
protected IgniteInternalFuture<Void>	CacheContinuousQueryHandler.initFut	Initialization future.
protected IgniteInternalFuture<Void>	CacheContinuousQueryHandler.p2pUnmarshalFut	P2P unmarshalling future.

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	Description
IgniteInternalFuture<T>	IgniteTxLocalAdapter.PostLockClosure1.apply(Boolean locked, @Nullable Exception e)	Closure body.
IgniteInternalFuture<T>	IgniteTxLocalAdapter.PostLockClosure2.apply(Boolean locked, @Nullable Exception e)	Closure body.
IgniteInternalFuture<IgniteInternalTx>	IgniteInternalTx.commitAsync()	Asynchronously commits this transaction by initiating two-phase-commit process.
IgniteInternalFuture<Boolean>	IgniteTxManager.commitIfPrepared(IgniteInternalTx tx, Set<UUID> failedNodeIds)	Commits transaction in case when node started transaction failed, but all related transactions were prepared (invalidates transaction if it is not fully prepared).
@Nullable IgniteInternalFuture<?>	IgniteInternalTx.currentPrepareFuture()
@Nullable IgniteInternalFuture<?>	IgniteTxAdapter.currentPrepareFuture()
IgniteInternalFuture<TxDeadlock>	IgniteTxManager.detectDeadlock(IgniteInternalTx tx, Set<IgniteTxKey> keys)	Performs deadlock detection for given keys.
@Nullable IgniteInternalFuture<IgniteInternalTx>	IgniteTxHandler.finish(UUID nodeId, @Nullable GridNearTxLocal locTx, GridNearTxFinishRequest req)
IgniteInternalFuture<?>	IgniteTxManager.finishAllTxs(IgniteInternalFuture<?> finishLocTxsFut, AffinityTopologyVersion topVer)	Creates a future that will wait for finishing all tx updates on backups after all local transactions are finished.
IgniteInternalFuture<IgniteInternalTx>	IgniteTxHandler.finishColocatedLocal(boolean commit, GridNearTxLocal tx)
IgniteInternalFuture<IgniteInternalTx>	IgniteInternalTx.finishFuture()
IgniteInternalFuture<IgniteInternalTx>	IgniteTxAdapter.finishFuture()
IgniteInternalFuture<Boolean>	IgniteTxManager.finishLocalTxs(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.
IgniteInternalFuture<GridNearTxPrepareResponse>	IgniteTxHandler.prepareColocatedTx(GridNearTxLocal locTx, GridNearTxPrepareRequest req)	Prepares local colocated tx.
IgniteInternalFuture<GridNearTxPrepareResponse>	IgniteTxHandler.prepareNearTxLocal(GridNearTxLocal originTx, GridNearTxPrepareRequest req)
IgniteInternalFuture<Boolean>	IgniteTxManager.recoverLocalTxs(AffinityTopologyVersion topVer, ClusterNode node)	Creates a future that will wait for all transactions with failed primary recovery.
IgniteInternalFuture<?>	IgniteTxManager.remoteTxFinishFuture(GridCacheVersion nearVer)
IgniteInternalFuture<IgniteInternalTx>	IgniteInternalTx.rollbackAsync()	Asynchronously rollback this transaction.
@Nullable IgniteInternalFuture<?>	IgniteInternalTx.salvageTx()
IgniteInternalFuture<Boolean>	IgniteTxManager.txCommitted(GridCacheVersion xidVer)
@Nullable 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

Modifier and Type	Method	Description
Collection<IgniteInternalFuture<?>>	IgniteTxManager.deadlockDetectionFutures()

Methods in org.apache.ignite.internal.processors.cache.transactions with parameters of type IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<?>	IgniteTxManager.finishAllTxs(IgniteInternalFuture<?> finishLocTxsFut, AffinityTopologyVersion topVer)	Creates a future that will wait for finishing all tx updates on backups after all local transactions are finished.

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	Description
<T,R> IgniteInternalFuture<Collection<R>>	GridClosureProcessor.broadcast(IgniteClosure<T,R> job, T arg, TaskExecutionOptions opts)
<R> IgniteInternalFuture<Collection<R>>	GridClosureProcessor.callAsync(GridClosureCallMode mode, Collection<? extends Callable<R>> jobs, TaskExecutionOptions opts)
<R> IgniteInternalFuture<R>	GridClosureProcessor.callAsync(GridClosureCallMode mode, Callable<R> job, TaskExecutionOptions opts)
<R> IgniteInternalFuture<R>	GridClosureProcessor.callLocal(@Nullable 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(@Nullable 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

Modifier and Type	Method	Description
IgniteInternalFuture<?>	GridClusterStateProcessor.changeGlobalState(ClusterState state, boolean forceDeactivation, Collection<? extends BaselineNode> baselineNodes, boolean forceChangeBaselineTopology)
IgniteInternalFuture<?>	GridClusterStateProcessor.changeGlobalState(ClusterState state, boolean forceDeactivation, Collection<? extends BaselineNode> baselineNodes, boolean forceChangeBaselineTopology, boolean isAutoAdjust)
IgniteInternalFuture<?>	IGridClusterStateProcessor.changeGlobalState(ClusterState state, boolean forceDeactivation, Collection<? extends BaselineNode> baselineNodes, boolean forceChangeBaselineTopology)
@Nullable IgniteInternalFuture<Boolean>	GridClusterStateProcessor.onLocalJoin(DiscoCache discoCache)
@Nullable IgniteInternalFuture<Boolean>	IGridClusterStateProcessor.onLocalJoin(DiscoCache discoCache)
IgniteInternalFuture<?>	ClusterProcessor.onReconnected(boolean clusterRestarted)	Client reconnected callback.
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

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

Modifier and Type	Method	Description
IgniteInternalFuture<UUID>	GridContinuousProcessor.startRoutine(GridContinuousHandler hnd, boolean locOnly, int bufSize, long interval, boolean autoUnsubscribe, @Nullable 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

Modifier and Type	Method	Description
IgniteInternalFuture<?>	DataStreamerImpl.internalFuture()

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

Methods in org.apache.ignite.internal.processors.datastructures that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<?>	DataStructuresProcessor.onReconnected(boolean clusterRestarted)	Client reconnected callback.

Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.localtask

Methods in org.apache.ignite.internal.processors.localtask that return IgniteInternalFuture

Modifier and Type	Method	Description
<R> IgniteInternalFuture<R>	DurableBackgroundTasksProcessor.executeAsync(DurableBackgroundTask<R> task, boolean save)	Asynchronous execution of a durable background task.
<R> IgniteInternalFuture<R>	DurableBackgroundTasksProcessor.executeAsync(DurableBackgroundTask<R> t, CacheConfiguration cacheCfg)	Overloading the DurableBackgroundTasksProcessor.executeAsync(DurableBackgroundTask, boolean).

Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.metastorage.persistence

Methods in org.apache.ignite.internal.processors.metastorage.persistence that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<?>	DistributedMetaStorageImpl.onReconnected(boolean clusterRestarted)	Client reconnected callback.

Methods in org.apache.ignite.internal.processors.metastorage.persistence with parameters of type IgniteInternalFuture

Modifier and Type	Method	Description
void	DistributedMetaStorageImpl.suspend(IgniteInternalFuture<?> compFut)
void	DmsDataWriterWorker.suspend(IgniteInternalFuture<?> compFut)

Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.odbc

Methods in org.apache.ignite.internal.processors.odbc that return IgniteInternalFuture

Modifier and Type	Method	Description
default IgniteInternalFuture<IgniteInternalTx>	ClientTxSupport.endTxAsync(ClientListenerAbstractConnectionContext ctx, int txId, boolean committed)	End transaction asynchronously.
IgniteInternalFuture<? extends ClientListenerResponse>	ClientAsyncResponse.future()	Future for response.
IgniteInternalFuture<? extends ClientListenerResponse>	ClientListenerAsyncResponse.future()	Future for response.

Constructors in org.apache.ignite.internal.processors.odbc with parameters of type IgniteInternalFuture

Constructor	Description
ClientAsyncResponse(long reqId, IgniteInternalFuture<? extends ClientListenerResponse> fut)	Constructs async response.

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

Methods in org.apache.ignite.internal.processors.platform that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<?>	PlatformProcessorImpl.onReconnected(boolean clusterRestarted)	Client reconnected callback.

Methods in org.apache.ignite.internal.processors.platform with parameters of type IgniteInternalFuture

Modifier and Type	Method	Description
protected PlatformListenable	PlatformAbstractTarget.readAndListenFuture(BinaryRawReader reader, IgniteInternalFuture fut)	Reads future information and listens.

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

Methods in org.apache.ignite.internal.processors.platform.client that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<ClientResponse>	ClientRequest.processAsync(ClientConnectionContext ctx)	Processes the request asynchronously.

Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.platform.client.cache

Methods in org.apache.ignite.internal.processors.platform.client.cache that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<ClientResponse>	ClientCacheClearKeysRequest.processAsync(ClientConnectionContext ctx)	Processes the request asynchronously.
IgniteInternalFuture<ClientResponse>	ClientCacheContainsKeysRequest.processAsync(ClientConnectionContext ctx)	Processes the request asynchronously.
IgniteInternalFuture<ClientResponse>	ClientCacheGetAllRequest.processAsync(ClientConnectionContext ctx)	Processes the request asynchronously.
IgniteInternalFuture<ClientResponse>	ClientCacheInvokeAllRequest.processAsync(ClientConnectionContext ctx)	Processes the request asynchronously.
IgniteInternalFuture<ClientResponse>	ClientCacheKeyRequest.processAsync(ClientConnectionContext ctx)	Processes the request asynchronously.
IgniteInternalFuture<ClientResponse>	ClientCachePutAllRequest.processAsync(ClientConnectionContext ctx)	Processes the request asynchronously.
IgniteInternalFuture<ClientResponse>	ClientCacheRemoveAllRequest.processAsync(ClientConnectionContext ctx)	Processes the request asynchronously.
IgniteInternalFuture<ClientResponse>	ClientCacheRemoveKeysRequest.processAsync(ClientConnectionContext ctx)	Processes the request asynchronously.
IgniteInternalFuture<ClientResponse>	ClientCacheClearKeyRequest.processAsync0(ClientConnectionContext ctx)
IgniteInternalFuture<ClientResponse>	ClientCacheContainsKeyRequest.processAsync0(ClientConnectionContext ctx)
IgniteInternalFuture<ClientResponse>	ClientCacheGetAndPutIfAbsentRequest.processAsync0(ClientConnectionContext ctx)
IgniteInternalFuture<ClientResponse>	ClientCacheGetAndPutRequest.processAsync0(ClientConnectionContext ctx)
protected IgniteInternalFuture<ClientResponse>	ClientCacheGetAndRemoveRequest.processAsync0(ClientConnectionContext ctx)
IgniteInternalFuture<ClientResponse>	ClientCacheGetAndReplaceRequest.processAsync0(ClientConnectionContext ctx)
protected IgniteInternalFuture<ClientResponse>	ClientCacheGetRequest.processAsync0(ClientConnectionContext ctx)
protected IgniteInternalFuture<ClientResponse>	ClientCacheInvokeRequest.processAsync0(ClientConnectionContext ctx)
protected IgniteInternalFuture<ClientResponse>	ClientCacheKeyRequest.processAsync0(ClientConnectionContext ctx)
IgniteInternalFuture<ClientResponse>	ClientCachePutIfAbsentRequest.processAsync0(ClientConnectionContext ctx)
IgniteInternalFuture<ClientResponse>	ClientCachePutRequest.processAsync0(ClientConnectionContext ctx)
IgniteInternalFuture<ClientResponse>	ClientCacheRemoveIfEqualsRequest.processAsync0(ClientConnectionContext ctx)
IgniteInternalFuture<ClientResponse>	ClientCacheRemoveKeyRequest.processAsync0(ClientConnectionContext ctx)
IgniteInternalFuture<ClientResponse>	ClientCacheReplaceIfEqualsRequest.processAsync0(ClientConnectionContext ctx)
IgniteInternalFuture<ClientResponse>	ClientCacheReplaceRequest.processAsync0(ClientConnectionContext ctx)

Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.platform.client.tx

Methods in org.apache.ignite.internal.processors.platform.client.tx that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<ClientResponse>	ClientTxEndRequest.processAsync(ClientConnectionContext ctx)	Processes the request asynchronously.

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

Classes in org.apache.ignite.internal.processors.platform.compute that implement IgniteInternalFuture

Modifier and Type	Class	Description
protected class	PlatformCompute.ComputeConvertingFuture	Wraps ComputeTaskFuture as IgniteInternalFuture.

Methods in org.apache.ignite.internal.processors.platform.compute that return IgniteInternalFuture

Modifier and Type	Method	Description
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.
IgniteInternalFuture	PlatformCompute.ComputeConvertingFuture.chain(IgniteOutClosure doneCb)	Make a chained future to convert result of this future (when complete) into a new format.
IgniteInternalFuture	PlatformCompute.ComputeConvertingFuture.chain(IgniteOutClosure doneCb, Executor exec)	Make a chained future to convert result of this future (when complete) into a new format.
IgniteInternalFuture	PlatformCompute.ComputeConvertingFuture.chainCompose(IgniteClosure doneCb)	Make a chained future that is completed when doneCb is executed.
IgniteInternalFuture	PlatformCompute.ComputeConvertingFuture.chainCompose(IgniteClosure doneCb, @Nullable Executor exec)	Make a chained future that is completed when doneCb is executed.

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

Modifier and Type	Method	Description
static PlatformListenable	PlatformFutureUtils.getListenable(IgniteInternalFuture fut)	Gets the listenable.
static <T> T	PlatformFutureUtils.getResult(IgniteInternalFuture<T> fut)	Awaits and returns the result of the specified 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, int typ, PlatformFutureUtils.Writer writer, 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

Modifier and Type	Method	Description
IgniteInternalFuture<?>	GridQueryProcessor.dynamicAddQueryEntity(String cacheName, String schemaName, QueryEntity entity, Integer qryParallelism, boolean sqlEscape)	Enable dynamically indexing of existing cache.
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
@Nullable IgniteInternalFuture<?>	GridQueryProcessor.indexRebuildFuture(int cacheId)
IgniteInternalFuture<?>	GridQueryProcessor.rebuildIndexesFromHash(GridCacheContext cctx, boolean force)	Rebuilds indexes for provided caches from corresponding hash indexes.

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

Classes in org.apache.ignite.internal.processors.query.running that implement IgniteInternalFuture

Modifier and Type	Class	Description
class	QueryRunningFuture	Query running future.

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

Classes in org.apache.ignite.internal.processors.query.schema that implement IgniteInternalFuture

Modifier and Type	Class	Description
class	SchemaIndexCacheCompoundFuture	Compound index rebuilding feature.
class	SchemaIndexCacheFuture	Extending GridFutureAdapter to rebuild indices.
class	SchemaOperationClientFuture	Schema operation client future.

Methods in org.apache.ignite.internal.processors.query.schema that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture	SchemaOperationWorker.future()

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

Methods in org.apache.ignite.internal.processors.query.stat that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<Boolean>	IgniteStatisticsConfigurationManager.dropStatisticsAsync(List<StatisticsTarget> targets, boolean validate)	Drop local statistic for specified database objects on the cluster.

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	Description
IgniteInternalFuture<GridRestResponse>	GridRestProtocolHandler.handleAsync(GridRestRequest req)
protected IgniteInternalFuture<GridRestResponse>	GridRestProcessor.handleAsync0(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	Description
IgniteInternalFuture<GridRestResponse>	GridRestCommandHandler.handleAsync(GridRestRequest req)

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

Methods in org.apache.ignite.internal.processors.rest.handlers.auth that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<GridRestResponse>	AuthenticationCommandHandler.handleAsync(GridRestRequest req)

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

Methods in org.apache.ignite.internal.processors.rest.handlers.beforeStart that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<GridRestResponse>	NodeStateBeforeStartCommandHandler.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	Description
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

Modifier and Type	Method	Description
IgniteInternalFuture<GridRestResponse>	GridBaselineCommandHandler.handleAsync(GridRestRequest req)
IgniteInternalFuture<GridRestResponse>	GridChangeClusterStateCommandHandler.handleAsync(GridRestRequest restReq)
IgniteInternalFuture<GridRestResponse>	GridChangeStateCommandHandler.handleAsync(GridRestRequest restRest)
IgniteInternalFuture<GridRestResponse>	GridClusterNameCommandHandler.handleAsync(GridRestRequest restReq)

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

Modifier and Type	Method	Description
IgniteInternalFuture<GridRestResponse>	GridLogCommandHandler.handleAsync(GridRestRequest req)

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

Methods in org.apache.ignite.internal.processors.rest.handlers.memory that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<GridRestResponse>	MemoryMetricsCommandHandler.handleAsync(GridRestRequest req)

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

Methods in org.apache.ignite.internal.processors.rest.handlers.probe that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<GridRestResponse>	GridProbeCommandHandler.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

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

Modifier and Type	Method	Description
IgniteInternalFuture<GridRedisMessage>	GridRedisCommandHandler.handleAsync(GridNioSession ses, GridRedisMessage msg)
IgniteInternalFuture<GridRedisMessage>	GridRedisConnectionCommandHandler.handleAsync(GridNioSession ses, GridRedisMessage msg)
IgniteInternalFuture<GridRedisMessage>	GridRedisRestCommandHandler.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

Modifier and Type	Method	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	Description
IgniteInternalFuture<GridRestResponse>	GridTopologyCommandHandler.handleAsync(GridRestRequest req)

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

Methods in org.apache.ignite.internal.processors.rest.handlers.user that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<GridRestResponse>	UserActionCommandHandler.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	Description
IgniteInternalFuture<GridRestResponse>	GridVersionCommandHandler.handleAsync(GridRestRequest req)

Uses of IgniteInternalFuture in org.apache.ignite.internal.processors.security

Methods in org.apache.ignite.internal.processors.security that return IgniteInternalFuture

Modifier and Type	Method	Description
@Nullable IgniteInternalFuture<?>	IgniteSecurityProcessor.onReconnected(boolean clusterRestarted)	Client reconnected callback.

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	Description
class	GridServiceDeploymentCompoundFuture<T extends Serializable>	Service deployment compound future.
class	GridServiceDeploymentFuture<T extends Serializable>	Service deployment future.

Methods in org.apache.ignite.internal.processors.service that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<?>	IgniteServiceProcessor.cancel(String name)
IgniteInternalFuture<?>	IgniteServiceProcessor.cancelAll()
IgniteInternalFuture<?>	IgniteServiceProcessor.cancelAll(@NotNull Collection<String> servicesNames)
IgniteInternalFuture<?>	IgniteServiceProcessor.deployAll(ClusterGroup prj, Collection<ServiceConfiguration> cfgs)
IgniteInternalFuture<?>	IgniteServiceProcessor.deployClusterSingleton(ClusterGroup prj, String name, Service srvc)
IgniteInternalFuture<?>	IgniteServiceProcessor.deployKeyAffinitySingleton(String name, Service srvc, String cacheName, Object affKey)
IgniteInternalFuture<?>	IgniteServiceProcessor.deployMultiple(ClusterGroup prj, String name, Service srvc, int totalCnt, int maxPerNodeCnt)
IgniteInternalFuture<?>	IgniteServiceProcessor.deployNodeSingleton(ClusterGroup prj, String name, Service srvc)
IgniteInternalFuture<?>	IgniteServiceProcessor.onReconnected(boolean active)	Client reconnected callback.

Methods in org.apache.ignite.internal.processors.service with parameters of type IgniteInternalFuture

Modifier and Type	Method	Description
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.processors.timeout

Methods in org.apache.ignite.internal.processors.timeout with parameters of type IgniteInternalFuture

Modifier and Type	Method	Description
void	GridTimeoutProcessor.waitAsync(IgniteInternalFuture<?> fut, long timeout, IgniteBiInClosure<IgniteCheckedException,Boolean> clo)	Wait for a future (listen with timeout).

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

Methods in org.apache.ignite.internal.util that return types with arguments of type IgniteInternalFuture

Modifier and Type	Method	Description
static <T,R> Collector<? super IgniteInternalFuture,? super GridCompoundFuture<T,R>,GridCompoundFuture<T,R>>	IgniteCollectors.toCompoundFuture()	Collector of IgniteInternalFuture inheritors stream to GridCompoundFuture.

Methods in org.apache.ignite.internal.util with parameters of type IgniteInternalFuture

Modifier and Type	Method	Description
static void	IgniteUtils.asyncLogError(IgniteInternalFuture<?> f, IgniteLogger log)	Adds listener to asynchronously log errors.

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

Constructor parameters in org.apache.ignite.internal.util.distributed with type arguments of type IgniteInternalFuture

Constructor	Description
DistributedProcess(GridKernalContext ctx, DistributedProcess.DistributedProcessType type, Function<I,IgniteInternalFuture<R>> exec, CI3<UUID,Map<UUID,R>,Map<UUID,Throwable>> finish)
DistributedProcess(GridKernalContext ctx, DistributedProcess.DistributedProcessType type, Function<I,IgniteInternalFuture<R>> exec, CI3<UUID,Map<UUID,R>,Map<UUID,Throwable>> finish, BiFunction<UUID,I,? extends InitMessage<I>> initMsgFactory)

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

Modifier and Type	Field	Description
protected IgniteInternalFuture<V>	IgniteFutureImpl.fut

Methods in org.apache.ignite.internal.util.future that return IgniteInternalFuture

Modifier and Type	Method	Description
<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.
<R> IgniteInternalFuture<R>	GridFinishedFuture.chain(IgniteOutClosure<R> doneCb)	Make a chained future to convert result of this future (when complete) into a new format.
<R> IgniteInternalFuture<R>	GridFinishedFuture.chain(IgniteOutClosure<R> doneCb, Executor exec)	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)	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.
<T> IgniteInternalFuture<T>	GridFutureAdapter.chain(IgniteOutClosure<T> doneCb)	Make a chained future to convert result of this future (when complete) into a new format.
<T> IgniteInternalFuture<T>	GridFutureAdapter.chain(IgniteOutClosure<T> doneCb, Executor exec)	Make a chained future to convert result of this future (when complete) into a new format.
<R> IgniteInternalFuture<R>	GridFinishedFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<T>,IgniteInternalFuture<R>> doneCb)	Make a chained future that is completed when doneCb is executed.
<R> IgniteInternalFuture<R>	GridFinishedFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<T>,IgniteInternalFuture<R>> doneCb, @Nullable Executor exec)	Make a chained future that is completed when doneCb is executed.
<T> IgniteInternalFuture<T>	GridFutureAdapter.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb)	Make a chained future that is completed when doneCb is executed.
<T> IgniteInternalFuture<T>	GridFutureAdapter.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb, @Nullable Executor exec)	Make a chained future that is completed when doneCb is executed.
protected <T> IgniteInternalFuture<T>	IgniteFutureImpl.chainInternal(IgniteClosure<? super IgniteFuture<V>,T> doneCb, @Nullable 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

Modifier and Type	Method	Description
Collection<IgniteInternalFuture<T>>	GridCompoundFuture.futures()	Gets collection of futures.

Methods in org.apache.ignite.internal.util.future with parameters of type IgniteInternalFuture

Modifier and Type	Method	Description
GridCompoundFuture<T,R>	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

Modifier and Type	Method	Description
<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.
<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.chainCompose(IgniteClosure<? super IgniteInternalFuture<T>,IgniteInternalFuture<R>> doneCb)	Make a chained future that is completed when doneCb is executed.
<R> IgniteInternalFuture<R>	GridFinishedFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<T>,IgniteInternalFuture<R>> doneCb)	Make a chained future that is completed when doneCb is executed.
<R> IgniteInternalFuture<R>	GridFinishedFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<T>,IgniteInternalFuture<R>> doneCb, @Nullable Executor exec)	Make a chained future that is completed when doneCb is executed.
<R> IgniteInternalFuture<R>	GridFinishedFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<T>,IgniteInternalFuture<R>> doneCb, @Nullable Executor exec)	Make a chained future that is completed when doneCb is executed.
<T> IgniteInternalFuture<T>	GridFutureAdapter.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb)	Make a chained future that is completed when doneCb is executed.
<T> IgniteInternalFuture<T>	GridFutureAdapter.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb)	Make a chained future that is completed when doneCb is executed.
<T> IgniteInternalFuture<T>	GridFutureAdapter.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb, @Nullable Executor exec)	Make a chained future that is completed when doneCb is executed.
<T> IgniteInternalFuture<T>	GridFutureAdapter.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb, @Nullable Executor exec)	Make a chained future that is completed when doneCb is executed.
void	GridFinishedFuture.listen(IgniteInClosure<? super IgniteInternalFuture<T>> lsnr)	Registers listener closure to be asynchronously notified whenever future completes.
void	GridFutureAdapter.listen(IgniteInClosure<? super IgniteInternalFuture<R>> 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	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)
GridEmbeddedFuture(IgniteBiClosure<B,Exception,A> c, IgniteInternalFuture<B> embedded)
IgniteFutureImpl(IgniteInternalFuture<V> fut)
IgniteFutureImpl(IgniteInternalFuture<V> fut, @Nullable Executor defaultExecutor)

Constructor parameters in org.apache.ignite.internal.util.future with type arguments of type IgniteInternalFuture

Constructor	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

Modifier and Type	Method	Description
static <T> void	GridFunc.awaitAll(long timeout, @Nullable Collection<IgniteInternalFuture<T>> futs)	Deprecated.
static <T,R> R	GridFunc.awaitAll(long timeout, @Nullable IgniteReducer<T,R> rdc, @Nullable Collection<IgniteInternalFuture<T>> futs)	Deprecated.
static <T> void	GridFunc.awaitAll(@Nullable 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

Modifier and Type	Interface	Description
interface	GridNioFuture<R>	NIO future.

Classes in org.apache.ignite.internal.util.nio that implement IgniteInternalFuture

Modifier and Type	Class	Description
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

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

Modifier and Type	Method	Description
GridNioFuture<GridNioSession>	GridNioServer.createSession(SocketChannel ch, @Nullable Map<Integer,Object> meta, boolean async, @Nullable IgniteInClosure<? super IgniteInternalFuture<GridNioSession>> lsnr)	Establishes a session.
void	GridNioServer.sendSystem(GridNioSession ses, Message msg, @Nullable 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

Modifier and Type	Class	Description
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

Modifier and Type	Method	Description
IgniteInternalFuture<String>	TcpCommunicationSpi.dumpNodeStatistics(UUID nodeId)
IgniteInternalFuture<Channel>	TcpCommunicationSpi.openChannel(ClusterNode remote, Message initMsg)

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

Classes in org.apache.ignite.spi.communication.tcp.internal that implement IgniteInternalFuture

Modifier and Type	Class	Description
class	ConnectFuture	Connect future which uses as a marker of type connection releted with TCP.
class	ConnectionRequestFuture	Marker future implementation, just like ConnectFuture, but meaning that we're waiting for the inverse connection.
class	TcpCommunicationConnectionCheckFuture	Tcp Communication Connection Check Future.

Methods in org.apache.ignite.spi.communication.tcp.internal that return IgniteInternalFuture

Modifier and Type	Method	Description
IgniteInternalFuture<Channel>	GridNioServerWrapper.openChannel(ClusterNode remote, Message initMsg)	Deprecated.

Uses of IgniteInternalFuture in org.apache.ignite.spi.discovery.tcp.internal

Classes in org.apache.ignite.spi.discovery.tcp.internal that implement IgniteInternalFuture

Modifier and Type	Class	Description
class	FutureTask<T>