| Modifier and Type | Class and Description |
|---|---|
class |
ComputeTaskInternalFuture<R>
This class provide implementation for task future.
|
| Modifier and Type | Method and Description |
|---|---|
<T> IgniteInternalFuture<T> |
IgniteInternalFuture.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T> IgniteInternalFuture<T> |
IgniteInternalFuture.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb,
Executor exec)
Make a chained future to convert result of this future (when complete) into a new format.
|
IgniteInternalFuture<?> |
IgniteKernal.destroyCacheAsync(String cacheName,
boolean checkThreadTx) |
IgniteInternalFuture<?> |
IgniteKernal.destroyCachesAsync(Collection<String> cacheNames,
boolean checkThreadTx) |
IgniteInternalFuture<?> |
IgniteKernal.getOrCreateCacheAsync(String cacheName,
boolean checkThreadTx) |
IgniteInternalFuture<?> |
GridComponent.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
IgniteInternalFuture<?> |
GridPluginComponent.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
IgniteInternalFuture |
IgniteKernal.sendIoTest(ClusterNode node,
byte[] payload,
boolean procFromNioThread) |
IgniteInternalFuture |
IgniteKernal.sendIoTest(List<ClusterNode> nodes,
byte[] payload,
boolean procFromNioThread) |
| Modifier and Type | Method and Description |
|---|---|
protected <R> IgniteFuture<R> |
IgniteComputeImpl.createFuture(IgniteInternalFuture<R> fut) |
protected <R> IgniteFuture<R> |
AsyncSupportAdapter.createFuture(IgniteInternalFuture<R> fut) |
<R> R |
AsyncSupportAdapter.saveOrGet(IgniteInternalFuture<R> fut) |
| Modifier and Type | Method and Description |
|---|---|
<T> IgniteInternalFuture<T> |
IgniteInternalFuture.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T> IgniteInternalFuture<T> |
IgniteInternalFuture.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb,
Executor exec)
Make a chained future to convert result of this future (when complete) into a new format.
|
void |
IgniteInternalFuture.listen(IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)
Registers listener closure to be asynchronously notified whenever future completes.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
ClusterTopologyCheckedException.retryReadyFuture() |
| Modifier and Type | Method and Description |
|---|---|
void |
ClusterTopologyCheckedException.retryReadyFuture(IgniteInternalFuture<?> readyFut) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
GridManagerAdapter.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture |
GridIoManager.sendIoTest(ClusterNode node,
byte[] payload,
boolean procFromNioThread) |
IgniteInternalFuture |
GridIoManager.sendIoTest(List<ClusterNode> nodes,
byte[] payload,
boolean procFromNioThread) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
GridDeploymentManager.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Long> |
GridDiscoveryManager.topologyFuture(long awaitVer)
Gets future that will be completed when current topology version becomes greater or equal to argument passed.
|
| Modifier and Type | Method and Description |
|---|---|
<T extends Event> |
GridEventStorageManager.remoteEventsAsync(IgnitePredicate<T> p,
Collection<? extends ClusterNode> nodes,
long timeout) |
<T extends Event> |
GridEventStorageManager.waitForEvent(IgnitePredicate<T> p,
int... types) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
GridProcessorAdapter.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<AffinityTopologyVersion> |
GridAffinityAssignmentCache.readyFuture(AffinityTopologyVersion topVer)
Gets future that will be completed after topology with version
topVer is calculated. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
GridCacheAtomicFuture<R>
Update future for atomic cache.
|
interface |
GridCacheFuture<R>
This interface should be implemented by all distributed futures.
|
interface |
GridCacheMvccFuture<T>
Distributed future aware of MVCC locking.
|
| Modifier and Type | Class and Description |
|---|---|
class |
GridCacheCompoundFuture<T,R> |
class |
GridCacheCompoundIdentityFuture<T> |
class |
GridCacheFutureAdapter<R> |
class |
GridCacheMultiTxFuture<K,V>
Future which waits for completion of one or more transactions.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
GridCachePartitionExchangeManager.affinityReadyFuture(AffinityTopologyVersion ver) |
IgniteInternalFuture<AffinityTopologyVersion> |
GridCacheAffinityManager.affinityReadyFuture(AffinityTopologyVersion topVer)
Gets affinity ready future, a future that will be completed after affinity with given
topology version is calculated.
|
IgniteInternalFuture<AffinityTopologyVersion> |
GridCacheAffinityManager.affinityReadyFuture(long topVer)
Gets affinity ready future, a future that will be completed after affinity with given
topology version is calculated.
|
IgniteInternalFuture<AffinityTopologyVersion> |
GridCacheAffinityManager.affinityReadyFuturex(AffinityTopologyVersion topVer)
Gets affinity ready future that will be completed after affinity with given topology version is calculated.
|
protected <T> IgniteInternalFuture<T> |
GridCacheAdapter.asyncOp(GridNearTxLocal tx,
GridCacheAdapter.AsyncOp<T> op,
CacheOperationContext opCtx,
boolean retry) |
protected <T> IgniteInternalFuture<T> |
GridCacheAdapter.asyncOpAcquire(boolean retry)
Tries to acquire asynchronous operations permit, if limited.
|
IgniteInternalFuture<?> |
GridCacheMvccManager.atomicFuture(long futId)
Gets future by given future ID.
|
IgniteInternalFuture<?> |
GridCacheProxyImpl.clearAllAsync(Set<? extends K> keys) |
IgniteInternalFuture<?> |
IgniteInternalCache.clearAllAsync(Set<? extends K> keys) |
IgniteInternalFuture<?> |
GridCacheAdapter.clearAllAsync(Set<? extends K> keys) |
IgniteInternalFuture<?> |
GridCacheProxyImpl.clearAsync() |
IgniteInternalFuture<?> |
IgniteInternalCache.clearAsync() |
IgniteInternalFuture<?> |
GridCacheAdapter.clearAsync() |
IgniteInternalFuture<?> |
GridCacheProxyImpl.clearAsync(K key) |
IgniteInternalFuture<?> |
IgniteInternalCache.clearAsync(K key) |
IgniteInternalFuture<?> |
GridCacheAdapter.clearAsync(K key) |
IgniteInternalFuture<IgniteInternalTx> |
GridCacheSharedContext.commitTxAsync(GridNearTxLocal tx) |
IgniteInternalFuture<Void> |
GridCacheAtomicFuture.completeFuture(AffinityTopologyVersion topVer)
Gets future that will be completed when it is safe when update is finished on the given version of topology.
|
IgniteInternalFuture<Boolean> |
GridCacheProxyImpl.containsKeyAsync(K key) |
IgniteInternalFuture<Boolean> |
IgniteInternalCache.containsKeyAsync(K key) |
IgniteInternalFuture<Boolean> |
GridCacheAdapter.containsKeyAsync(K key) |
IgniteInternalFuture<Boolean> |
GridCacheProxyImpl.containsKeysAsync(Collection<? extends K> keys) |
IgniteInternalFuture<Boolean> |
IgniteInternalCache.containsKeysAsync(Collection<? extends K> keys) |
IgniteInternalFuture<Boolean> |
GridCacheAdapter.containsKeysAsync(Collection<? extends K> keys) |
IgniteInternalFuture<?> |
GridCacheProcessor.createFromTemplate(String cacheName)
Dynamically starts cache using template configuration.
|
IgniteInternalFuture<?> |
GridCacheProcessor.dynamicCloseCache(String cacheName) |
IgniteInternalFuture<?> |
GridCacheProcessor.dynamicDestroyCache(String cacheName,
boolean checkThreadTx) |
IgniteInternalFuture<?> |
GridCacheProcessor.dynamicDestroyCaches(Collection<String> cacheNames,
boolean checkThreadTx) |
IgniteInternalFuture<?> |
GridCacheProcessor.dynamicStartCache(CacheConfiguration ccfg,
String cacheName,
NearCacheConfiguration nearCfg,
boolean failIfExists,
boolean failIfNotStarted,
boolean checkThreadTx)
Dynamically starts cache.
|
IgniteInternalFuture<?> |
GridCacheProcessor.dynamicStartCache(CacheConfiguration ccfg,
String cacheName,
NearCacheConfiguration nearCfg,
CacheType cacheType,
boolean failIfExists,
boolean failIfNotStarted,
boolean checkThreadTx)
Dynamically starts cache.
|
IgniteInternalFuture<?> |
GridCacheProcessor.dynamicStartCaches(Collection<CacheConfiguration> ccfgList,
boolean failIfExists,
boolean checkThreadTx)
Dynamically starts multiple caches.
|
IgniteInternalFuture<?> |
GridCacheMvccManager.finishAtomicUpdates(AffinityTopologyVersion topVer) |
IgniteInternalFuture<?> |
GridCacheMvccManager.finishDataStreamerUpdates() |
IgniteInternalFuture<?> |
GridCacheMvccManager.finishExplicitLocks(AffinityTopologyVersion topVer)
Creates a future that will wait for all explicit locks acquired on given topology
version to be released.
|
IgniteInternalFuture<?> |
GridCacheMvccManager.finishKeys(Collection<KeyCacheObject> keys,
int cacheId,
AffinityTopologyVersion topVer) |
IgniteInternalFuture<?> |
GridCacheMvccManager.finishLocks(AffinityTopologyVersion topVer) |
IgniteInternalFuture<Boolean> |
GridCachePreloaderAdapter.forceRebalance()
Force Rebalance process.
|
IgniteInternalFuture<Boolean> |
GridCachePreloader.forceRebalance()
Force Rebalance process.
|
IgniteInternalFuture<Boolean> |
GridCachePartitionExchangeManager.forceRebalance(GridDhtPartitionsExchangeFuture exchFut)
Forces preload exchange.
|
IgniteInternalFuture<GridCacheReturn> |
GridCacheReturnCompletableWrapper.fut()
Allows wait for properly initialized value.
|
IgniteInternalFuture |
GridCacheAdapter.FutureHolder.future()
Gets future.
|
IgniteInternalFuture<Map<K,V>> |
GridCacheProxyImpl.getAllAsync(Collection<? extends K> keys)
Asynchronously retrieves values mapped to the specified keys from cache.
|
IgniteInternalFuture<Map<K,V>> |
IgniteInternalCache.getAllAsync(Collection<? extends K> keys)
Asynchronously retrieves values mapped to the specified keys from cache.
|
IgniteInternalFuture<Map<K,V>> |
GridCacheAdapter.getAllAsync(Collection<? extends K> keys)
Asynchronously retrieves values mapped to the specified keys from cache.
|
IgniteInternalFuture<Map<K,V>> |
GridCacheAdapter.getAllAsync(Collection<? extends K> keys,
boolean deserializeBinary,
boolean recovery,
boolean needVer) |
protected IgniteInternalFuture<Map<K,V>> |
GridCacheAdapter.getAllAsync(Collection<? extends K> keys,
boolean forcePrimary,
boolean skipTx,
UUID subjId,
String taskName,
boolean deserializeBinary,
boolean recovery,
boolean skipVals,
boolean canRemap,
boolean needVer) |
IgniteInternalFuture<Map<K,V>> |
GridCacheAdapter.getAllAsync(Collection<? extends K> keys,
ReaderArguments readerArgs,
boolean readThrough,
boolean checkTx,
UUID subjId,
String taskName,
boolean deserializeBinary,
boolean recovery,
boolean forcePrimary,
IgniteCacheExpiryPolicy expiry,
boolean skipVals,
boolean canRemap,
boolean needVer) |
protected <K1,V1> IgniteInternalFuture<Map<K1,V1>> |
GridCacheAdapter.getAllAsync0(Collection<KeyCacheObject> keys,
ReaderArguments readerArgs,
boolean readThrough,
boolean checkTx,
UUID subjId,
String taskName,
boolean deserializeBinary,
IgniteCacheExpiryPolicy expiry,
boolean skipVals,
boolean keepCacheObjects,
boolean recovery,
boolean canRemap,
boolean needVer) |
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<Map<K,V>> |
GridCacheAdapter.getAllOutTxAsync(Set<? extends K> keys)
Gets values from cache.
|
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.getAndPutAsync(K key,
V val)
Asynchronously stores given key-value pair in cache.
|
protected IgniteInternalFuture<V> |
GridCacheAdapter.getAndPutAsync(K key,
V val,
CacheEntryPredicate filter) |
IgniteInternalFuture<V> |
GridCacheAdapter.getAndPutAsync0(K key,
V val,
CacheEntryPredicate filter) |
IgniteInternalFuture<V> |
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.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.getAndRemoveAsync(K key)
Asynchronously removes given key mapping from cache.
|
IgniteInternalFuture<V> |
IgniteInternalCache.getAndRemoveAsync(K key)
Asynchronously removes given key mapping from cache.
|
IgniteInternalFuture<V> |
GridCacheAdapter.getAndRemoveAsync(K key)
Asynchronously removes given key mapping from cache.
|
protected IgniteInternalFuture<V> |
GridCacheAdapter.getAndRemoveAsync0(K key) |
IgniteInternalFuture<V> |
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.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.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<V> |
GridCacheAdapter.getAsync(K key)
Asynchronously retrieves value mapped to the specified key from cache.
|
IgniteInternalFuture<V> |
GridCacheAdapter.getAsync(K key,
boolean deserializeBinary,
boolean needVer) |
protected IgniteInternalFuture<V> |
GridCacheAdapter.getAsync(K key,
boolean forcePrimary,
boolean skipTx,
UUID subjId,
String taskName,
boolean deserializeBinary,
boolean skipVals,
boolean canRemap,
boolean needVer) |
IgniteInternalFuture<Collection<CacheEntry<K,V>>> |
GridCacheProxyImpl.getEntriesAsync(Collection<? extends K> keys)
Asynchronously retrieves values mapped to the specified keys from cache.
|
IgniteInternalFuture<Collection<CacheEntry<K,V>>> |
IgniteInternalCache.getEntriesAsync(Collection<? extends K> keys)
Asynchronously retrieves values mapped to the specified keys from cache.
|
IgniteInternalFuture<Collection<CacheEntry<K,V>>> |
GridCacheAdapter.getEntriesAsync(Collection<? extends K> keys)
Asynchronously retrieves values mapped to the specified keys from cache.
|
IgniteInternalFuture<CacheEntry<K,V>> |
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<CacheEntry<K,V>> |
GridCacheAdapter.getEntryAsync(K key)
Asynchronously retrieves value mapped to the specified key 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<V> |
GridCacheAdapter.getForcePrimaryAsync(K key)
Asynchronously gets value from cache.
|
IgniteInternalFuture<?> |
GridCacheProcessor.getOrCreateFromTemplate(String cacheName,
boolean checkThreadTx)
Dynamically starts cache using template configuration.
|
IgniteInternalFuture<Map<Integer,Map<Integer,List<UUID>>>> |
CacheAffinitySharedManager.initAffinityOnNodeLeft(GridDhtPartitionsExchangeFuture fut) |
<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>>> |
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>>> |
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>>> |
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(Set<? extends K> keys,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
GridCacheAdapter.invokeAllAsync(Set<? extends K> keys,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>> |
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) |
<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>> |
GridCacheAdapter.invokeAsync(K key,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
IgniteInternalFuture<?> |
GridCacheAdapter.loadAll(Set<? extends K> keys,
boolean replaceExisting) |
IgniteInternalFuture<?> |
IgniteInternalCache.localLoadCacheAsync(IgniteBiPredicate<K,V> p,
Object... args)
Asynchronously delegates to
CacheStore.loadCache(IgniteBiInClosure, Object...) method
to reload state from the underlying persistent storage. |
IgniteInternalFuture<?> |
GridCacheProxyImpl.localLoadCacheAsync(IgniteBiPredicate<K,V> p,
Object[] args)
Asynchronously delegates to
CacheStore.loadCache(IgniteBiInClosure, Object...) method
to reload state from the underlying persistent storage. |
IgniteInternalFuture<?> |
GridCacheAdapter.localLoadCacheAsync(IgniteBiPredicate<K,V> p,
Object[] args)
Asynchronously delegates to
CacheStore.loadCache(IgniteBiInClosure, Object...) method
to reload state from the underlying persistent storage. |
IgniteInternalFuture<Boolean> |
GridCacheProxyImpl.lockAllAsync(Collection<? extends K> keys,
long timeout)
All or nothing synchronous lock for passed in keys.
|
IgniteInternalFuture<Boolean> |
IgniteInternalCache.lockAllAsync(Collection<? extends K> keys,
long timeout)
All or nothing synchronous lock for passed in keys.
|
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<Boolean> |
GridCacheAdapter.lockAsync(K key,
long timeout)
Asynchronously acquires lock on a cached object with given
key only if the passed in filter (if any) passes.
|
IgniteInternalFuture<?> |
GridCacheSharedContext.nextAffinityReadyFuture(AffinityTopologyVersion curVer)
Gets ready future for the next affinity topology version (used in cases when a node leaves grid).
|
IgniteInternalFuture<?> |
GridCacheProcessor.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
abstract IgniteInternalFuture<T> |
GridCacheAdapter.AsyncOp.op(GridNearTxLocal tx,
AffinityTopologyVersion readyTopVer) |
IgniteInternalFuture<T> |
GridCacheAdapter.AsyncOp.op(GridNearTxLocal tx,
CacheOperationContext opCtx) |
IgniteInternalFuture<?> |
GridCacheSharedContext.partitionReleaseFuture(AffinityTopologyVersion topVer)
Waits for partition locks and transactions release.
|
IgniteInternalFuture<?> |
GridCacheProxyImpl.putAllAsync(Map<? extends K,? extends V> m)
Asynchronously stores given key-value pairs in cache.
|
IgniteInternalFuture<?> |
IgniteInternalCache.putAllAsync(Map<? extends K,? extends V> m)
Asynchronously stores given key-value pairs in cache.
|
IgniteInternalFuture<?> |
GridCacheAdapter.putAllAsync(Map<? extends K,? extends V> m)
Asynchronously stores given key-value pairs in cache.
|
protected IgniteInternalFuture<?> |
GridCacheAdapter.putAllAsync0(Map<? extends K,? extends V> m) |
IgniteInternalFuture<?> |
GridCacheProxyImpl.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)
Store DR data asynchronously.
|
IgniteInternalFuture<?> |
IgniteInternalCache.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)
Store DR data asynchronously.
|
IgniteInternalFuture<?> |
GridCacheAdapter.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)
Store DR data asynchronously.
|
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.putAsync(K key,
V val)
Stores given key-value pair in cache.
|
IgniteInternalFuture<Boolean> |
GridCacheAdapter.putAsync(K key,
V val,
CacheEntryPredicate filter) |
IgniteInternalFuture<Boolean> |
GridCacheAdapter.putAsync0(K key,
V val,
CacheEntryPredicate filter) |
IgniteInternalFuture<Boolean> |
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<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<?> |
GridCacheProxyImpl.rebalance()
Forces this cache node to re-balance its partitions.
|
IgniteInternalFuture<?> |
IgniteInternalCache.rebalance()
Forces this cache node to re-balance its partitions.
|
IgniteInternalFuture<?> |
GridCacheAdapter.rebalance()
Forces this cache node to re-balance its partitions.
|
IgniteInternalFuture<Boolean> |
GridCachePreloaderAdapter.rebalanceFuture() |
IgniteInternalFuture<Boolean> |
GridCachePreloader.rebalanceFuture() |
IgniteInternalFuture<?> |
GridCachePartitionExchangeManager.reconnectExchangeFuture() |
IgniteInternalFuture<Object> |
GridCacheExplicitLockSpan.releaseFuture()
Gets span release future.
|
IgniteInternalFuture<?> |
GridCacheProxyImpl.removeAllAsync() |
IgniteInternalFuture<?> |
IgniteInternalCache.removeAllAsync() |
IgniteInternalFuture<?> |
GridCacheProxyImpl.removeAllAsync(Collection<? extends K> keys)
Asynchronously removes given key mappings from cache for entries.
|
IgniteInternalFuture<?> |
IgniteInternalCache.removeAllAsync(Collection<? extends K> keys)
Asynchronously removes given key mappings from cache for entries.
|
IgniteInternalFuture<?> |
GridCacheAdapter.removeAllAsync(Collection<? extends K> keys)
Asynchronously removes given key mappings from cache for entries.
|
protected IgniteInternalFuture<Object> |
GridCacheAdapter.removeAllAsync0(Collection<? extends K> keys) |
IgniteInternalFuture<?> |
GridCacheProxyImpl.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)
Removes DR data asynchronously.
|
IgniteInternalFuture<?> |
IgniteInternalCache.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)
Removes DR data asynchronously.
|
IgniteInternalFuture<?> |
GridCacheAdapter.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)
Removes DR data asynchronously.
|
IgniteInternalFuture<Boolean> |
GridCacheProxyImpl.removeAsync(K key)
Asynchronously removes given key mapping from cache.
|
IgniteInternalFuture<Boolean> |
IgniteInternalCache.removeAsync(K key)
Asynchronously removes given key mapping from cache.
|
IgniteInternalFuture<Boolean> |
GridCacheAdapter.removeAsync(K key)
Asynchronously removes given key mapping from cache.
|
IgniteInternalFuture<Boolean> |
GridCacheAdapter.removeAsync(K key,
CacheEntryPredicate filter) |
IgniteInternalFuture<Boolean> |
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,
V val)
Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
|
IgniteInternalFuture<Boolean> |
GridCacheAdapter.removeAsync(K key,
V val)
Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
|
protected IgniteInternalFuture<Boolean> |
GridCacheAdapter.removeAsync0(K key,
CacheEntryPredicate filter) |
IgniteInternalFuture<?> |
GridCacheMvccManager.removeAtomicFuture(long futId) |
IgniteInternalFuture<Boolean> |
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> |
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> |
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> |
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 oldVal,
V newVal)
Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the
'oldVal' passed in. |
IgniteInternalFuture<Boolean> |
GridCacheAdapter.replaceAsync(K key,
V oldVal,
V newVal)
Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the
'oldVal' passed in. |
IgniteInternalFuture<Object> |
GridCachePreloaderAdapter.request(Collection<KeyCacheObject> keys,
AffinityTopologyVersion topVer)
Requests that preloader sends the request for the key.
|
IgniteInternalFuture<Object> |
GridCachePreloader.request(Collection<KeyCacheObject> keys,
AffinityTopologyVersion topVer)
Requests that preloader sends the request for the key.
|
IgniteInternalFuture<Object> |
GridCachePreloaderAdapter.request(GridNearAtomicAbstractUpdateRequest req,
AffinityTopologyVersion topVer)
Requests that preloader sends the request for the key.
|
IgniteInternalFuture<Object> |
GridCachePreloader.request(GridNearAtomicAbstractUpdateRequest req,
AffinityTopologyVersion topVer)
Requests that preloader sends the request for the key.
|
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> |
GridCacheProxyImpl.sizeAsync(CachePeekMode[] peekModes) |
IgniteInternalFuture<Integer> |
IgniteInternalCache.sizeAsync(CachePeekMode[] peekModes) |
IgniteInternalFuture<Integer> |
GridCacheAdapter.sizeAsync(CachePeekMode[] peekModes) |
IgniteInternalFuture<Long> |
GridCacheProxyImpl.sizeLongAsync(CachePeekMode[] peekModes) |
IgniteInternalFuture<Long> |
IgniteInternalCache.sizeLongAsync(CachePeekMode[] peekModes) |
IgniteInternalFuture<Long> |
GridCacheAdapter.sizeLongAsync(CachePeekMode[] peekModes) |
IgniteInternalFuture<Long> |
GridCacheProxyImpl.sizeLongAsync(int partition,
CachePeekMode[] peekModes) |
IgniteInternalFuture<Long> |
IgniteInternalCache.sizeLongAsync(int partition,
CachePeekMode[] peekModes) |
IgniteInternalFuture<Long> |
GridCacheAdapter.sizeLongAsync(int part,
CachePeekMode[] peekModes) |
IgniteInternalFuture<Object> |
GridCachePreloaderAdapter.startFuture() |
IgniteInternalFuture<Object> |
GridCachePreloader.startFuture() |
IgniteInternalFuture<?> |
GridCachePreloaderAdapter.syncFuture() |
IgniteInternalFuture<?> |
GridCachePreloader.syncFuture() |
abstract IgniteInternalFuture<Boolean> |
GridCacheAdapter.txLockAsync(Collection<KeyCacheObject> keys,
long timeout,
IgniteTxLocalEx tx,
boolean isRead,
boolean retval,
TransactionIsolation isolation,
boolean invalidate,
long createTtl,
long accessTtl) |
| Modifier and Type | Method and Description |
|---|---|
static IgniteInClosure<IgniteInternalFuture<?>> |
GridCacheUtils.errorLogger(IgniteLogger log,
Class<? extends Exception>... excl) |
| Modifier and Type | Method and Description |
|---|---|
void |
GridCacheAdapter.UpdateTimeStatClosure.apply(IgniteInternalFuture<T> fut)
Closure body.
|
protected <R> IgniteFuture<R> |
IgniteCacheProxy.createFuture(IgniteInternalFuture<R> fut) |
void |
GridCacheAdapter.FutureHolder.future(IgniteInternalFuture fut)
Sets future.
|
protected void |
GridCacheAdapter.saveFuture(GridCacheAdapter.FutureHolder holder,
IgniteInternalFuture<?> fut,
boolean retry)
Saves future in thread local holder and adds listener
that will clear holder when future is finished.
|
| Constructor and Description |
|---|
IgniteCacheFutureImpl(IgniteInternalFuture<V> fut)
Constructor.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture |
IgniteCacheDatabaseSharedManager.indexRebuildFuture(int cacheId) |
IgniteInternalFuture |
IgniteCacheDatabaseSharedManager.startLocalSnapshotCreation(StartFullSnapshotAckDiscoveryMessage snapshotMsg,
ClusterNode initiator,
String msg) |
IgniteInternalFuture |
IgniteCacheDatabaseSharedManager.wakeupForCheckpoint(String reason) |
IgniteInternalFuture |
IgniteCacheDatabaseSharedManager.wakeupForSnapshot(long snapshotId,
UUID snapshotNodeId,
Collection<String> cacheNames) |
| Modifier and Type | Class and Description |
|---|---|
class |
GridCacheTxRecoveryFuture
Future verifying that all remote transactions related to transaction were prepared or committed.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
GridCacheTxFinishSync.awaitAckAsync(UUID nodeId,
long threadId) |
IgniteInternalFuture<IgniteInternalTx> |
GridDistributedTxRemoteAdapter.commitAsync()
Asynchronously commits this transaction by initiating
two-phase-commit process. |
IgniteInternalFuture<Boolean> |
GridDistributedCacheAdapter.lockAllAsync(Collection<? extends K> keys,
long timeout)
All or nothing synchronous lock for passed in keys.
|
protected abstract IgniteInternalFuture<Boolean> |
GridDistributedCacheAdapter.lockAllAsync(Collection<KeyCacheObject> keys,
long timeout,
IgniteTxLocalEx tx,
boolean isInvalidate,
boolean isRead,
boolean retval,
TransactionIsolation isolation,
long createTtl,
long accessTtl) |
IgniteInternalFuture<?> |
GridDistributedCacheAdapter.removeAllAsync() |
IgniteInternalFuture<IgniteInternalTx> |
GridDistributedTxRemoteAdapter.rollbackAsync()
Asynchronously rollback this transaction.
|
IgniteInternalFuture<?> |
GridDistributedTxRemoteAdapter.salvageTx() |
IgniteInternalFuture<Boolean> |
GridDistributedCacheAdapter.txLockAsync(Collection<KeyCacheObject> keys,
long timeout,
IgniteTxLocalEx tx,
boolean isRead,
boolean retval,
TransactionIsolation isolation,
boolean isInvalidate,
long createTtl,
long accessTtl) |
| Modifier and Type | Interface and Description |
|---|---|
interface |
GridDhtFuture<T>
Keys to retry.
|
interface |
GridDhtTopologyFuture
Future that implements a barrier after which dht topology is safe to use.
|
| Modifier and Type | Class and Description |
|---|---|
class |
CacheDistributedGetFutureAdapter<K,V> |
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 |
GridDhtTxFinishFuture<K,V> |
class |
GridDhtTxPrepareFuture |
class |
GridPartitionedGetFuture<K,V>
Colocated get future.
|
class |
GridPartitionedSingleGetFuture |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Boolean> |
GridDhtTxLocalAdapter.addEntry(long msgId,
IgniteTxEntry e) |
protected abstract IgniteInternalFuture<Boolean> |
GridDhtTxLocalAdapter.addReader(long msgId,
GridDhtCacheEntry cached,
IgniteTxEntry entry,
AffinityTopologyVersion topVer)
Adds reader to cached entry.
|
protected IgniteInternalFuture<Boolean> |
GridDhtTxLocal.addReader(long msgId,
GridDhtCacheEntry cached,
IgniteTxEntry entry,
AffinityTopologyVersion topVer)
Adds reader to cached entry.
|
IgniteInternalFuture<Boolean> |
GridDhtCacheEntry.addReader(UUID nodeId,
long msgId,
AffinityTopologyVersion topVer) |
protected IgniteInternalFuture<GridNearTxPrepareResponse> |
GridDhtTxLocalAdapter.chainOnePhasePrepare(GridDhtTxPrepareFuture prepFut) |
IgniteInternalFuture<IgniteInternalTx> |
GridDhtTxLocal.commitAsync()
Asynchronously commits this transaction by initiating
two-phase-commit process. |
IgniteInternalFuture<IgniteInternalTx> |
GridDhtTxLocal.commitDhtLocalAsync() |
IgniteInternalFuture<?> |
GridDhtTxLocal.currentPrepareFuture() |
IgniteInternalFuture<Map<K,V>> |
GridDhtCacheAdapter.getAllAsync(Collection<? extends K> keys,
boolean forcePrimary,
boolean skipTx,
UUID subjId,
String taskName,
boolean deserializeBinary,
boolean recovery,
boolean skipVals,
boolean canRemap,
boolean needVer)
This method is used internally.
|
IgniteInternalFuture<Boolean> |
GridDhtTransactionalCacheAdapter.lockAllAsync(Collection<KeyCacheObject> keys,
long timeout,
IgniteTxLocalEx txx,
boolean isInvalidate,
boolean isRead,
boolean retval,
TransactionIsolation isolation,
long createTtl,
long accessTtl) |
IgniteInternalFuture<GridNearLockResponse> |
GridDhtTransactionalCacheAdapter.lockAllAsync(GridCacheContext<?,?> cacheCtx,
ClusterNode nearNode,
GridNearLockRequest req,
CacheEntryPredicate[] filter0) |
IgniteInternalFuture<?> |
GridDhtCacheAdapter.multiUpdateFinishFuture(AffinityTopologyVersion topVer)
Creates multi update finish future.
|
IgniteInternalFuture<GridNearTxPrepareResponse> |
GridDhtTxLocal.prepareAsync(Collection<IgniteTxEntry> reads,
Collection<IgniteTxEntry> writes,
Map<IgniteTxKey,GridCacheVersion> verMap,
long msgId,
int nearMiniId,
Map<UUID,Collection<UUID>> txNodes,
boolean last)
Prepares next batch of entries in dht transaction.
|
IgniteInternalFuture<IgniteInternalTx> |
GridDhtTxLocal.rollbackAsync()
Asynchronously rollback this transaction.
|
IgniteInternalFuture<IgniteInternalTx> |
GridDhtTxLocal.rollbackDhtLocalAsync() |
IgniteInternalFuture<?> |
GridDhtTxLocal.salvageTx() |
| Constructor and Description |
|---|
GridDhtEmbeddedFuture(IgniteBiClosure<B,Exception,A> c,
IgniteInternalFuture<B> embedded) |
GridDhtEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c) |
| Constructor and Description |
|---|
GridDhtEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c) |
| Modifier and Type | Class and 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.
|
| Modifier and Type | Method and Description |
|---|---|
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<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<Map<K,V>> |
GridDhtAtomicCache.getAllAsync(Collection<? extends K> keys,
boolean forcePrimary,
boolean skipTx,
UUID subjId,
String taskName,
boolean deserializeBinary,
boolean recovery,
boolean skipVals,
boolean canRemap,
boolean needVer)
This method is used internally.
|
IgniteInternalFuture<V> |
GridDhtAtomicCache.getAndPutAsync0(K key,
V val,
CacheEntryPredicate filter) |
IgniteInternalFuture<V> |
GridDhtAtomicCache.getAndRemoveAsync0(K key) |
protected IgniteInternalFuture<V> |
GridDhtAtomicCache.getAsync(K key,
boolean forcePrimary,
boolean skipTx,
UUID subjId,
String taskName,
boolean deserializeBinary,
boolean skipVals,
boolean canRemap,
boolean needVer) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
GridDhtAtomicCache.invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
Object... args) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
GridDhtAtomicCache.invokeAllAsync(Set<? extends K> keys,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>> |
GridDhtAtomicCache.invokeAsync(K key,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
protected IgniteInternalFuture<Boolean> |
GridDhtAtomicCache.lockAllAsync(Collection<KeyCacheObject> keys,
long timeout,
IgniteTxLocalEx tx,
boolean isInvalidate,
boolean isRead,
boolean retval,
TransactionIsolation isolation,
long createTtl,
long accessTtl) |
IgniteInternalFuture<?> |
GridDhtAtomicCache.putAllAsync0(Map<? extends K,? extends V> m) |
IgniteInternalFuture<?> |
GridDhtAtomicCache.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> conflictMap)
Store DR data asynchronously.
|
IgniteInternalFuture<Boolean> |
GridDhtAtomicCache.putAsync0(K key,
V val,
CacheEntryPredicate filter) |
IgniteInternalFuture<Object> |
GridDhtAtomicCache.removeAllAsync0(Collection<? extends K> keys) |
IgniteInternalFuture<?> |
GridDhtAtomicCache.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> conflictMap)
Removes DR data asynchronously.
|
IgniteInternalFuture<Boolean> |
GridDhtAtomicCache.removeAsync0(K key,
CacheEntryPredicate filter) |
| Modifier and Type | Class and Description |
|---|---|
class |
GridDhtColocatedLockFuture
Colocated cache lock future.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Map<K,V>> |
GridDhtColocatedCache.getAllAsync(Collection<? extends K> keys,
boolean forcePrimary,
boolean skipTx,
UUID subjId,
String taskName,
boolean deserializeBinary,
boolean recovery,
boolean skipVals,
boolean canRemap,
boolean needVer)
This method is used internally.
|
protected IgniteInternalFuture<V> |
GridDhtColocatedCache.getAsync(K key,
boolean forcePrimary,
boolean skipTx,
UUID subjId,
String taskName,
boolean deserializeBinary,
boolean skipVals,
boolean canRemap,
boolean needVer) |
IgniteInternalFuture<Map<K,V>> |
GridDhtColocatedCache.loadAsync(Collection<KeyCacheObject> keys,
boolean readThrough,
boolean forcePrimary,
AffinityTopologyVersion topVer,
UUID subjId,
String taskName,
boolean deserializeBinary,
boolean recovery,
IgniteCacheExpiryPolicy expiryPlc,
boolean skipVals,
boolean canRemap,
boolean needVer) |
IgniteInternalFuture<Map<K,V>> |
GridDhtColocatedCache.loadAsync(Collection<KeyCacheObject> keys,
boolean readThrough,
boolean forcePrimary,
AffinityTopologyVersion topVer,
UUID subjId,
String taskName,
boolean deserializeBinary,
boolean recovery,
IgniteCacheExpiryPolicy expiryPlc,
boolean skipVals,
boolean canRemap,
boolean needVer,
boolean keepCacheObj) |
IgniteInternalFuture<Object> |
GridDhtColocatedCache.loadAsync(KeyCacheObject key,
boolean readThrough,
boolean forcePrimary,
AffinityTopologyVersion topVer,
UUID subjId,
String taskName,
boolean deserializeBinary,
IgniteCacheExpiryPolicy expiryPlc,
boolean skipVals,
boolean canRemap,
boolean needVer,
boolean keepCacheObj,
boolean recovery) |
IgniteInternalFuture<Boolean> |
GridDhtColocatedCache.lockAllAsync(Collection<KeyCacheObject> keys,
long timeout,
IgniteTxLocalEx tx,
boolean isInvalidate,
boolean isRead,
boolean retval,
TransactionIsolation isolation,
long createTtl,
long accessTtl)
This is an entry point to pessimistic locking within transaction.
|
| Modifier and Type | Class and Description |
|---|---|
class |
GridDhtForceKeysFuture<K,V>
Force keys request future.
|
static class |
GridDhtPartitionDemander.RebalanceFuture |
class |
GridDhtPartitionsExchangeFuture
Future for exchanging partition maps.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Boolean> |
GridDhtPreloader.forceRebalance()
Force Rebalance process.
|
IgniteInternalFuture<Boolean> |
GridDhtPreloader.rebalanceFuture() |
IgniteInternalFuture<Object> |
GridDhtPreloader.request(GridNearAtomicAbstractUpdateRequest req,
AffinityTopologyVersion topVer)
Requests that preloader sends the request for the key.
|
IgniteInternalFuture<Object> |
GridDhtPreloader.startFuture() |
IgniteInternalFuture<?> |
GridDhtPreloader.syncFuture() |
| Modifier and Type | Class and 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 |
GridNearTxFinishFuture<K,V> |
class |
GridNearTxPrepareFutureAdapter
Common code for tx prepare in optimistic and pessimistic modes.
|
| Modifier and Type | Method and 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() |
IgniteInternalFuture<?> |
GridNearTxLocal.currentPrepareFuture() |
protected IgniteInternalFuture<Map<K,V>> |
GridNearAtomicCache.getAllAsync(Collection<? extends K> keys,
boolean forcePrimary,
boolean skipTx,
UUID subjId,
String taskName,
boolean deserializeBinary,
boolean recovery,
boolean skipVals,
boolean canRemap,
boolean needVer) |
IgniteInternalFuture<Map<K,V>> |
GridNearTransactionalCache.getAllAsync(Collection<? extends K> keys,
boolean forcePrimary,
boolean skipTx,
UUID subjId,
String taskName,
boolean deserializeBinary,
boolean recovery,
boolean skipVals,
boolean canRemap,
boolean needVer) |
<K,V> IgniteInternalFuture<Map<K,V>> |
GridNearTxLocal.getAllAsync(GridCacheContext cacheCtx,
AffinityTopologyVersion entryTopVer,
Collection<KeyCacheObject> keys,
boolean deserializeBinary,
boolean skipVals,
boolean keepCacheObjects,
boolean skipStore,
boolean recovery,
boolean needVer) |
IgniteInternalFuture<V> |
GridNearAtomicCache.getAndPutAsync0(K key,
V val,
CacheEntryPredicate filter) |
IgniteInternalFuture<V> |
GridNearAtomicCache.getAndRemoveAsync(K key)
Asynchronously removes given key mapping from cache.
|
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
GridNearAtomicCache.invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
Object... args) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
GridNearAtomicCache.invokeAllAsync(Set<? extends K> keys,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<K,V> IgniteInternalFuture<GridCacheReturn> |
GridNearTxLocal.invokeAsync(GridCacheContext cacheCtx,
AffinityTopologyVersion entryTopVer,
K key,
javax.cache.processor.EntryProcessor<K,V,Object> entryProcessor,
Object... invokeArgs) |
<K,V,T> IgniteInternalFuture<GridCacheReturn> |
GridNearTxLocal.invokeAsync(GridCacheContext cacheCtx,
AffinityTopologyVersion entryTopVer,
Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,Object>> map,
Object... invokeArgs) |
<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>> |
GridNearAtomicCache.invokeAsync(K key,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
IgniteInternalFuture<Map<K,V>> |
GridNearCacheAdapter.loadAsync(IgniteInternalTx tx,
Collection<KeyCacheObject> keys,
boolean forcePrimary,
UUID subjId,
String taskName,
boolean deserializeBinary,
boolean recovery,
javax.cache.expiry.ExpiryPolicy expiryPlc,
boolean skipVal,
boolean skipStore,
boolean canRemap,
boolean needVer) |
IgniteInternalFuture<Void> |
GridNearTxLocal.loadMissing(GridCacheContext cacheCtx,
AffinityTopologyVersion topVer,
boolean readThrough,
boolean async,
Collection<KeyCacheObject> keys,
boolean skipVals,
boolean needVer,
boolean keepBinary,
boolean recovery,
javax.cache.expiry.ExpiryPolicy expiryPlc,
GridInClosure3<KeyCacheObject,Object,GridCacheVersion> c) |
IgniteInternalFuture<?> |
GridNearCacheAdapter.localLoadCacheAsync(IgniteBiPredicate<K,V> p,
Object[] args)
Asynchronously delegates to
CacheStore.loadCache(IgniteBiInClosure, Object...) method
to reload state from the underlying persistent storage. |
protected IgniteInternalFuture<Boolean> |
GridNearAtomicCache.lockAllAsync(Collection<KeyCacheObject> keys,
long timeout,
IgniteTxLocalEx tx,
boolean isInvalidate,
boolean isRead,
boolean retval,
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(Collection<IgniteTxEntry> reads,
Collection<IgniteTxEntry> writes,
Map<UUID,Collection<UUID>> txNodes,
boolean last)
Prepares next batch of entries in dht transaction.
|
IgniteInternalFuture<?> |
GridNearTxLocal.prepareNearTxLocal() |
<K,V> IgniteInternalFuture<GridCacheReturn> |
GridNearTxLocal.putAllAsync(GridCacheContext cacheCtx,
AffinityTopologyVersion entryTopVer,
Map<? extends K,? extends V> map,
boolean retval) |
IgniteInternalFuture<?> |
GridNearAtomicCache.putAllAsync(Map<? extends K,? extends V> m)
Asynchronously stores given key-value pairs in cache.
|
IgniteInternalFuture<?> |
GridNearAtomicCache.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)
Store DR data asynchronously.
|
IgniteInternalFuture<?> |
GridNearTxLocal.putAllDrAsync(GridCacheContext cacheCtx,
Map<KeyCacheObject,GridCacheDrInfo> drMap) |
<K,V> IgniteInternalFuture<GridCacheReturn> |
GridNearTxLocal.putAsync(GridCacheContext cacheCtx,
AffinityTopologyVersion entryTopVer,
K key,
V val,
boolean retval,
CacheEntryPredicate filter) |
IgniteInternalFuture<Boolean> |
GridNearAtomicCache.putAsync0(K key,
V val,
CacheEntryPredicate filter) |
IgniteInternalFuture<?> |
GridNearAtomicCache.removeAllAsync() |
IgniteInternalFuture<?> |
GridNearAtomicCache.removeAllAsync(Collection<? extends K> keys)
Asynchronously removes given key mappings from cache for entries.
|
<K,V> IgniteInternalFuture<GridCacheReturn> |
GridNearTxLocal.removeAllAsync(GridCacheContext cacheCtx,
AffinityTopologyVersion entryTopVer,
Collection<? extends K> keys,
boolean retval,
CacheEntryPredicate filter,
boolean singleRmv) |
IgniteInternalFuture<?> |
GridNearAtomicCache.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)
Removes DR data asynchronously.
|
IgniteInternalFuture<?> |
GridNearTxLocal.removeAllDrAsync(GridCacheContext cacheCtx,
Map<KeyCacheObject,GridCacheVersion> drMap) |
IgniteInternalFuture<Boolean> |
GridNearAtomicCache.removeAsync(K key,
CacheEntryPredicate filter) |
IgniteInternalFuture<IgniteInternalTx> |
GridNearTxLocal.rollbackAsync()
Asynchronously rollback this transaction.
|
IgniteInternalFuture<IgniteInternalTx> |
GridNearTxLocal.rollbackAsyncLocal()
Rolls back local part of colocated transaction.
|
IgniteInternalFuture<IgniteInternalTx> |
GridNearTxLocal.rollbackNearTxLocalAsync() |
IgniteInternalFuture<?> |
GridNearTxLocal.salvageTx() |
| Modifier and Type | Class and Description |
|---|---|
class |
GridLocalLockFuture<K,V>
Cache lock future.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Boolean> |
GridLocalCache.lockAllAsync(Collection<? extends K> keys,
long timeout)
All or nothing synchronous lock for passed in keys.
|
IgniteInternalFuture<Boolean> |
GridLocalCache.lockAllAsync(Collection<KeyCacheObject> keys,
long timeout,
IgniteTxLocalEx tx,
CacheEntryPredicate[] filter) |
IgniteInternalFuture<?> |
GridLocalCache.removeAllAsync() |
IgniteInternalFuture<Boolean> |
GridLocalCache.txLockAsync(Collection<KeyCacheObject> keys,
long timeout,
IgniteTxLocalEx tx,
boolean isRead,
boolean retval,
TransactionIsolation isolation,
boolean invalidate,
long createTtl,
long accessTtl) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Map<K,V>> |
GridLocalAtomicCache.getAllAsync(Collection<? extends K> keys,
boolean forcePrimary,
boolean skipTx,
UUID subjId,
String taskName,
boolean deserializeBinary,
boolean recovery,
boolean skipVals,
boolean canRemap,
boolean needVer) |
IgniteInternalFuture<V> |
GridLocalAtomicCache.getAndPutAsync0(K key,
V val,
CacheEntryPredicate filter) |
IgniteInternalFuture<V> |
GridLocalAtomicCache.getAndRemoveAsync0(K key) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
GridLocalAtomicCache.invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
Object... args) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
GridLocalAtomicCache.invokeAllAsync(Set<? extends K> keys,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>> |
GridLocalAtomicCache.invokeAsync(K key,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
IgniteInternalFuture<Boolean> |
GridLocalAtomicCache.lockAllAsync(Collection<? extends K> keys,
long timeout)
All or nothing synchronous lock for passed in keys.
|
IgniteInternalFuture<?> |
GridLocalAtomicCache.putAllAsync0(Map<? extends K,? extends V> m) |
IgniteInternalFuture<Boolean> |
GridLocalAtomicCache.putAsync0(K key,
V val,
CacheEntryPredicate filter) |
IgniteInternalFuture<?> |
GridLocalAtomicCache.removeAllAsync() |
IgniteInternalFuture<Object> |
GridLocalAtomicCache.removeAllAsync0(Collection<? extends K> keys) |
IgniteInternalFuture<Boolean> |
GridLocalAtomicCache.removeAsync0(K key,
CacheEntryPredicate filter) |
IgniteInternalFuture<Boolean> |
GridLocalAtomicCache.txLockAsync(Collection<KeyCacheObject> keys,
long timeout,
IgniteTxLocalEx tx,
boolean isRead,
boolean retval,
TransactionIsolation isolation,
boolean invalidate,
long createTtl,
long accessTtl) |
| Modifier and Type | Interface and Description |
|---|---|
interface |
CacheQueryFuture<T>
Cache query future returned by query execution.
|
| Modifier and Type | Class and 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.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<List<GridQueryFieldMetadata>> |
GridCacheDistributedFieldsQueryFuture.metadata() |
IgniteInternalFuture<List<GridQueryFieldMetadata>> |
GridCacheLocalFieldsQueryFuture.metadata() |
IgniteInternalFuture<List<GridQueryFieldMetadata>> |
GridCacheQueryMetadataAware.metadata() |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<T> |
IgniteTxLocalAdapter.PostLockClosure1.apply(Boolean locked,
Exception e)
Closure body.
|
IgniteInternalFuture<T> |
IgniteTxLocalAdapter.PostLockClosure2.apply(Boolean locked,
Exception e)
Closure body.
|
IgniteInternalFuture<T> |
IgniteTxLocalAdapter.PostMissClosure.apply(T t,
Exception e)
Closure body.
|
IgniteInternalFuture<?> |
IgniteTxManager.awaitFinishAckAsync(UUID rmtNodeId,
long threadId)
Asynchronously waits for last finish request ack.
|
IgniteInternalFuture<IgniteInternalTx> |
IgniteInternalTx.commitAsync()
Asynchronously commits this transaction by initiating
two-phase-commit process. |
IgniteInternalFuture<?> |
IgniteTxAdapter.currentPrepareFuture() |
IgniteInternalFuture<?> |
IgniteInternalTx.currentPrepareFuture() |
IgniteInternalFuture<TxDeadlock> |
IgniteTxManager.detectDeadlock(IgniteInternalTx tx,
Set<IgniteTxKey> keys)
Performs deadlock detection for given keys.
|
IgniteInternalFuture<IgniteInternalTx> |
IgniteTxHandler.finish(UUID nodeId,
GridNearTxLocal locTx,
GridNearTxFinishRequest req) |
IgniteInternalFuture<IgniteInternalTx> |
IgniteTxHandler.finishColocatedLocal(boolean commit,
GridNearTxLocal tx) |
IgniteInternalFuture<IgniteInternalTx> |
IgniteTxAdapter.finishFuture() |
IgniteInternalFuture<IgniteInternalTx> |
IgniteInternalTx.finishFuture() |
IgniteInternalFuture<Boolean> |
IgniteTxManager.finishTxs(AffinityTopologyVersion topVer)
Creates a future that will wait for all ongoing transactions that maybe affected by topology update
to be finished.
|
protected abstract IgniteInternalFuture<T> |
IgniteTxLocalAdapter.PostLockClosure2.postLock()
Post lock callback.
|
protected abstract IgniteInternalFuture<T> |
IgniteTxLocalAdapter.PostMissClosure.postMiss(T t)
Post lock callback.
|
IgniteInternalFuture<GridNearTxPrepareResponse> |
IgniteTxHandler.prepareColocatedTx(GridNearTxLocal locTx,
GridNearTxPrepareRequest req)
Prepares local colocated tx.
|
IgniteInternalFuture<GridNearTxPrepareResponse> |
IgniteTxHandler.prepareNearTx(UUID nearNodeId,
GridNearTxPrepareRequest req,
boolean locReq) |
IgniteInternalFuture<?> |
IgniteTxManager.remoteTxFinishFuture(GridCacheVersion nearVer) |
IgniteInternalFuture<IgniteInternalTx> |
IgniteInternalTx.rollbackAsync()
Asynchronously rollback this transaction.
|
IgniteInternalFuture<?> |
IgniteInternalTx.salvageTx() |
IgniteInternalFuture<Boolean> |
IgniteTxManager.txCommitted(GridCacheVersion xidVer) |
IgniteInternalFuture<Boolean> |
IgniteTxManager.txsPreparedOrCommitted(GridCacheVersion nearVer,
int txNum)
Checks if transactions with given near version ID was prepared or committed.
|
| Modifier and Type | Method and Description |
|---|---|
Collection<IgniteInternalFuture<?>> |
IgniteTxManager.deadlockDetectionFutures() |
| Modifier and Type | Method and Description |
|---|---|
<T,R> IgniteInternalFuture<Collection<R>> |
GridClosureProcessor.broadcast(IgniteClosure<T,R> job,
T arg,
Collection<ClusterNode> nodes,
String execName) |
<R> IgniteInternalFuture<R> |
GridClosureProcessor.callAsyncNoFailover(GridClosureCallMode mode,
Callable<R> job,
Collection<ClusterNode> nodes,
boolean sys,
long timeout) |
<R> IgniteInternalFuture<Collection<R>> |
GridClosureProcessor.callAsyncNoFailover(GridClosureCallMode mode,
Collection<? extends Callable<R>> jobs,
Collection<ClusterNode> nodes,
boolean sys,
long timeout) |
<R> IgniteInternalFuture<R> |
GridClosureProcessor.callLocal(Callable<R> c,
byte plc) |
<R> IgniteInternalFuture<R> |
GridClosureProcessor.callLocalSafe(Callable<R> c)
Executes closure on system pool.
|
<R> IgniteInternalFuture<R> |
GridClosureProcessor.callLocalSafe(Callable<R> c,
boolean sys)
Executes closure on system pool.
|
<R> IgniteInternalFuture<R> |
GridClosureProcessor.callLocalSafe(Callable<R> c,
byte plc)
Companion to
GridClosureProcessor.callLocal(Callable, boolean) but in case of rejected execution re-runs
the closure in the current thread (blocking). |
IgniteInternalFuture<?> |
GridClosureProcessor.runLocal(Runnable c,
byte plc) |
IgniteInternalFuture<?> |
GridClosureProcessor.runLocalSafe(Runnable c)
Executes closure on system pool.
|
IgniteInternalFuture<?> |
GridClosureProcessor.runLocalSafe(Runnable c,
boolean sys)
Companion to
GridClosureProcessor.runLocal(Runnable, boolean) but in case of rejected execution re-runs
the closure in the current thread (blocking). |
IgniteInternalFuture<?> |
GridClosureProcessor.runLocalSafe(Runnable c,
byte plc)
Companion to
GridClosureProcessor.runLocal(Runnable, boolean) but in case of rejected execution re-runs
the closure in the current thread (blocking). |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
GridClusterStateProcessor.changeGlobalState(boolean activate) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<UUID> |
GridContinuousProcessor.startRoutine(GridContinuousHandler hnd,
boolean locOnly,
int bufSize,
long interval,
boolean autoUnsubscribe,
IgnitePredicate<ClusterNode> prjPred) |
IgniteInternalFuture<?> |
GridContinuousProcessor.stopRoutine(UUID routineId) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
DataStreamerImpl.internalFuture() |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
DataStructuresProcessor.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
HadoopNoopProcessor.finishFuture(HadoopJobId jobId)
Gets Hadoop job finish future.
|
abstract IgniteInternalFuture<?> |
HadoopProcessorAdapter.finishFuture(HadoopJobId jobId)
Gets Hadoop job finish future.
|
IgniteInternalFuture<?> |
Hadoop.finishFuture(HadoopJobId jobId)
Gets Hadoop finish future for particular job.
|
IgniteInternalFuture<?> |
HadoopNoopProcessor.submit(HadoopJobId jobId,
HadoopJobInfo jobInfo)
Submits job to job tracker.
|
abstract IgniteInternalFuture<?> |
HadoopProcessorAdapter.submit(HadoopJobId jobId,
HadoopJobInfo jobInfo)
Submits job to job tracker.
|
IgniteInternalFuture<?> |
Hadoop.submit(HadoopJobId jobId,
HadoopJobInfo jobInfo)
Submits job to job tracker.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<byte[]> |
IgfsDataManager.dataBlock(IgfsEntryInfo fileInfo,
IgfsPath path,
long blockIdx,
IgfsSecondaryFileSystemPositionedReadable secReader)
Get data block for specified file ID and block index.
|
protected IgniteInternalFuture<byte[]> |
IgfsInputStreamImpl.dataBlock(long blockIdx)
Get data block for specified block index.
|
IgniteInternalFuture<Object> |
IgfsDataManager.delete(IgfsEntryInfo fileInfo)
Delete file's data from data cache.
|
IgniteInternalFuture<IgfsMessage> |
IgfsServerHandler.handleAsync(IgfsClientSession ses,
IgfsMessage msg,
DataInput in)
Asynchronously handles incoming message.
|
IgniteInternalFuture<Boolean> |
IgfsDataManager.writeStart(IgniteUuid fileId)
Registers write future in igfs data manager.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
PlatformProcessorImpl.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
| Modifier and Type | Method and Description |
|---|---|
protected PlatformListenable |
PlatformAbstractTarget.readAndListenFuture(BinaryRawReader reader,
IgniteInternalFuture fut)
Reads future information and listens.
|
protected PlatformListenable |
PlatformAbstractTarget.readAndListenFuture(BinaryRawReader reader,
IgniteInternalFuture fut,
PlatformFutureUtils.Writer writer)
Reads future information and listens.
|
| Modifier and Type | Class and Description |
|---|---|
protected class |
PlatformCompute.ComputeConvertingFuture
Wraps ComputeTaskFuture as IgniteInternalFuture.
|
| Modifier and Type | Method and 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.
|
| Modifier and Type | Method and Description |
|---|---|
static PlatformListenable |
PlatformFutureUtils.getListenable(IgniteInternalFuture fut)
Gets the listenable.
|
static PlatformListenable |
PlatformFutureUtils.listen(PlatformContext ctx,
IgniteInternalFuture fut,
long futPtr,
int typ,
PlatformFutureUtils.Writer writer,
PlatformTarget target)
Listen future.
|
static PlatformListenable |
PlatformFutureUtils.listen(PlatformContext ctx,
IgniteInternalFuture fut,
long futPtr,
int typ,
PlatformTarget target)
Listen future.
|
static PlatformListenable |
PlatformFutureUtils.listen(PlatformContext ctx,
IgniteInternalFuture fut,
long futPtr,
PlatformFutureUtils.Writer writer,
PlatformTarget target)
Listen future.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
GridQueryProcessor.dynamicIndexCreate(String space,
String tblName,
QueryIndex idx,
boolean ifNotExists)
Entry point for index procedure.
|
IgniteInternalFuture<?> |
GridQueryProcessor.dynamicIndexDrop(String space,
String idxName,
boolean ifExists)
Entry point for index drop procedure
|
IgniteInternalFuture<?> |
GridQueryProcessor.rebuildIndexesFromHash(Collection<Integer> cacheIds)
Rebuilds indexes for provided caches from corresponding hash indexes.
|
| Modifier and Type | Class and Description |
|---|---|
class |
SchemaOperationClientFuture
Schema operation client future.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture |
SchemaOperationWorker.future() |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridRestProtocolHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridRestCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridCacheCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridChangeStateCommandHandler.handleAsync(GridRestRequest restRest) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
DataStructuresCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridLogCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
QueryCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRedisMessage> |
GridRedisConnectionCommandHandler.handleAsync(GridRedisMessage msg) |
IgniteInternalFuture<GridRedisMessage> |
GridRedisCommandHandler.handleAsync(GridRedisMessage msg) |
IgniteInternalFuture<GridRedisMessage> |
GridRedisRestCommandHandler.handleAsync(GridRedisMessage msg) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridTaskCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridTopologyCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridVersionCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Class and Description |
|---|---|
class |
GridServiceDeploymentFuture
Service deployment future.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
GridServiceProcessor.cancel(String name) |
IgniteInternalFuture<?> |
GridServiceProcessor.cancelAll() |
IgniteInternalFuture<?> |
GridServiceProcessor.deploy(ServiceConfiguration cfg) |
IgniteInternalFuture<?> |
GridServiceProcessor.deployClusterSingleton(ClusterGroup prj,
String name,
Service svc) |
IgniteInternalFuture<?> |
GridServiceProcessor.deployKeyAffinitySingleton(String name,
Service svc,
String cacheName,
Object affKey) |
IgniteInternalFuture<?> |
GridServiceProcessor.deployMultiple(ClusterGroup prj,
String name,
Service svc,
int totalCnt,
int maxPerNodeCnt) |
IgniteInternalFuture<?> |
GridServiceProcessor.deployNodeSingleton(ClusterGroup prj,
String name,
Service svc) |
| Modifier and Type | Method and Description |
|---|---|
static void |
IgniteUtils.asyncLogError(IgniteInternalFuture<?> f,
IgniteLogger log)
Adds listener to asynchronously log errors.
|
| Modifier and Type | Class and Description |
|---|---|
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.
|
| Modifier and Type | Field and Description |
|---|---|
protected IgniteInternalFuture<V> |
IgniteFutureImpl.fut |
| Modifier and Type | Method and Description |
|---|---|
<T> IgniteInternalFuture<T> |
GridFutureAdapter.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T> IgniteInternalFuture<T> |
GridFutureAdapter.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb,
Executor exec)
Make a chained future to convert result of this future (when complete) into a new format.
|
<R> IgniteInternalFuture<R> |
GridFinishedFuture.chain(IgniteClosure<? super IgniteInternalFuture<T>,R> doneCb)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T1> IgniteInternalFuture<T1> |
GridFinishedFuture.chain(IgniteClosure<? super IgniteInternalFuture<T>,T1> doneCb,
Executor exec)
Make a chained future to convert result of this future (when complete) into a new format.
|
protected <T> IgniteInternalFuture<T> |
IgniteFutureImpl.chainInternal(IgniteClosure<? super IgniteFuture<V>,T> doneCb) |
protected IgniteInternalFuture<T> |
GridCompoundFuture.future(int idx)
Returns future at the specified position in this list.
|
IgniteInternalFuture<V> |
IgniteFutureImpl.internalFuture() |
| Modifier and Type | Method and Description |
|---|---|
Collection<IgniteInternalFuture<T>> |
GridCompoundFuture.futures()
Gets collection of futures.
|
| Modifier and Type | Method and Description |
|---|---|
void |
GridCompoundFuture.add(IgniteInternalFuture<T> fut)
Adds a future to this compound future.
|
void |
GridCompoundFuture.apply(IgniteInternalFuture<T> fut)
Closure body.
|
| Modifier and Type | Method and Description |
|---|---|
<T> IgniteInternalFuture<T> |
GridFutureAdapter.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T> IgniteInternalFuture<T> |
GridFutureAdapter.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb,
Executor exec)
Make a chained future to convert result of this future (when complete) into a new format.
|
<R> IgniteInternalFuture<R> |
GridFinishedFuture.chain(IgniteClosure<? super IgniteInternalFuture<T>,R> doneCb)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T1> IgniteInternalFuture<T1> |
GridFinishedFuture.chain(IgniteClosure<? super IgniteInternalFuture<T>,T1> doneCb,
Executor exec)
Make a chained future to convert result of this future (when complete) into a new format.
|
void |
GridFutureAdapter.listen(IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)
Registers listener closure to be asynchronously notified whenever future completes.
|
void |
GridFinishedFuture.listen(IgniteInClosure<? super IgniteInternalFuture<T>> lsnr)
Registers listener closure to be asynchronously notified whenever future completes.
|
| Constructor and Description |
|---|
GridEmbeddedFuture(IgniteBiClosure<B,Exception,A> c,
IgniteInternalFuture<B> embedded) |
GridEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c)
Embeds futures.
|
GridEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c1,
IgniteBiClosure<A,Exception,A> c2)
Embeds futures.
|
GridEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteOutClosure<IgniteInternalFuture<A>> c) |
IgniteFutureImpl(IgniteInternalFuture<V> fut) |
| Constructor and Description |
|---|
GridEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c)
Embeds futures.
|
GridEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c1,
IgniteBiClosure<A,Exception,A> c2)
Embeds futures.
|
GridEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteOutClosure<IgniteInternalFuture<A>> c) |
| Modifier and Type | Method and Description |
|---|---|
static <T> void |
GridFunc.awaitAll(Collection<IgniteInternalFuture<T>> futs)
Deprecated.
|
static <T> void |
GridFunc.awaitAll(long timeout,
Collection<IgniteInternalFuture<T>> futs)
Deprecated.
|
static <T,R> R |
GridFunc.awaitAll(long timeout,
IgniteReducer<T,R> rdc,
Collection<IgniteInternalFuture<T>> futs)
Deprecated.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
GridNioFuture<R>
NIO future.
|
| Modifier and Type | Class and 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.
|
| Modifier and Type | Method and Description |
|---|---|
void |
GridNioServer.sendSystem(GridNioSession ses,
Message msg,
IgniteInClosure<? super IgniteInternalFuture<?>> lsnr)
Adds message at the front of the queue without acquiring back pressure semaphore.
|
| Modifier and Type | Class and Description |
|---|---|
class |
GridWorkerFuture<T>
Future for locally executed closure that defines cancellation logic.
|
Follow @ApacheIgnite
Ignite Fabric : ver. 2.0.0 Release Date : April 30 2017