Uses of Class
org.apache.ignite.client.ClientException

Packages that use ClientException

Package	Description
org.apache.ignite	Contains entry-point Ignite & HPC APIs.
org.apache.ignite.client	Contains Ignite Thin Client API classes.
org.apache.ignite.springdata.proxy	Contains classes that provide client-independent access to the Ignite operations required by Spring Data.

Uses of ClientException in org.apache.ignite

Methods in org.apache.ignite that throw ClientException

Modifier and Type	Method and Description
static IgniteClient	Ignition.startClient(ClientConfiguration cfg) Initializes new instance of IgniteClient.

Uses of ClientException in org.apache.ignite.client

Subclasses of ClientException in org.apache.ignite.client

Modifier and Type	Class and Description
class	ClientAuthenticationException Indicates user name or password is invalid.
class	ClientAuthorizationException Indicates user has no permission to perform operation.
class	ClientConnectionException Indicates all the Ignite servers specified in the client configuration are no longer available.
class	ClientFeatureNotSupportedByServerException Feature not supported by server exception.
class	ClientReconnectedException Indicates that previous connection was lost and a new connection established, which can lead to inconsistency of non-atomic operations.

Methods in org.apache.ignite.client that throw ClientException

Modifier and Type	Method and Description
Collection<String>	IgniteClient.cacheNames() Gets the names of all available caches.
IgniteClientFuture<Collection<String>>	IgniteClient.cacheNamesAsync() Gets the names of all available caches.
void	ClientCache.clear() Clears the contents of the cache.
void	ClientCache.clear(K key) Clears entry with specified key from the cache.
void	ClientCache.clearAll(Set<? extends K> keys) Clears entries with specified keys from the cache.
IgniteClientFuture<Void>	ClientCache.clearAllAsync(Set<? extends K> keys) Clears entries with specified keys from the cache asynchronously.
IgniteClientFuture<Void>	ClientCache.clearAsync() Clears the contents of the cache asynchronously.
IgniteClientFuture<Void>	ClientCache.clearAsync(K key) Clears entry with specified key from the cache asynchronously.
void	ClientTransaction.commit() Commits this transaction.
boolean	ClientCache.containsKey(K key) Determines if the ClientCache contains an entry for the specified key.
IgniteClientFuture<Boolean>	ClientCache.containsKeyAsync(K key) Determines if the ClientCache contains an entry for the specified key asynchronously.
boolean	ClientCache.containsKeys(Set<? extends K> keys) Determines if the ClientCache contains entries for the specified keys.
IgniteClientFuture<Boolean>	ClientCache.containsKeysAsync(Set<? extends K> keys) Determines if the ClientCache contains entries for the specified keys asynchronously.
<K,V> ClientCache<K,V>	IgniteClient.createCache(ClientCacheConfiguration cfg) Creates a cache with the specified configuration.
<K,V> ClientCache<K,V>	IgniteClient.createCache(String name) Creates a cache with a default configuration.
<K,V> IgniteClientFuture<ClientCache<K,V>>	IgniteClient.createCacheAsync(ClientCacheConfiguration cfg) Creates a cache with the specified configuration.
<K,V> IgniteClientFuture<ClientCache<K,V>>	IgniteClient.createCacheAsync(String name) Creates a cache with a default configuration.
void	IgniteClient.destroyCache(String name) Destroys the cache with the given name.
IgniteClientFuture<Void>	IgniteClient.destroyCacheAsync(String name) Destroys the cache with the given name.
boolean	ClientCluster.disableWal(String cacheName) Disables write-ahead logging for specified cache.
boolean	ClientCluster.enableWal(String cacheName) Enables write-ahead logging for specified cache.
<T,R> R	ClientCompute.execute(String taskName, T arg) Executes given task within the cluster group.
<T,R> Future<R>	ClientCompute.executeAsync(String taskName, T arg) Deprecated. Use ClientCompute.executeAsync2(String, Object) instead. This method calls ClientCompute.executeAsync2(String, Object) internally, but returns a more limited Future interface.
<T,R> IgniteClientFuture<R>	ClientCompute.executeAsync2(String taskName, T arg) Executes given task asynchronously within the cluster group.
V	ClientCache.get(K key) Gets an entry from the cache.
Map<K,V>	ClientCache.getAll(Set<? extends K> keys) Gets a collection of entries from the ClientCache, returning them as Map of the values associated with the set of keys requested.
IgniteClientFuture<Map<K,V>>	ClientCache.getAllAsync(Set<? extends K> keys) Gets a collection of entries from the ClientCache, returning them as Map of the values associated with the set of keys requested.
V	ClientCache.getAndPut(K key, V val) Associates the specified value with the specified key in this cache, returning an existing value if one existed.
IgniteClientFuture<V>	ClientCache.getAndPutAsync(K key, V val) Associates the specified value with the specified key in this cache, returning an existing value if one existed.
V	ClientCache.getAndPutIfAbsent(K key, V val) Atomically associates the specified key with the given value if it is not already associated with a value.
IgniteClientFuture<V>	ClientCache.getAndPutIfAbsentAsync(K key, V val) Atomically associates the specified key with the given value if it is not already associated with a value.
V	ClientCache.getAndRemove(K key) Atomically removes the entry for a key only if currently mapped to some value.
IgniteClientFuture<V>	ClientCache.getAndRemoveAsync(K key) Atomically removes the entry for a key only if currently mapped to some value.
V	ClientCache.getAndReplace(K key, V val) Atomically replaces the value for a given key if and only if there is a value currently mapped by the key.
IgniteClientFuture<V>	ClientCache.getAndReplaceAsync(K key, V val) Atomically replaces the value for a given key if and only if there is a value currently mapped by the key.
ClientCacheConfiguration	ClientCache.getConfiguration()
IgniteClientFuture<ClientCacheConfiguration>	ClientCache.getConfigurationAsync() Gets the cache configuration asynchronously.
<K,V> ClientCache<K,V>	IgniteClient.getOrCreateCache(ClientCacheConfiguration cfg) Gets the existing cache or creates a new cache if it does not exist.
<K,V> ClientCache<K,V>	IgniteClient.getOrCreateCache(String name) Gets the existing cache or creates a new cache with default configuration if it does not exist.
<K,V> IgniteClientFuture<ClientCache<K,V>>	IgniteClient.getOrCreateCacheAsync(ClientCacheConfiguration cfg) Gets the existing cache or creates a new cache if it does not exist.
<K,V> IgniteClientFuture<ClientCache<K,V>>	IgniteClient.getOrCreateCacheAsync(String name) Gets the existing cache or creates a new cache with default configuration if it does not exist.
void	ClientCache.put(K key, V val) Associates the specified value with the specified key in the cache.
void	ClientCache.putAll(Map<? extends K,? extends V> map) Copies all of the entries from the specified map to the ClientCache.
IgniteClientFuture<Void>	ClientCache.putAllAsync(Map<? extends K,? extends V> map) Copies all of the entries from the specified map to the ClientCache.
IgniteClientFuture<Void>	ClientCache.putAsync(K key, V val) Associates the specified value with the specified key in the cache asynchronously.
boolean	ClientCache.putIfAbsent(K key, V val) Atomically associates the specified key with the given value if it is not already associated with a value.
IgniteClientFuture<Boolean>	ClientCache.putIfAbsentAsync(K key, V val) Atomically associates the specified key with the given value if it is not already associated with a value.
boolean	ClientCache.remove(K key) Removes the mapping for a key from this cache if it is present.
boolean	ClientCache.remove(K key, V oldVal) Atomically removes the mapping for a key only if currently mapped to the given value.
void	ClientCache.removeAll() Removes all of the mappings from this cache.
void	ClientCache.removeAll(Set<? extends K> keys) Removes entries for the specified keys.
IgniteClientFuture<Void>	ClientCache.removeAllAsync() Removes all of the mappings from this cache.
IgniteClientFuture<Void>	ClientCache.removeAllAsync(Set<? extends K> keys) Removes entries for the specified keys.
IgniteClientFuture<Boolean>	ClientCache.removeAsync(K key) Removes the mapping for a key from this cache if it is present.
IgniteClientFuture<Boolean>	ClientCache.removeAsync(K key, V oldVal) Atomically removes the mapping for a key only if currently mapped to the given value.
boolean	ClientCache.replace(K key, V val) Atomically replaces the entry for a key only if currently mapped to some value.
boolean	ClientCache.replace(K key, V oldVal, V newVal) Atomically replaces the entry for a key only if currently mapped to a given value.
IgniteClientFuture<Boolean>	ClientCache.replaceAsync(K key, V val) Atomically replaces the entry for a key only if currently mapped to some value.
IgniteClientFuture<Boolean>	ClientCache.replaceAsync(K key, V oldVal, V newVal) Atomically replaces the entry for a key only if currently mapped to a given value.
void	ClientTransaction.rollback() Rolls back this transaction.
int	ClientCache.size(CachePeekMode... peekModes) Gets the number of all entries cached across all nodes.
IgniteClientFuture<Integer>	ClientCache.sizeAsync(CachePeekMode... peekModes) Gets the number of all entries cached across all nodes.
void	ClientCluster.state(ClusterState newState) Changes current cluster state to given newState cluster state.
ClientTransaction	ClientTransactions.txStart() Starts a new transaction with the default isolation level, concurrency and timeout.
ClientTransaction	ClientTransactions.txStart(TransactionConcurrency concurrency, TransactionIsolation isolation) Starts a new transaction with the specified concurrency and isolation.
ClientTransaction	ClientTransactions.txStart(TransactionConcurrency concurrency, TransactionIsolation isolation, long timeout) Starts a new transaction with the specified isolation, concurrency and timeout.
ClientTransactions	ClientTransactions.withLabel(String lb) Returns instance of ClientTransactions to mark each new transaction with a specified label.

