Uses of Class
org.apache.ignite.lang.IgniteAsyncSupported

Packages that use IgniteAsyncSupported

Package	Description
org.apache.ignite	Contains entry-point Ignite & HPC APIs.
org.apache.ignite.transactions	Contains transaction-related classes.

Uses of IgniteAsyncSupported in org.apache.ignite

Methods in org.apache.ignite with annotations of type IgniteAsyncSupported

Modifier and Type	Method and Description
<R> R	IgniteCompute.affinityCall(@NotNull Collection<String> cacheNames, int partId, IgniteCallable<R> job) Executes given job on the node where partition is located (the partition is primary on the node) It's guaranteed that the data of all the partitions of all participating caches, the affinity key belongs to, will present on the destination node throughout the job execution.
<R> R	IgniteCompute.affinityCall(@NotNull Collection<String> cacheNames, Object affKey, IgniteCallable<R> job) Executes given job on the node where data for provided affinity key is located (a.k.a. affinity co-location).
<R> R	IgniteCompute.affinityCall(String cacheName, Object affKey, IgniteCallable<R> job) Executes given job on the node where data for provided affinity key is located (a.k.a. affinity co-location).
void	IgniteCompute.affinityRun(@NotNull Collection<String> cacheNames, int partId, IgniteRunnable job) Executes given job on the node where partition is located (the partition is primary on the node) It's guaranteed that the data of all the partitions of all participating caches, the affinity key belongs to, will present on the destination node throughout the job execution.
void	IgniteCompute.affinityRun(@NotNull Collection<String> cacheNames, Object affKey, IgniteRunnable job) Executes given job on the node where data for provided affinity key is located (a.k.a. affinity co-location).
void	IgniteCompute.affinityRun(String cacheName, Object affKey, IgniteRunnable job) Executes given job on the node where data for provided affinity key is located (a.k.a. affinity co-location).
<T,R> Collection<R>	IgniteCompute.apply(IgniteClosure<T,R> job, Collection<? extends T> args) Executes provided closure job on nodes within the underlying cluster group.
<R,T> R	IgniteCompute.apply(IgniteClosure<T,R> job, T arg) Executes provided closure job on a node within the underlying cluster group.
<R1,R2,T> R2	IgniteCompute.apply(IgniteClosure<T,R1> job, Collection<? extends T> args, IgniteReducer<R1,R2> rdc) Executes provided closure job on nodes within the underlying cluster group.
<R> Collection<R>	IgniteCompute.broadcast(IgniteCallable<R> job) Broadcasts given job to all nodes in cluster group.
<R,T> Collection<R>	IgniteCompute.broadcast(IgniteClosure<T,R> job, T arg) Broadcasts given closure job with passed in argument to all nodes in the cluster group.
void	IgniteCompute.broadcast(IgniteRunnable job) Broadcasts given job to all nodes in the cluster group.
<R> Collection<R>	IgniteCompute.call(Collection<? extends IgniteCallable<R>> jobs) Executes collection of jobs on nodes within the underlying cluster group.
<R1,R2> R2	IgniteCompute.call(Collection<? extends IgniteCallable<R1>> jobs, IgniteReducer<R1,R2> rdc) Executes collection of jobs on nodes within the underlying cluster group.
<R> R	IgniteCompute.call(IgniteCallable<R> job) Executes provided job on a node within the underlying cluster group.
void	IgniteServices.cancel(String name) Cancels service deployment.
void	IgniteServices.cancelAll() Cancels all deployed services.
void	IgniteServices.cancelAll(Collection<String> names) Cancels services with specified names.
void	IgniteCache.clear()
void	IgniteCache.clear(K key) Clears entry from the cache and swap storage, without notifying listeners or CacheWriters.
void	IgniteCache.clearAll(Set<? extends K> keys) Clears entries from the cache and swap storage, without notifying listeners or CacheWriters.
boolean	IgniteCache.containsKey(K key)
boolean	IgniteCache.containsKeys(Set<? extends K> keys) Determines if the Cache contains entries for the specified keys.
void	IgniteServices.deploy(ServiceConfiguration cfg) Deploys multiple instances of the service on the grid according to provided configuration.
void	IgniteServices.deployClusterSingleton(String name, Service svc) Deploys a cluster-wide singleton service.
void	IgniteServices.deployKeyAffinitySingleton(String name, Service svc, @Nullable String cacheName, Object affKey) Deploys one instance of this service on the primary node for a given affinity key.
void	IgniteServices.deployMultiple(String name, Service svc, int totalCnt, int maxPerNodeCnt) Deploys multiple instances of the service on the grid.
void	IgniteServices.deployNodeSingleton(String name, Service svc) Deploys a per-node singleton service.
<T,R> R	IgniteCompute.execute(Class<? extends ComputeTask<T,R>> taskCls, T arg) Executes given task on within the cluster group.
<T,R> R	IgniteCompute.execute(ComputeTask<T,R> task, T arg) Executes given task within the cluster group.
<T,R> R	IgniteCompute.execute(String taskName, T arg) Executes given task within the cluster group.
V	IgniteCache.get(K key)
Map<K,V>	IgniteCache.getAll(Set<? extends K> keys)
Map<K,V>	IgniteCache.getAllOutTx(Set<? extends K> keys) Gets values from cache.
V	IgniteCache.getAndPut(K key, V val)
V	IgniteCache.getAndPutIfAbsent(K key, V val) Stores given key-value pair in cache only if cache had no previous mapping for it.
V	IgniteCache.getAndRemove(K key)
V	IgniteCache.getAndReplace(K key, V val)
Collection<CacheEntry<K,V>>	IgniteCache.getEntries(Set<? extends K> keys) Gets a collection of entries from the Cache.
CacheEntry<K,V>	IgniteCache.getEntry(K key) Gets an entry from the cache.
<T> T	IgniteCache.invoke(K key, CacheEntryProcessor<K,V,T> entryProcessor, Object... arguments) Invokes an CacheEntryProcessor against the Cache.Entry specified by the provided key.
<T> T	IgniteCache.invoke(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... arguments) Please refer to documentation for CacheAtomicityMode.ATOMIC for information on system behavior in crash scenarios for atomic caches.
<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>	IgniteCache.invokeAll(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args) Asynchronously invokes each EntryProcessor from map's values against the correspondent Cache.Entry specified by map's key set.
<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>	IgniteCache.invokeAll(Set<? extends K> keys, CacheEntryProcessor<K,V,T> entryProcessor, Object... args) Invokes an CacheEntryProcessor against the set of Cache.Entrys specified by the set of keys.
<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>	IgniteCache.invokeAll(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args) Please refer to documentation for CacheAtomicityMode.ATOMIC for information on system behavior in crash scenarios for atomic caches.
void	IgniteCache.loadCache(@Nullable IgniteBiPredicate<K,V> p, Object... args) Executes IgniteCache.localLoadCache(IgniteBiPredicate, Object...) on all cache nodes.
void	IgniteCache.localLoadCache(@Nullable IgniteBiPredicate<K,V> p, Object... args) Delegates to CacheStore.loadCache(IgniteBiInClosure,Object...) method to load state from the underlying persistent storage.
void	IgniteCache.put(K key, V val)
void	IgniteCache.putAll(Map<? extends K,? extends V> map) Keys are locked in the order in which they appear in map.
boolean	IgniteCache.putIfAbsent(K key, V val) For CacheAtomicityMode.ATOMIC return value on primary node crash may be incorrect because of the automatic retries.
<T extends Event> UUID	IgniteEvents.remoteListen(@Nullable IgniteBiPredicate<UUID,T> locLsnr, @Nullable IgnitePredicate<T> rmtFilter, int... types) Adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well).
<T extends Event> UUID	IgniteEvents.remoteListen(int bufSize, long interval, boolean autoUnsubscribe, @Nullable IgniteBiPredicate<UUID,T> locLsnr, @Nullable IgnitePredicate<T> rmtFilter, int... types) Adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well).
UUID	IgniteMessaging.remoteListen(@Nullable Object topic, IgniteBiPredicate<UUID,?> p) Adds a message listener for a given topic to all nodes in the cluster group (possibly including this node if it belongs to the cluster group as well).
<T extends Event> List<T>	IgniteEvents.remoteQuery(IgnitePredicate<T> p, long timeout, int... types) Queries nodes in this cluster group for events using passed in predicate filter for event selection.
boolean	IgniteCache.remove(K key)
boolean	IgniteCache.remove(K key, V oldVal) For CacheAtomicityMode.ATOMIC return value on primary node crash may be incorrect because of the automatic retries.
void	IgniteCache.removeAll() Removes all of the mappings from this cache.
void	IgniteCache.removeAll(Set<? extends K> keys) Keys are locked in the order in which they appear in key set.
boolean	IgniteCache.replace(K key, V val)
boolean	IgniteCache.replace(K key, V oldVal, V newVal) For CacheAtomicityMode.ATOMIC return value on primary node crash may be incorrect because of the automatic retries.
void	IgniteCompute.run(Collection<? extends IgniteRunnable> jobs) Executes collection of jobs on grid nodes within the underlying cluster group.
void	IgniteCompute.run(IgniteRunnable job) Executes provided job on a node within the underlying cluster group.
int	IgniteCache.size(CachePeekMode... peekModes) Gets the number of all entries cached across all nodes.
long	IgniteCache.sizeLong(CachePeekMode... peekModes) Gets the number of all entries cached across all nodes as a long value.
long	IgniteCache.sizeLong(int partition, CachePeekMode... peekModes) Gets the number of all entries cached in a partition as a long value.
Collection<ClusterStartNodeResult>	IgniteCluster.startNodes(Collection<Map<String,Object>> hosts, @Nullable Map<String,Object> dflts, boolean restart, int timeout, int maxConn) Starts one or more nodes on remote host(s).
Collection<ClusterStartNodeResult>	IgniteCluster.startNodes(File file, boolean restart, int timeout, int maxConn) Starts one or more nodes on remote host(s).
void	IgniteEvents.stopRemoteListen(UUID opId) Stops listening to remote events.
void	IgniteMessaging.stopRemoteListen(UUID opId) Unregisters all listeners identified with provided operation ID on all nodes in the cluster group.
<T extends Event> T	IgniteEvents.waitForLocal(@Nullable IgnitePredicate<T> filter, int... types) Waits for the specified events.

Uses of IgniteAsyncSupported in org.apache.ignite.transactions

Methods in org.apache.ignite.transactions with annotations of type IgniteAsyncSupported

Modifier and Type	Method and Description
void	Transaction.commit() Commits this transaction by initiating two-phase-commit process.
void	Transaction.rollback() Rolls back this transaction.