## Uses of Class
org.apache.ignite.IgniteException

- Packages that use IgniteException
  Package | Description
  --- | ---
  org.apache.ignite | Contains entry-point Ignite & HPC APIs.
  org.apache.ignite.binary | Contains Ignite Binary Objects API classes.
  org.apache.ignite.cache.jta | Contains JTA (Java Transaction API) related public classes and interfaces.
  org.apache.ignite.cache.jta.jndi | Contains JNDI-based transaction manager lookup.
  org.apache.ignite.cache.jta.reflect | Contains reflection-based transaction manager lookup.
  org.apache.ignite.cache.query | Contains APIs for creating and executing cache queries.
  org.apache.ignite.cache.store.jdbc | Contains reference JDBC-based cache store implementation.
  org.apache.ignite.cache.store.spring | Contains cache store session listener based on Spring transaction management.
  org.apache.ignite.cluster | Contains cluster-related classes.
  org.apache.ignite.compute | Contains Compute Grid functionality.
  org.apache.ignite.compute.gridify | Contains APIs utilized for AOP-based grid-enabling.
  org.apache.ignite.lang | Contains general language constructs and functional APIs for distributed computations.
  org.apache.ignite.lifecycle | Contains lifecycle-related classes.
  org.apache.ignite.messaging | Contains Topic-based Messaging functionality.
  org.apache.ignite.ml.math.exceptions | Contains exceptions for distributed ML.
  org.apache.ignite.ml.math.exceptions.datastructures | Contains exceptions for kNN algorithms.
  org.apache.ignite.ml.math.exceptions.math | Contains exceptions for distributed code algebra.
  org.apache.ignite.ml.math.exceptions.preprocessing | Contains exceptions for preprocessing.
  org.apache.ignite.ml.sparkmodelparser | Base package for Spark model parser.
  org.apache.ignite.mxbean | Contains annotations for Dynamic MBeans.
  org.apache.ignite.platform.dotnet | Contains .Net platform-related classes.
  org.apache.ignite.plugin | Contains plugins management API.
  org.apache.ignite.plugin.extensions.communication | Contains extendable components for communication.
  org.apache.ignite.plugin.security | Contains APIs for security, authentication, and authorization.
  org.apache.ignite.scheduler | Contains Job Scheduling functionality.
  org.apache.ignite.services | Contains main Managed Services APIs.
  org.apache.ignite.spi | Contains common classes and interfaces for SPI implementations.
  org.apache.ignite.spi.communication.tcp | Contains default TCP/IP-based implementation for communication SPI.
  org.apache.ignite.spi.discovery | Contains APIs for topology manager SPI.
  org.apache.ignite.spi.discovery.tcp | Contains default TCP/IP implementation for discovery SPI.
  org.apache.ignite.spi.discovery.tcp.ipfinder.s3.encrypt | Contains Encryption services.
  org.apache.ignite.spi.encryption | Contains APIs for encryption SPI.
  org.apache.ignite.spi.encryption.keystore | Contains encryption SPI implementation based on standard jdk keystore.
  org.apache.ignite.spi.encryption.noop | Contains no-op encryption SPI implementation.
  org.apache.ignite.spi.failover | Contains APIs for failover SPI.
  org.apache.ignite.spi.loadbalancing | Contains APIs for load balancing SPI.
  org.apache.ignite.spi.tracing | Contains common classes and interfaces for tracing SPI implementations.
  org.apache.ignite.stream | Contains Ignite Streamer classes.
  org.apache.ignite.stream.camel | Contains implementation of Camel Streamer.
  org.apache.ignite.stream.jms11 | Contains implementation of JMS queue and topic messages consumer.
  org.apache.ignite.stream.mqtt | Contains implementation of MQTT topic messages consumer.
  org.apache.ignite.stream.storm | StormStreamer -- integration with Apache Storm.
  org.apache.ignite.transactions | Contains transaction-related classes.