Uses of ClientException in org.apache.ignite.springdata.proxy

Methods in org.apache.ignite.springdata.proxy that throw ClientException

Modifier and Type	Method and Description
void	IgniteCacheClientProxy.clear() Clears the contents of the cache.
void	IgniteCacheProxyImpl.clear() Clears the contents of the cache.
V	IgniteCacheClientProxy.get(K key) Gets an entry from the cache.
V	IgniteCacheProxyImpl.get(K key) Gets an entry from the cache.
Map<K,V>	IgniteCacheClientProxy.getAll(Set<? extends K> keys) Gets a collection of entries from the Ignite cache, returning them as Map of the values associated with the set of keys requested.
Map<K,V>	IgniteCacheProxyImpl.getAll(Set<? extends K> keys) Gets a collection of entries from the Ignite cache, returning them as Map of the values associated with the set of keys requested.
void	IgniteCacheClientProxy.put(K key, V val) Associates the specified value with the specified key in the cache.
void	IgniteCacheProxyImpl.put(K key, V val) Associates the specified value with the specified key in the cache.
void	IgniteCacheClientProxy.putAll(Map<? extends K,? extends V> map) Copies all of the entries from the specified map to the Ignite cache.
void	IgniteCacheProxyImpl.putAll(Map<? extends K,? extends V> map) Copies all of the entries from the specified map to the Ignite cache.
boolean	IgniteCacheClientProxy.remove(K key) Removes the mapping for a key from this cache if it is present.
boolean	IgniteCacheProxyImpl.remove(K key) Removes the mapping for a key from this cache if it is present.
void	IgniteCacheClientProxy.removeAll(Set<? extends K> keys) Removes entries for the specified keys.
void	IgniteCacheProxyImpl.removeAll(Set<? extends K> keys) Removes entries for the specified keys.
int	IgniteCacheClientProxy.size(CachePeekMode... peekModes) Gets the number of all entries cached across all nodes.
int	IgniteCacheProxyImpl.size(CachePeekMode... peekModes) Gets the number of all entries cached across all nodes.