- - ### Uses of IgniteException in org.apache.ignite

    Subclasses of IgniteException in org.apache.ignite
    Modifier and Type | Class and Description
    --- | ---
    `class` | `IgniteCacheRestartingException` Exception thrown from ignite cache API if cache is restarting.
    `class` | `IgniteClientDisconnectedException` Exception thrown from Ignite API when client node disconnected from cluster.
    `class` | `IgniteDataStreamerTimeoutException` Exception is thrown when timeout of some `IgniteDataStreamer` operations occurs.
    `class` | `IgniteDeploymentException` Deployment or re-deployment failed.
    `class` | `IgniteInterruptedException` This exception is used to wrap standard `InterruptedException` into `IgniteException`.

    Methods in org.apache.ignite that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | IgniteQueue.`add(T item)`
    `boolean` | IgniteSet.`add(T t)`
    `boolean` | IgniteQueue.`addAll(Collection<? extends T> items)`
    `boolean` | IgniteSet.`addAll(Collection<? extends T> c)`
    `long` | IgniteAtomicSequence.`addAndGet(long l)` Adds `l` elements to atomic sequence and gets value of atomic sequence.
    `long` | IgniteAtomicLong.`addAndGet(long l)` Adds `l` and gets current value of atomic long.
    `<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` | IgniteQueue.`affinityCall(IgniteCallable<R> job)` Executes given job on collocated queue on the node where the queue is located (a.k.a. affinity co-location).
    `<R> R` | IgniteSet.`affinityCall(IgniteCallable<R> job)` Executes given job on collocated set on the node where the set 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).
    `<R> IgniteFuture<R>` | IgniteCompute.`affinityCallAsync(@NotNull Collection<String> cacheNames, int partId, IgniteCallable<R> job)` Executes given job asynchronously on the node where partition is located (the partition is primary on the node) The data of the partition will not be migrated from the target node while the job is executed.
    `<R> IgniteFuture<R>` | IgniteCompute.`affinityCallAsync(@NotNull Collection<String> cacheNames, Object affKey, IgniteCallable<R> job)` Executes given job asynchronously on the node where data for provided affinity key is located (a.k.a. affinity co-location).
    `<R> IgniteFuture<R>` | IgniteCompute.`affinityCallAsync(String cacheName, Object affKey, IgniteCallable<R> job)` Executes given job asynchronously 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` | IgniteQueue.`affinityRun(IgniteRunnable job)` Executes given job on collocated queue on the node where the queue is located (a.k.a. affinity co-location).
    `void` | IgniteSet.`affinityRun(IgniteRunnable job)` Executes given job on collocated set on the node where the set 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).
    `IgniteFuture<Void>` | IgniteCompute.`affinityRunAsync(@NotNull Collection<String> cacheNames, int partId, IgniteRunnable job)` Executes given job asynchronously on the node where partition is located (the partition is primary on the node) The data of the partition will not be migrated from the target node while the job is executed.
    `IgniteFuture<Void>` | IgniteCompute.`affinityRunAsync(@NotNull Collection<String> cacheNames, Object affKey, IgniteRunnable job)` Executes given job asynchronously on the node where data for provided affinity key is located (a.k.a. affinity co-location).
    `IgniteFuture<Void>` | IgniteCompute.`affinityRunAsync(String cacheName, Object affKey, IgniteRunnable job)` Executes given job asynchronously 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.
    `<T,R> IgniteFuture<Collection<R>>` | IgniteCompute.`applyAsync(IgniteClosure<T,R> job, Collection<? extends T> args)` Executes provided closure job asynchronously on nodes within the underlying cluster group.
    `<R,T> IgniteFuture<R>` | IgniteCompute.`applyAsync(IgniteClosure<T,R> job, T arg)` Executes provided closure job asynchronously on a node within the underlying cluster group.
    `<R1,R2,T> IgniteFuture<R2>` | IgniteCompute.`applyAsync(IgniteClosure<T,R1> job, Collection<? extends T> args, IgniteReducer<R1,R2> rdc)` Executes provided closure job asynchronously on nodes within the underlying cluster group.
    `IgniteAtomicLong` | IgniteSpringBean.`atomicLong(String name, AtomicConfiguration cfg, long initVal, boolean create)`
    `IgniteAtomicLong` | Ignite.`atomicLong(String name, AtomicConfiguration cfg, long initVal, boolean create)` Will get a atomic long from cache and create one if it has not been created yet and `create` flag is `true`.
    `IgniteAtomicLong` | Ignite.`atomicLong(String name, long initVal, boolean create)` Will get a atomic long from cache and create one if it has not been created yet and `create` flag is `true`.
    `<T> IgniteAtomicReference<T>` | IgniteSpringBean.`atomicReference(String name, AtomicConfiguration cfg, T initVal, boolean create)` Will get a atomic reference from cache and create one if it has not been created yet and `create` flag is `true`.
    `<T> IgniteAtomicReference<T>` | Ignite.`atomicReference(String name, AtomicConfiguration cfg, T initVal, boolean create)` Will get a atomic reference from cache and create one if it has not been created yet and `create` flag is `true`.
    `<T> IgniteAtomicReference<T>` | Ignite.`atomicReference(String name, T initVal, boolean create)` Will get a atomic reference from cache and create one if it has not been created yet and `create` flag is `true`.
    `IgniteAtomicSequence` | IgniteSpringBean.`atomicSequence(String name, AtomicConfiguration cfg, long initVal, boolean create)` Will get an atomic sequence from cache and create one if it has not been created yet and `create` flag is `true`.
    `IgniteAtomicSequence` | Ignite.`atomicSequence(String name, AtomicConfiguration cfg, long initVal, boolean create)` Will get an atomic sequence from cache and create one if it has not been created yet and `create` flag is `true`.
    `IgniteAtomicSequence` | Ignite.`atomicSequence(String name, long initVal, boolean create)` Will get an atomic sequence from cache and create one if it has not been created yet and `create` flag is `true`.
    `<T,S> IgniteAtomicStamped<T,S>` | IgniteSpringBean.`atomicStamped(String name, AtomicConfiguration cfg, T initVal, S initStamp, boolean create)`
    `<T,S> IgniteAtomicStamped<T,S>` | Ignite.`atomicStamped(String name, AtomicConfiguration cfg, T initVal, S initStamp, boolean create)` Will get a atomic stamped from cache and create one if it has not been created yet and `create` flag is `true`.
    `<T,S> IgniteAtomicStamped<T,S>` | Ignite.`atomicStamped(String name, T initVal, S initStamp, boolean create)` Will get a atomic stamped from cache and create one if it has not been created yet and `create` flag is `true`.
    `void` | IgniteCountDownLatch.`await()` Causes the current thread to wait until the latch has counted down to zero, unless current thread is interrupted.
    `void` | IgniteCondition.`await()` Causes the current thread to wait until it is signalled or interrupted.
    `boolean` | IgniteCountDownLatch.`await(long timeout)` Causes the current thread to wait until the latch has counted down to zero, unless the thread is interrupted, or the specified waiting time elapses.
    `boolean` | IgniteCountDownLatch.`await(long timeout, TimeUnit unit)` Causes the current thread to wait until the latch has counted down to zero, unless the thread is interrupted, or the specified waiting time elapses.
    `boolean` | IgniteCondition.`await(long time, TimeUnit unit)` Causes the current thread to wait until it is signalled or interrupted, or the specified waiting time elapses.
    `long` | IgniteCondition.`awaitNanos(long nanosTimeout)` Causes the current thread to wait until it is signalled or interrupted, or the specified waiting time elapses.
    `void` | IgniteCondition.`awaitUninterruptibly()` Causes the current thread to wait until it is signalled.
    `boolean` | IgniteCondition.`awaitUntil(Date deadline)` Causes the current thread to wait until it is signalled or interrupted, or the specified deadline elapses.
    `void` | IgniteCluster.`baselineAutoAdjustEnabled(boolean baselineAutoAdjustEnabled)`
    `void` | IgniteCluster.`baselineAutoAdjustTimeout(long baselineAutoAdjustTimeout)`
    `<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> IgniteFuture<Collection<R>>` | IgniteCompute.`broadcastAsync(IgniteCallable<R> job)` Broadcasts given job asynchronously to all nodes in cluster group.
    `<R,T> IgniteFuture<Collection<R>>` | IgniteCompute.`broadcastAsync(IgniteClosure<T,R> job, T arg)` Broadcasts given closure job asynchronously with passed in argument to all nodes in the cluster group.
    `IgniteFuture<Void>` | IgniteCompute.`broadcastAsync(IgniteRunnable job)` Broadcasts given job asynchronously 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.
    `<R> IgniteFuture<Collection<R>>` | IgniteCompute.`callAsync(Collection<? extends IgniteCallable<R>> jobs)` Executes collection of jobs asynchronously on nodes within the underlying cluster group.
    `<R1,R2> IgniteFuture<R2>` | IgniteCompute.`callAsync(Collection<? extends IgniteCallable<R1>> jobs, IgniteReducer<R1,R2> rdc)` Executes collection of jobs asynchronously on nodes within the underlying cluster group.
    `<R> IgniteFuture<R>` | IgniteCompute.`callAsync(IgniteCallable<R> job)` Executes provided job asynchronously 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` | IgniteQueue.`clear()`
    `void` | IgniteSet.`clear()`
    `void` | IgniteQueue.`clear(int batchSize)` Removes all of the elements from this queue.
    `void` | IgniteSpringBean.`close()` Closes `this` instance of grid.
    `void` | IgniteQueue.`close()` Removes this queue.
    `void` | IgniteSet.`close()` Removes this set.
    `void` | Ignite.`close()` Closes `this` instance of grid.
    `boolean` | IgniteAtomicLong.`compareAndSet(long expVal, long newVal)` Atomically compares current value to the expected value, and if they are equal, sets current value to new value.
    `boolean` | IgniteAtomicReference.`compareAndSet(T expVal, T newVal)` Conditionally sets the new value.
    `boolean` | IgniteAtomicStamped.`compareAndSet(T expVal, T newVal, S expStamp, S newStamp)` Conditionally sets the new value and new stamp.
    `boolean` | IgniteQueue.`contains(Object item)`
    `boolean` | IgniteSet.`contains(Object o)`
    `boolean` | IgniteQueue.`containsAll(Collection<?> items)`
    `boolean` | IgniteSet.`containsAll(Collection<?> c)`
    `int` | IgniteCountDownLatch.`countDown()` Decrements the count of the latch, releasing all waiting threads on all nodes if the count reaches zero.
    `int` | IgniteCountDownLatch.`countDown(int val)` Decreases the count of the latch using passed in value, releasing all waiting threads on all nodes if the count reaches zero.
    `void` | IgniteCountDownLatch.`countDownAll()` Counts down this latch to zero, releasing all waiting threads on all nodes.
    `IgniteCountDownLatch` | Ignite.`countDownLatch(String name, int cnt, boolean autoDel, boolean create)` Gets or creates count down latch.
    `long` | IgniteAtomicLong.`decrementAndGet()` Decrements and gets current value of atomic long.
    `boolean` | IgniteCluster.`disableWal(String cacheName)` Disables write-ahead logging for specified cache.
    `boolean` | IgniteCluster.`enableWal(String cacheName)` Enables write-ahead logging for specified cache.
    `<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.
    `<T,R> ComputeTaskFuture<R>` | IgniteCompute.`executeAsync(Class<? extends ComputeTask<T,R>> taskCls, T arg)` Executes given task asynchronously on within the cluster group.
    `<T,R> ComputeTaskFuture<R>` | IgniteCompute.`executeAsync(ComputeTask<T,R> task, T arg)` Executes given task asynchronously within the cluster group.
    `<T,R> ComputeTaskFuture<R>` | IgniteCompute.`executeAsync(String taskName, T arg)` Executes given task asynchronously within the cluster group.
    `IgniteBiTuple<T,S>` | IgniteAtomicStamped.`get()` Gets both current value and current stamp of atomic stamped.
    `long` | IgniteAtomicSequence.`get()` Gets current value of atomic sequence.
    `long` | IgniteAtomicLong.`get()` Gets current value of atomic long.
    `T` | IgniteAtomicReference.`get()` Gets current value of an atomic reference.
    `long` | IgniteAtomicSequence.`getAndAdd(long l)` Gets current value of atomic sequence and adds `l` elements.
    `long` | IgniteAtomicLong.`getAndAdd(long l)` Gets current value of atomic long and adds `l`.
    `long` | IgniteAtomicLong.`getAndDecrement()` Gets and decrements current value of atomic long.
    `long` | IgniteAtomicSequence.`getAndIncrement()` Gets and increments current value of atomic sequence.
    `long` | IgniteAtomicLong.`getAndIncrement()` Gets and increments current value of atomic long.
    `long` | IgniteAtomicLong.`getAndSet(long l)` Gets current value of atomic long and sets new value `l` of atomic long.
    `int` | IgniteLock.`getHoldCount()` Queries the number of holds on this lock by the current thread.
    `IgniteCondition` | IgniteLock.`getOrCreateCondition(String name)` Returns a `Condition` instance for use with this `IgniteLock` instance.
    `static Ignite` | Ignition.`getOrStart(IgniteConfiguration cfg)` Gets or starts new grid instance if it hasn't been started yet.
    `int` | IgniteLock.`getWaitQueueLength(IgniteCondition condition)` Returns an estimate of the number of threads on this node that are waiting on the given condition associated with this lock.
    `boolean` | IgniteLock.`hasQueuedThread(Thread thread)` Queries whether the given thread is waiting to acquire this lock.
    `boolean` | IgniteLock.`hasQueuedThreads()` Queries whether any threads on this node are waiting to acquire this lock.
    `boolean` | IgniteLock.`hasWaiters(IgniteCondition condition)` Queries whether any threads on this node are waiting on the given condition associated with this lock.
    `long` | IgniteAtomicSequence.`incrementAndGet()` Increments and returns the value of atomic sequence.
    `long` | IgniteAtomicLong.`incrementAndGet()` Increments and gets current value of atomic long.
    `boolean` | IgniteLock.`isBroken()` Returns true if any node that owned the locked failed before releasing the lock.
    `boolean` | IgniteQueue.`isEmpty()`
    `boolean` | IgniteSet.`isEmpty()`
    `boolean` | IgniteLock.`isHeldByCurrentThread()` Queries if this lock is held by the current thread.
    `boolean` | IgniteLock.`isLocked()` Queries if this lock is held by any thread on any node.
    `Iterator<T>` | IgniteQueue.`iterator()`
    `Iterator<T>` | IgniteSet.`iterator()`
    `static <T> T` | Ignition.`loadSpringBean(InputStream springXmlStream, String beanName)` Loads Spring bean by its name from given Spring XML configuration file.
    `static <T> T` | Ignition.`loadSpringBean(String springXmlPath, String beanName)` Loads Spring bean by its name from given Spring XML configuration file.
    `static <T> T` | Ignition.`loadSpringBean(URL springXmlUrl, String beanName)` Loads Spring bean by its name from given Spring XML configuration file.
    `void` | IgniteCompute.`localDeployTask(Class<? extends ComputeTask> taskCls, ClassLoader clsLdr)` Explicitly deploys a task with given class loader on the local node.
    `void` | IgniteLock.`lock()` Acquires the distributed reentrant lock.
    `void` | IgniteLock.`lockInterruptibly()` Acquires the lock unless the current thread is interrupted.
    `boolean` | IgniteQueue.`offer(T item)`
    `boolean` | IgniteQueue.`offer(T item, long timeout, TimeUnit unit)`
    `T` | IgniteQueue.`peek()`
    `T` | IgniteQueue.`poll()`
    `T` | IgniteQueue.`poll(long timeout, TimeUnit unit)`
    `void` | IgniteQueue.`put(T item)`
    `<T> IgniteQueue<T>` | Ignite.`queue(String name, int cap, @Nullable CollectionConfiguration cfg)` Will get a named queue from cache and create one if it has not been created yet and `cfg` is not `null`.
    `IgniteLock` | Ignite.`reentrantLock(String name, boolean failoverSafe, boolean fair, boolean create)` Gets or creates reentrant lock.
    `<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> IgniteFuture<UUID>` | IgniteEvents.`remoteListenAsync(@Nullable IgniteBiPredicate<UUID,T> locLsnr, @Nullable IgnitePredicate<T> rmtFilter, int... types)` Asynchronously 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> IgniteFuture<UUID>` | IgniteEvents.`remoteListenAsync(int bufSize, long interval, boolean autoUnsubscribe, @Nullable IgniteBiPredicate<UUID,T> locLsnr, @Nullable IgnitePredicate<T> rmtFilter, int... types)` Asynchronously 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).
    `IgniteFuture<UUID>` | IgniteMessaging.`remoteListenAsync(@Nullable Object topic, IgniteBiPredicate<UUID,?> p)` Asynchronously 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.
    `<T extends Event> IgniteFuture<List<T>>` | IgniteEvents.`remoteQueryAsync(IgnitePredicate<T> p, long timeout, int... types)` Asynchronously queries nodes in this cluster group for events using passed in predicate filter for event selection.
    `boolean` | IgniteQueue.`remove(Object item)`
    `boolean` | IgniteSet.`remove(Object o)`
    `boolean` | IgniteQueue.`removeAll(Collection<?> items)`
    `boolean` | IgniteSet.`removeAll(Collection<?> c)`
    `void` | IgniteCluster.`restartNodes()` Restarts nodes satisfying optional set of predicates.
    `void` | IgniteCluster.`restartNodes(Collection<UUID> ids)` Restarts nodes defined by provided IDs.
    `boolean` | IgniteQueue.`retainAll(Collection<?> items)`
    `boolean` | IgniteSet.`retainAll(Collection<?> c)`
    `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.
    `IgniteFuture<Void>` | IgniteCompute.`runAsync(Collection<? extends IgniteRunnable> jobs)` Executes collection of jobs asynchronously on grid nodes within the underlying cluster group.
    `IgniteFuture<Void>` | IgniteCompute.`runAsync(IgniteRunnable job)` Executes provided job asynchronously on a node within the underlying cluster group.
    `IgniteSemaphore` | Ignite.`semaphore(String name, int cnt, boolean failoverSafe, boolean create)` Gets or creates semaphore.
    `void` | IgniteMessaging.`send(@Nullable Object topic, Collection<?> msgs)` Sends given messages with the specified topic to the nodes in the underlying cluster group.
    `void` | IgniteMessaging.`send(@Nullable Object topic, Object msg)` Sends given message with specified topic to the nodes in the underlying cluster group.
    `void` | IgniteMessaging.`sendOrdered(@Nullable Object topic, Object msg, long timeout)` Sends given message with specified topic to the nodes in the underlying cluster group.
    `<T> T` | IgniteServices.`serviceProxy(String name, Class<? super T> svcItf, boolean sticky)` Gets a remote handle on the service.
    `<T> T` | IgniteServices.`serviceProxy(String name, Class<? super T> svcItf, boolean sticky, long timeout)` Gets a remote handle on the service with timeout.
    `<T> IgniteSet<T>` | Ignite.`set(String name, @Nullable CollectionConfiguration cfg)` Will get a named set from cache and create one if it has not been created yet and `cfg` is not `null`.
    `void` | IgniteAtomicReference.`set(T val)` Unconditionally sets the value.
    `void` | IgniteAtomicStamped.`set(T val, S stamp)` Unconditionally sets the value and the stamp.
    `void` | IgniteCondition.`signal()` Wakes up one waiting thread.
    `void` | IgniteCondition.`signalAll()` Wakes up all waiting threads.
    `int` | IgniteQueue.`size()`
    `int` | IgniteSet.`size()`
    `S` | IgniteAtomicStamped.`stamp()` Gets current stamp.
    `static Ignite` | Ignition.`start()` Starts grid with default configuration.
    `static Ignite` | Ignition.`start(IgniteConfiguration cfg)` Starts grid with given configuration.
    `static Ignite` | Ignition.`start(InputStream springCfgStream)` Starts all grids specified within given Spring XML configuration input stream.
    `static Ignite` | Ignition.`start(String springCfgPath)` Starts all grids specified within given Spring XML configuration file.
    `static Ignite` | Ignition.`start(URL springCfgUrl)` Starts all grids specified within given Spring XML configuration file URL.
    `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).
    `IgniteFuture<Collection<ClusterStartNodeResult>>` | IgniteCluster.`startNodesAsync(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) asynchronously.
    `IgniteFuture<Collection<ClusterStartNodeResult>>` | IgniteCluster.`startNodesAsync(File file, boolean restart, int timeout, int maxConn)` Starts one or more nodes on remote host(s) asynchronously.
    `void` | IgniteCluster.`state(ClusterState newState)` Changes current cluster state to given `newState` cluster state.
    `void` | IgniteCluster.`stopNodes()` Stops nodes satisfying optional set of predicates.
    `void` | IgniteCluster.`stopNodes(Collection<UUID> ids)` Stops nodes defined by provided IDs.
    `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.
    `IgniteFuture<Void>` | IgniteEvents.`stopRemoteListenAsync(UUID opId)` Asynchronously stops listening to remote events.
    `IgniteFuture<Void>` | IgniteMessaging.`stopRemoteListenAsync(UUID opId)` Asynchronously unregisters all listeners identified with provided operation ID on all nodes in the cluster group.
    `T` | IgniteQueue.`take()`
    `Object[]` | IgniteQueue.`toArray()`
    `Object[]` | IgniteSet.`toArray()`
    `<T> T[]` | IgniteQueue.`toArray(T[] a)`
    `<T1> T1[]` | IgniteSet.`toArray(T1[] a)`
    `boolean` | IgniteLock.`tryLock()` Acquires the lock only if it is free at the time of invocation.
    `boolean` | IgniteLock.`tryLock(long timeout, TimeUnit unit)` Acquires the lock if it is not held by another thread within the given waiting time and the current thread has not been interrupted.
    `void` | IgniteCompute.`undeployTask(String taskName)` Makes the best attempt to undeploy a task with given name within the underlying cluster group.
    `T` | IgniteAtomicStamped.`value()` Gets current value.
    `<T extends Event> T` | IgniteEvents.`waitForLocal(@Nullable IgnitePredicate<T> filter, int... types)` Waits for the specified events.
    `<T extends Event> IgniteFuture<T>` | IgniteEvents.`waitForLocalAsync(@Nullable IgnitePredicate<T> filter, int... types)` Create future to wait for the specified events.

  - ### Uses of IgniteException in org.apache.ignite.binary

    Subclasses of IgniteException in org.apache.ignite.binary
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BinaryInvalidTypeException` Exception indicating that class needed for deserialization of binary object does not exist.
    `class` | `BinaryObjectException` Exception indicating binary object serialization error.

  - ### Uses of IgniteException in org.apache.ignite.cache.jta

    Methods in org.apache.ignite.cache.jta that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `@Nullable TransactionManager` | CacheTmLookup.`getTm()` Gets Transaction Manager (TM).

  - ### Uses of IgniteException in org.apache.ignite.cache.jta.jndi

    Methods in org.apache.ignite.cache.jta.jndi that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `@Nullable TransactionManager` | CacheJndiTmLookup.`getTm()` Gets Transaction Manager (TM).

  - ### Uses of IgniteException in org.apache.ignite.cache.jta.reflect

    Methods in org.apache.ignite.cache.jta.reflect that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `TransactionManager` | CacheReflectionTmLookup.`getTm()` Gets Transaction Manager (TM).

  - ### Uses of IgniteException in org.apache.ignite.cache.query

    Subclasses of IgniteException in org.apache.ignite.cache.query
    Modifier and Type | Class and Description
    --- | ---
    `class` | `QueryRetryException` The exception is thrown if a query was cancelled or timed out while executing.

  - ### Uses of IgniteException in org.apache.ignite.cache.store.jdbc

    Methods in org.apache.ignite.cache.store.jdbc that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | CacheJdbcStoreSessionListener.`start()` Starts grid component, called on grid start.
    `void` | CacheAbstractJdbcStore.`start()` Starts grid component, called on grid start.
    `void` | CacheJdbcStoreSessionListener.`stop()` Stops grid component, called on grid shutdown.
    `void` | CacheAbstractJdbcStore.`stop()` Stops grid component, called on grid shutdown.

  - ### Uses of IgniteException in org.apache.ignite.cache.store.spring

    Methods in org.apache.ignite.cache.store.spring that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | CacheSpringStoreSessionListener.`start()` Starts grid component, called on grid start.
    `void` | CacheSpringStoreSessionListener.`stop()` Stops grid component, called on grid shutdown.

  - ### Uses of IgniteException in org.apache.ignite.cluster

    Subclasses of IgniteException in org.apache.ignite.cluster
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ClusterGroupEmptyException` This exception defines illegal call on empty cluster group.
    `class` | `ClusterTopologyException` This exception is used to indicate error with the cluster topology (e.g., crashed node, etc.).

    Methods in org.apache.ignite.cluster that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `ClusterMetrics` | ClusterGroup.`metrics()` Gets a metrics snapshot for this cluster group.

  - ### Uses of IgniteException in org.apache.ignite.compute

    Subclasses of IgniteException in org.apache.ignite.compute
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ComputeExecutionRejectedException` This exception defines execution rejection.
    `class` | `ComputeJobFailoverException` This runtime exception can be thrown from `ComputeJob.execute()` method to force job failover to another node within task topology.
    `class` | `ComputeTaskCancelledException` This exception indicates that grid task was cancelled.
    `class` | `ComputeTaskTimeoutException` This exception indicates that task execution timed out.
    `class` | `ComputeUserUndeclaredException` This exception is thrown when user's code throws undeclared runtime exception.

    Methods in org.apache.ignite.compute that return IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `IgniteException` | ComputeJobResult.`getException()` Gets exception produced by execution of remote job, or `null` if remote execution finished normally and did not produce any exceptions.

    Methods in org.apache.ignite.compute that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | ComputeJobSibling.`cancel()` Sends a request to cancel this sibling.
    `Object` | ComputeJob.`execute()` Executes this job.
    `@Nullable ClusterNode` | ComputeLoadBalancer.`getBalancedNode(ComputeJob job, @Nullable Collection<ClusterNode> exclNodes)` Gets the next balanced node according to the underlying load balancing policy.
    `@Nullable ComputeJobSibling` | ComputeTaskSession.`getJobSibling(IgniteUuid jobId)` Gets job sibling for a given ID.
    `Collection<ComputeJobSibling>` | ComputeTaskSession.`getJobSiblings()` Gets a collection of all grid job siblings.
    `<T> T` | ComputeTaskSession.`loadCheckpoint(String key)` Loads job's state previously saved via `ComputeTaskSession.saveCheckpoint(String, Object, ComputeTaskSessionScope, long)` method from an underlying storage for a given `key`.
    `@NotNull Map<? extends ComputeJob,ClusterNode>` | ComputeTask.`map(List<ClusterNode> subgrid, T arg)` This method is called to map or split grid task into multiple grid jobs.
    `void` | ComputeJobMasterLeaveAware.`onMasterNodeLeft(ComputeTaskSession ses)` A method which is executed in case master node has left topology during job execution.
    `R` | ComputeTask.`reduce(List<ComputeJobResult> results)` Reduces (or aggregates) results received so far into one compound result to be returned to caller via `ComputeTaskFuture.get()` method.
    `Collection<ComputeJobSibling>` | ComputeTaskSession.`refreshJobSiblings()` Refreshes collection of job siblings.
    `boolean` | ComputeTaskSession.`removeCheckpoint(String key)` Removes previously saved job's state for a given `key` from an underlying storage.
    `ComputeJobResultPolicy` | ComputeTask.`result(ComputeJobResult res, List<ComputeJobResult> rcvd)` Asynchronous callback invoked every time a result from remote execution is received.
    `ComputeJobResultPolicy` | ComputeTaskAdapter.`result(ComputeJobResult res, List<ComputeJobResult> rcvd)` Default implementation which will wait for all jobs to complete before calling `ComputeTask.reduce(List)` method.
    `void` | ComputeTaskSession.`saveCheckpoint(String key, Object state)` Saves intermediate state of a job or task to a storage.
    `void` | ComputeTaskSession.`saveCheckpoint(String key, Object state, ComputeTaskSessionScope scope, long timeout)` Saves intermediate state of a job to a storage.
    `void` | ComputeTaskSession.`saveCheckpoint(String key, Object state, ComputeTaskSessionScope scope, long timeout, boolean overwrite)` Saves intermediate state of a job or task to a storage.
    `void` | ComputeTaskContinuousMapper.`send(Collection<? extends ComputeJob> jobs)` Sends collection of jobs to nodes automatically picked by the underlying load balancer.
    `void` | ComputeTaskContinuousMapper.`send(ComputeJob job)` Sends job to a node automatically picked by the underlying load balancer.
    `void` | ComputeTaskContinuousMapper.`send(ComputeJob job, ClusterNode node)` Sends given job to a specific grid node.
    `void` | ComputeTaskContinuousMapper.`send(Map<? extends ComputeJob,ClusterNode> mappedJobs)` Sends collection of grid jobs to assigned nodes.
    `void` | ComputeTaskSession.`setAttribute(Object key, @Nullable Object val)` Sets session attributed.
    `void` | ComputeTaskSession.`setAttributes(Map<?,?> attrs)` Sets task attributes.
    `protected abstract Collection<? extends ComputeJob>` | ComputeTaskSplitAdapter.`split(int gridSize, T arg)` This is a simplified version of `ComputeTask.map(List, Object)` method.

  - ### Uses of IgniteException in org.apache.ignite.compute.gridify

    Subclasses of IgniteException in org.apache.ignite.compute.gridify
    Modifier and Type | Class and Description
    --- | ---
    `class` | `GridifyRuntimeException` This defines gridify exception.

  - ### Uses of IgniteException in org.apache.ignite.lang

    Subclasses of IgniteException in org.apache.ignite.lang
    Modifier and Type | Class and Description
    --- | ---
    `class` | `IgniteFutureCancelledException` Future computation cannot be retrieved because it was cancelled.
    `class` | `IgniteFutureTimeoutException` Future computation completion is timed out.

    Methods in org.apache.ignite.lang that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | IgniteFuture.`cancel()` Cancels this future.
    `V` | IgniteFuture.`get()` Synchronously waits for completion of the computation and returns computation result.
    `V` | IgniteFuture.`get(long timeout)` Synchronously waits for completion of the computation for up to the timeout specified and returns computation result.
    `V` | IgniteFuture.`get(long timeout, TimeUnit unit)` Synchronously waits for completion of the computation for up to the timeout specified and returns computation result.

  - ### Uses of IgniteException in org.apache.ignite.lifecycle

    Methods in org.apache.ignite.lifecycle that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | LifecycleBean.`onLifecycleEvent(LifecycleEventType evt)` This method is called when lifecycle event occurs.
    `void` | LifecycleAware.`start()` Starts grid component, called on grid start.
    `void` | LifecycleAware.`stop()` Stops grid component, called on grid shutdown.

  - ### Uses of IgniteException in org.apache.ignite.messaging

    Methods in org.apache.ignite.messaging that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | MessagingListenActor.`respond(@Nullable Object respMsg)` Responds to the original sender node with given message and continues to listen for the new messages.
    `protected void` | MessagingListenActor.`respond(UUID id, @Nullable Object respMsg)` Responds to the provided node with given message and continues to listen for the new messages.
    `protected void` | MessagingListenActor.`stop(@Nullable Object respMsg)` This method sends the response message to the original sender node and instructs underlying implementation to stop receiving new messages and unregister the message listener.

  - ### Uses of IgniteException in org.apache.ignite.ml.math.exceptions

    Subclasses of IgniteException in org.apache.ignite.ml.math.exceptions
    Modifier and Type | Class and Description
    --- | ---
    `class` | `UnsupportedOperationException` Indicate that a specific operation is not supported by the underlying implementation.

  - ### Uses of IgniteException in org.apache.ignite.ml.math.exceptions.datastructures

    Subclasses of IgniteException in org.apache.ignite.ml.math.exceptions.datastructures
    Modifier and Type | Class and Description
    --- | ---
    `class` | `EmptyFileException` This exception is used to indicate error with empty file.
    `class` | `FileParsingException` This exception is used to indicate error with non-parsed data in specific row by given file path.
    `class` | `NoLabelVectorException` This exception is used to indicate error with non-existing Labeled Vector in the given Labeled Dataset.

  - ### Uses of IgniteException in org.apache.ignite.ml.math.exceptions.math

    Subclasses of IgniteException in org.apache.ignite.ml.math.exceptions.math
    Modifier and Type | Class and Description
    --- | ---
    `class` | `CardinalityException` Indicates a cardinality mismatch in matrix or vector operations.
    `class` | `ColumnIndexException` This exception is used to indicate any error condition accessing matrix elements by invalid column index.
    `class` | `IndexException` Indicates an invalid, i.e. out of bound, index on matrix or vector operations.
    `class` | `MathIllegalArgumentException` Base class for all preconditions violation exceptions.
    `class` | `MathRuntimeException` This class is based on the corresponding class from Apache Common Math lib.
    `class` | `NoDataException` This class is based on the corresponding class from Apache Common Math lib.
    `class` | `NonSquareMatrixException` Indicates that given matrix is not a square matrix.
    `class` | `RowIndexException` This exception is used to indicate any error condition accessing matrix elements by invalid row index.
    `class` | `SingularMatrixException` Exception to be thrown when a non-singular matrix is expected.

  - ### Uses of IgniteException in org.apache.ignite.ml.math.exceptions.preprocessing

    Subclasses of IgniteException in org.apache.ignite.ml.math.exceptions.preprocessing
    Modifier and Type | Class and Description
    --- | ---
    `class` | `IllegalFeatureTypeException` Indicates an illegal feature type and value.
    `class` | `IllegalLabelTypeException` Indicates an illegal label type and value.
    `class` | `NonDoubleVectorException` Indicates a vector with non-double data.
    `class` | `UndefinedLabelException` Indicates a LabeledVector with undefined label.
    `class` | `UnknownCategorialValueException` Indicates an unknown categorial feature value for Encoder.

  - ### Uses of IgniteException in org.apache.ignite.ml.sparkmodelparser

    Subclasses of IgniteException in org.apache.ignite.ml.sparkmodelparser
    Modifier and Type | Class and Description
    --- | ---
    `class` | `UnsupportedSparkModelException` Indicates an unsupported Spark Model.

  - ### Uses of IgniteException in org.apache.ignite.mxbean

    Methods in org.apache.ignite.mxbean that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | MetricsMxBean.`configureHistogramMetric(String name, long[] bounds)` Change `HistogramMetric` configuration.
    `void` | MetricsMxBean.`configureHitRateMetric(String name, long rateTimeInterval)` Change `HitRateMetric` configuration.

  - ### Uses of IgniteException in org.apache.ignite.platform.dotnet

    Methods in org.apache.ignite.platform.dotnet that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | PlatformDotNetAffinityFunction.`start()` Starts grid component, called on grid start.
    `void` | PlatformDotNetAffinityFunction.`stop()` Stops grid component, called on grid shutdown.

  - ### Uses of IgniteException in org.apache.ignite.plugin

    Subclasses of IgniteException in org.apache.ignite.plugin
    Modifier and Type | Class and Description
    --- | ---
    `class` | `PluginNotFoundException` Exception thrown if plugin is not found.
    `class` | `PluginValidationException` Plugin validation exception.

  - ### Uses of IgniteException in org.apache.ignite.plugin.extensions.communication

    Methods in org.apache.ignite.plugin.extensions.communication that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | IgniteMessageFactory.`register(short directType, Supplier<Message> supplier)` Register message factory with given direct type.

  - ### Uses of IgniteException in org.apache.ignite.plugin.security

    Subclasses of IgniteException in org.apache.ignite.plugin.security
    Modifier and Type | Class and Description
    --- | ---
    `class` | `SecurityException` Common security exception for the grid.

  - ### Uses of IgniteException in org.apache.ignite.scheduler

    Methods in org.apache.ignite.scheduler that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `R` | SchedulerFuture.`last()` Gets result of the last execution of scheduled task, or `null` if task has not been executed, or has not produced a result yet.
    `long` | SchedulerFuture.`nextExecutionTime()` Gets next execution time of scheduled task.
    `long[]` | SchedulerFuture.`nextExecutionTimes(int cnt, long start)` Gets an array of the next execution times after passed `start` timestamp.

  - ### Uses of IgniteException in org.apache.ignite.services

    Subclasses of IgniteException in org.apache.ignite.services
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ServiceDeploymentException` Exception indicating service deployment failure.

  - ### Uses of IgniteException in org.apache.ignite.spi

    Subclasses of IgniteException in org.apache.ignite.spi
    Modifier and Type | Class and Description
    --- | ---
    `class` | `IgniteSpiException` Exception thrown by SPI implementations.
    `class` | `IgniteSpiMultiException` Grid SPI exception which may contain more than one failure.
    `class` | `IgniteSpiVersionCheckException` Grid SPI exception for version check failure.

    Methods in org.apache.ignite.spi that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `SecuritySubject` | IgniteSpiContext.`authenticatedSubject(UUID subjId)` Gets security subject based on subject ID.
    `Collection<SecuritySubject>` | IgniteSpiContext.`authenticatedSubjects()` Gets collection of authenticated subjects together with their permissions.

  - ### Uses of IgniteException in org.apache.ignite.spi.communication.tcp

    Method parameters in org.apache.ignite.spi.communication.tcp with type arguments of type IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | TcpCommunicationSpi.`sendMessage(ClusterNode node, Message msg, IgniteInClosure<IgniteException> ackC)` Sends given message to destination node.

  - ### Uses of IgniteException in org.apache.ignite.spi.discovery

    Methods in org.apache.ignite.spi.discovery that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `org.apache.ignite.internal.processors.security.SecurityContext` | DiscoverySpiNodeAuthenticator.`authenticateNode(ClusterNode node, SecurityCredentials cred)` Security credentials.
    `void` | DiscoverySpi.`sendCustomEvent(DiscoverySpiCustomMessage msg)` Sends custom message across the ring.

  - ### Uses of IgniteException in org.apache.ignite.spi.discovery.tcp

    Methods in org.apache.ignite.spi.discovery.tcp that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | TcpDiscoverySpi.`sendCustomEvent(DiscoverySpiCustomMessage msg)` Sends custom message across the ring.

  - ### Uses of IgniteException in org.apache.ignite.spi.discovery.tcp.ipfinder.s3.encrypt

    Methods in org.apache.ignite.spi.discovery.tcp.ipfinder.s3.encrypt that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | SymmetricKeyEncryptionService.`init()` For initialization operations.
    `void` | AsymmetricKeyEncryptionService.`init()` For initialization operations.

  - ### Uses of IgniteException in org.apache.ignite.spi.encryption

    Methods in org.apache.ignite.spi.encryption that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `Serializable` | EncryptionSpi.`create()` Creates new key for an encryption/decryption of cache persistent data: pages, WAL records.

  - ### Uses of IgniteException in org.apache.ignite.spi.encryption.keystore

    Methods in org.apache.ignite.spi.encryption.keystore that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `KeystoreEncryptionKey` | KeystoreEncryptionSpi.`create()` Creates new key for an encryption/decryption of cache persistent data: pages, WAL records.

  - ### Uses of IgniteException in org.apache.ignite.spi.encryption.noop

    Methods in org.apache.ignite.spi.encryption.noop that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `Serializable` | NoopEncryptionSpi.`create()` Creates new key for an encryption/decryption of cache persistent data: pages, WAL records.

  - ### Uses of IgniteException in org.apache.ignite.spi.failover

    Methods in org.apache.ignite.spi.failover that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `ClusterNode` | FailoverContext.`getBalancedNode(List<ClusterNode> top)` Gets the next balanced node for failed job.

  - ### Uses of IgniteException in org.apache.ignite.spi.loadbalancing

    Methods in org.apache.ignite.spi.loadbalancing that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `ClusterNode` | LoadBalancingSpi.`getBalancedNode(ComputeTaskSession ses, List<ClusterNode> top, ComputeJob job)` Gets balanced node for specified job within given task session.

  - ### Uses of IgniteException in org.apache.ignite.spi.tracing

    Methods in org.apache.ignite.spi.tracing that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `default @NotNull TracingConfigurationParameters` | TracingConfigurationManager.`get(@NotNull TracingConfigurationCoordinates coordinates)` Get the most specific tracing parameters for the specified tracing coordinates (scope, label, etc.).
    `@NotNull Map<TracingConfigurationCoordinates,TracingConfigurationParameters>` | TracingConfigurationManager.`getAll(@Nullable Scope scope)` List all pairs of tracing configuration coordinates and tracing configuration parameters or list all pairs of tracing configuration and parameters for the specific scope.
    `void` | TracingConfigurationManager.`reset(@NotNull TracingConfigurationCoordinates coordinates)` Reset tracing configuration for the specific tracing coordinates (scope, label, etc.) to default values.
    `void` | TracingConfigurationManager.`resetAll(@Nullable Scope scope)` Reset tracing configuration for the specific scope, or all tracing configurations if scope not specified.
    `void` | TracingConfigurationManager.`set(@NotNull TracingConfigurationCoordinates coordinates, @NotNull TracingConfigurationParameters parameters)` Set new tracing configuration for the specific tracing coordinates (scope, label, etc.).

  - ### Uses of IgniteException in org.apache.ignite.stream

    Methods in org.apache.ignite.stream that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | StreamVisitor.`receive(IgniteCache<K,V> cache, Collection<Map.Entry<K,V>> entries)` Updates cache with batch of entries.
    `void` | StreamTransformer.`receive(IgniteCache<K,V> cache, Collection<Map.Entry<K,V>> entries)` Updates cache with batch of entries.
    `void` | StreamReceiver.`receive(IgniteCache<K,V> cache, Collection<Map.Entry<K,V>> entries)` Updates cache with batch of entries.

  - ### Uses of IgniteException in org.apache.ignite.stream.camel

    Methods in org.apache.ignite.stream.camel that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | CamelStreamer.`start()` Starts the streamer.
    `void` | CamelStreamer.`stop()` Stops the streamer.

  - ### Uses of IgniteException in org.apache.ignite.stream.jms11

    Methods in org.apache.ignite.stream.jms11 that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | JmsStreamer.`start()` Starts streamer.
    `void` | JmsStreamer.`stop()` Stops streamer.

  - ### Uses of IgniteException in org.apache.ignite.stream.mqtt

    Methods in org.apache.ignite.stream.mqtt that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | MqttStreamer.`start()` Starts streamer.
    `void` | MqttStreamer.`stop()` Stops streamer.

  - ### Uses of IgniteException in org.apache.ignite.stream.storm

    Methods in org.apache.ignite.stream.storm that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | StormStreamer.`start()` Starts streamer.
    `void` | StormStreamer.`stop()` Stops streamer.

  - ### Uses of IgniteException in org.apache.ignite.transactions

    Subclasses of IgniteException in org.apache.ignite.transactions
    Modifier and Type | Class and Description
    --- | ---
    `class` | `TransactionAlreadyCompletedException` Exception thrown whenever Mvcc transaction has been finished before operation finished.
    `class` | `TransactionDeadlockException` Transaction deadlock exception.
    `class` | `TransactionDuplicateKeyException` Exception thrown whenever transaction tries to inserts entry with same mvcc version more than once.
    `class` | `TransactionException` Base class for all transaction related exceptions.
    `class` | `TransactionHeuristicException` Exception thrown whenever grid transaction enters an unknown state.
    `class` | `TransactionMixedModeException` Exception thrown whenever transaction spans over MVCC and non-MVCC caches.
    `class` | `TransactionOptimisticException` Exception thrown whenever grid transactions fail optimistically.
    `class` | `TransactionRollbackException` Exception thrown whenever grid transactions has been automatically rolled back.
    `class` | `TransactionSerializationException` Exception thrown whenever transaction can't be serialized due to write conflict.
    `class` | `TransactionTimeoutException` Exception thrown whenever transactions time out.
    `class` | `TransactionUnsupportedConcurrencyException` Exception thrown whenever transaction concurrency level is not supported.

    Methods in org.apache.ignite.transactions that throw IgniteException
    Modifier and Type | Method and Description
    --- | ---
    `void` | Transaction.`close()` Ends the transaction.
    `void` | Transaction.`commit()` Commits this transaction by initiating `two-phase-commit` process.
    `IgniteFuture<Void>` | Transaction.`commitAsync()` Asynchronously commits this transaction by initiating `two-phase-commit` process.
    `void` | Transaction.`resume()` Resume a transaction if it was previously suspended.
    `void` | Transaction.`rollback()` Rolls back this transaction.
    `IgniteFuture<Void>` | Transaction.`rollbackAsync()` Asynchronously rolls back this transaction.
    `void` | Transaction.`suspend()` Suspends a transaction.

2020 Copyright © Apache Software Foundation
| Follow @ApacheIgnite
Ignite Database and Caching Platform | : ver. 2.9.0
Release Date | : October 15 2020