public class GridCacheProxyImpl<K,V> extends Object implements IgniteInternalCache<K,V>, Externalizable
Constructor and Description |
---|
GridCacheProxyImpl()
Empty constructor required for
Externalizable . |
GridCacheProxyImpl(GridCacheContext<K,V> ctx,
IgniteInternalCache<K,V> delegate,
CacheOperationContext opCtx) |
Modifier and Type | Method and Description |
---|---|
Affinity<K> |
affinity()
Gets affinity service to provide information about data partitioning
and distribution.
|
<K1,V1> IgniteInternalCache<K1,V1> |
cache()
Gets base cache for this projection.
|
void |
clear()
Clears cache on all nodes that store it's data.
|
void |
clear(K key)
Clears key on all nodes that store it's data.
|
void |
clearAll(Set<? extends K> keys)
Clears keys on all nodes that store it's data.
|
IgniteInternalFuture<?> |
clearAllAsync(Set<? extends K> keys) |
IgniteInternalFuture<?> |
clearAsync() |
IgniteInternalFuture<?> |
clearAsync(K key) |
void |
clearLocally(boolean srv,
boolean near,
boolean readers)
Clears all entries from this cache only if the entry is not
currently locked or participating in a transaction.
|
boolean |
clearLocally(K key)
Clears an entry from this cache and swap storage only if the entry
is not currently locked, and is not participating in a transaction.
|
void |
clearLocallyAll(Set<? extends K> keys,
boolean srv,
boolean near,
boolean readers)
Clears entries from this cache and swap storage only if the entry
is not currently locked, and is not participating in a transaction.
|
CacheMetrics |
clusterMetrics()
Gets whole cluster metrics (statistics) for this cache.
|
CacheMetrics |
clusterMetrics(ClusterGroup grp)
Gets cluster group metrics (statistics) for this cache.
|
CacheMetricsMXBean |
clusterMxBean()
Gets whole cluster metrics (statistics) for this cache.
|
CacheConfiguration |
configuration()
Gets configuration bean for this cache.
|
boolean |
containsKey(K key) |
IgniteInternalFuture<Boolean> |
containsKeyAsync(K key) |
boolean |
containsKeys(Collection<? extends K> keys) |
IgniteInternalFuture<Boolean> |
containsKeysAsync(Collection<? extends K> keys) |
GridCacheContext<K,V> |
context() |
IgniteInternalCache<K,V> |
delegate() |
Set<javax.cache.Cache.Entry<K,V>> |
entrySet()
Gets set of all entries cached on this node.
|
Set<javax.cache.Cache.Entry<K,V>> |
entrySet(int part)
Gets set containing cache entries that belong to provided partition or
null
if partition is not found locally. |
Set<javax.cache.Cache.Entry<K,V>> |
entrySetx(CacheEntryPredicate... filter)
Gets entry set containing internal entries.
|
boolean |
evict(K key)
Evicts entry associated with given key from cache.
|
void |
evictAll(Collection<? extends K> keys)
Attempts to evict all entries associated with keys.
|
javax.cache.expiry.ExpiryPolicy |
expiry() |
GridCacheProxyImpl<K,V> |
forSubjectId(UUID subjId)
Creates projection for specified subject ID.
|
V |
get(K key)
Retrieves value mapped to the specified key from cache.
|
Map<K,V> |
getAll(Collection<? extends K> keys)
Retrieves values mapped to the specified keys from cache.
|
IgniteInternalFuture<Map<K,V>> |
getAllAsync(Collection<? extends K> keys)
Asynchronously retrieves values mapped to the specified keys from cache.
|
Map<K,V> |
getAllOutTx(Set<? extends K> keys)
Gets values from cache.
|
IgniteInternalFuture<Map<K,V>> |
getAllOutTxAsync(Set<? extends K> keys)
Gets values from cache.
|
V |
getAndPut(K key,
V val)
Stores given key-value pair in cache.
|
IgniteInternalFuture<V> |
getAndPutAsync(K key,
V val)
Asynchronously stores given key-value pair in cache.
|
V |
getAndPutIfAbsent(K key,
V val)
Stores given key-value pair in cache only if cache had no previous mapping for it.
|
IgniteInternalFuture<V> |
getAndPutIfAbsentAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
|
V |
getAndRemove(K key)
Removes given key mapping from cache.
|
IgniteInternalFuture<V> |
getAndRemoveAsync(K key)
Asynchronously removes given key mapping from cache.
|
V |
getAndReplace(K key,
V val)
Stores given key-value pair in cache only if there is a previous mapping for it.
|
IgniteInternalFuture<V> |
getAndReplaceAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
|
IgniteInternalFuture<V> |
getAsync(K key)
Asynchronously retrieves value mapped to the specified key from cache.
|
Collection<CacheEntry<K,V>> |
getEntries(Collection<? extends K> keys)
Retrieves values mapped to the specified keys from cache.
|
IgniteInternalFuture<Collection<CacheEntry<K,V>>> |
getEntriesAsync(Collection<? extends K> keys)
Asynchronously retrieves values mapped to the specified keys from cache.
|
CacheEntry<K,V> |
getEntry(K key)
Retrieves value mapped to the specified key from cache.
|
IgniteInternalFuture<CacheEntry<K,V>> |
getEntryAsync(K key)
Asynchronously retrieves value mapped to the specified key from cache.
|
V |
getForcePrimary(K key)
Gets value from cache.
|
IgniteInternalFuture<V> |
getForcePrimaryAsync(K key)
Asynchronously gets value from cache.
|
V |
getTopologySafe(K key)
Gets value without waiting for toplogy changes.
|
long |
igfsDataSpaceUsed()
Get current amount of used IGFS space in bytes.
|
<T> javax.cache.processor.EntryProcessorResult<T> |
invoke(AffinityTopologyVersion topVer,
K key,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<T> javax.cache.processor.EntryProcessorResult<T> |
invoke(K key,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<T> Map<K,javax.cache.processor.EntryProcessorResult<T>> |
invokeAll(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
Object... args) |
<T> Map<K,javax.cache.processor.EntryProcessorResult<T>> |
invokeAll(Set<? extends K> keys,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
Object... args) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
invokeAllAsync(Set<? extends K> keys,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>> |
invokeAsync(K key,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
boolean |
isEmpty()
Returns
true if this map contains no key-value mappings. |
boolean |
isIgfsDataCache()
Checks whether this cache is IGFS data cache.
|
boolean |
isLocked(K key)
Checks if any node owns a lock for this key.
|
boolean |
isLockedByThread(K key)
Checks if current thread owns a lock on this key.
|
boolean |
isMongoDataCache()
Checks whether this cache is Mongo data cache.
|
boolean |
isMongoMetaCache()
Checks whether this cache is Mongo meta cache.
|
Iterator<javax.cache.Cache.Entry<K,V>> |
iterator() |
<K1,V1> GridCacheProxyImpl<K1,V1> |
keepBinary()
Creates projection that will operate with binary objects.
|
Set<K> |
keySet()
Set of keys cached on this node.
|
Set<K> |
keySetx() |
Iterable<javax.cache.Cache.Entry<K,V>> |
localEntries(CachePeekMode[] peekModes) |
void |
localLoadCache(IgniteBiPredicate<K,V> p,
Object[] args)
Delegates to
CacheStore.loadCache(IgniteBiInClosure, Object...) method
to load state from the underlying persistent storage. |
IgniteInternalFuture<?> |
localLoadCacheAsync(IgniteBiPredicate<K,V> p,
Object[] args)
Asynchronously delegates to
CacheStore.loadCache(IgniteBiInClosure, Object...) method
to reload state from the underlying persistent storage. |
CacheMetrics |
localMetrics()
Gets local metrics (statistics) for this cache.
|
CacheMetricsMXBean |
localMxBean()
Gets local metrics (statistics) for this cache.
|
V |
localPeek(K key,
CachePeekMode[] peekModes,
IgniteCacheExpiryPolicy plc) |
int |
localSize(CachePeekMode[] peekModes) |
long |
localSizeLong(CachePeekMode[] peekModes) |
long |
localSizeLong(int partition,
CachePeekMode[] peekModes) |
boolean |
lock(K key,
long timeout)
Synchronously acquires lock on a cached object with given
key only if the passed in filter (if any) passes.
|
boolean |
lockAll(Collection<? extends K> keys,
long timeout)
All or nothing synchronous lock for passed in keys.
|
IgniteInternalFuture<Boolean> |
lockAllAsync(Collection<? extends K> keys,
long timeout)
All or nothing synchronous lock for passed in keys.
|
IgniteInternalFuture<Boolean> |
lockAsync(K key,
long timeout)
Asynchronously acquires lock on a cached object with given
key only if the passed in filter (if any) passes.
|
Collection<Integer> |
lostPartitions() |
String |
name()
Gets name of this cache (
null for default cache). |
int |
nearSize()
Gets size of near cache key set.
|
long |
offHeapAllocatedSize()
Gets memory size allocated in off-heap.
|
long |
offHeapEntriesCount()
Gets number of cache entries stored in off-heap memory.
|
Set<K> |
primaryKeySet()
Set of keys for which this node is primary.
|
int |
primarySize()
Gets the number of all primary entries cached on this node.
|
long |
primarySizeLong()
Gets the number of all primary entries cached on this node as a long value.
|
boolean |
put(K key,
V val)
Stores given key-value pair in cache.
|
void |
putAll(Map<? extends K,? extends V> m)
Stores given key-value pairs in cache.
|
IgniteInternalFuture<?> |
putAllAsync(Map<? extends K,? extends V> m)
Asynchronously stores given key-value pairs in cache.
|
void |
putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> drMap)
Store DR data.
|
IgniteInternalFuture<?> |
putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)
Store DR data asynchronously.
|
IgniteInternalFuture<Boolean> |
putAsync(K key,
V val)
Stores given key-value pair in cache.
|
boolean |
putIfAbsent(K key,
V val)
Stores given key-value pair in cache only if cache had no previous mapping for it.
|
IgniteInternalFuture<Boolean> |
putIfAbsentAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
|
void |
readExternal(ObjectInput in) |
IgniteInternalFuture<?> |
rebalance()
Forces this cache node to re-balance its partitions.
|
boolean |
remove(K key)
Removes given key mapping from cache.
|
boolean |
remove(K key,
V val)
Removes given key mapping from cache if one exists and value is equal to the passed in value.
|
void |
removeAll()
Removes mappings from cache.
|
void |
removeAll(Collection<? extends K> keys)
Removes given key mappings from cache.
|
IgniteInternalFuture<?> |
removeAllAsync() |
IgniteInternalFuture<?> |
removeAllAsync(Collection<? extends K> keys)
Asynchronously removes given key mappings from cache for entries.
|
void |
removeAllConflict(Map<KeyCacheObject,GridCacheVersion> drMap)
Removes DR data.
|
IgniteInternalFuture<?> |
removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)
Removes DR data asynchronously.
|
IgniteInternalFuture<Boolean> |
removeAsync(K key)
Asynchronously removes given key mapping from cache.
|
IgniteInternalFuture<Boolean> |
removeAsync(K key,
V val)
Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
|
boolean |
replace(K key,
V val)
Stores given key-value pair in cache only if only if there is a previous mapping for it.
|
boolean |
replace(K key,
V oldVal,
V newVal)
Stores given key-value pair in cache only if only if the previous value is equal to the
'oldVal' passed in. |
IgniteInternalFuture<Boolean> |
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> |
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. |
Iterator<javax.cache.Cache.Entry<K,V>> |
scanIterator(boolean keepBinary,
IgniteBiPredicate<Object,Object> p) |
GridCacheProxyImpl<K,V> |
setSkipStore(boolean skipStore) |
int |
size()
Gets the number of all entries cached on this node.
|
int |
size(CachePeekMode[] peekModes) |
IgniteInternalFuture<Integer> |
sizeAsync(CachePeekMode[] peekModes) |
long |
sizeLong()
Gets the number of all entries cached on this node as a long value.
|
long |
sizeLong(CachePeekMode[] peekModes) |
long |
sizeLong(int partition,
CachePeekMode[] peekModes) |
IgniteInternalFuture<Long> |
sizeLongAsync(CachePeekMode[] peekModes) |
IgniteInternalFuture<Long> |
sizeLongAsync(int partition,
CachePeekMode[] peekModes) |
boolean |
skipStore() |
String |
toString() |
GridNearTxLocal |
tx()
Gets transaction started by this thread or
null if this thread does
not have a transaction. |
Transaction |
txStart(TransactionConcurrency concurrency,
TransactionIsolation isolation)
Starts new transaction with the specified concurrency and isolation.
|
Transaction |
txStart(TransactionConcurrency concurrency,
TransactionIsolation isolation,
long timeout,
int txSize)
Starts transaction with specified isolation, concurrency, timeout, invalidation flag,
and number of participating entries.
|
GridNearTxLocal |
txStartEx(TransactionConcurrency concurrency,
TransactionIsolation isolation) |
void |
unlock(K key)
Unlocks given key only if current thread owns the lock.
|
void |
unlockAll(Collection<? extends K> keys)
Unlocks given keys only if current thread owns the locks.
|
Iterable<V> |
values()
Collection of values cached on this node.
|
GridCacheProxyImpl<K,V> |
withExpiryPolicy(javax.cache.expiry.ExpiryPolicy plc) |
IgniteInternalCache<K,V> |
withNoRetries() |
void |
writeExternal(ObjectOutput out) |
public GridCacheProxyImpl()
Externalizable
.public GridCacheProxyImpl(GridCacheContext<K,V> ctx, IgniteInternalCache<K,V> delegate, @Nullable CacheOperationContext opCtx)
ctx
- Context.delegate
- Delegate object.opCtx
- Optional operation context which will be passed to gateway.public GridCacheContext<K,V> context()
context
in interface IgniteInternalCache<K,V>
public IgniteInternalCache<K,V> delegate()
public String name()
null
for default cache).name
in interface IgniteInternalCache<K,V>
public <K1,V1> IgniteInternalCache<K1,V1> cache()
cache
in interface IgniteInternalCache<K,V>
K1
- Cache key type.V1
- Cache value type.public boolean skipStore()
skipStore
in interface IgniteInternalCache<K,V>
public Affinity<K> affinity()
affinity
in interface IgniteInternalCache<K,V>
public CacheMetrics clusterMetrics()
clusterMetrics
in interface IgniteInternalCache<K,V>
public CacheMetrics clusterMetrics(ClusterGroup grp)
clusterMetrics
in interface IgniteInternalCache<K,V>
grp
- Cluster group.public CacheConfiguration configuration()
configuration
in interface IgniteInternalCache<K,V>
public CacheMetrics localMetrics()
localMetrics
in interface IgniteInternalCache<K,V>
public CacheMetricsMXBean clusterMxBean()
clusterMxBean
in interface IgniteInternalCache<K,V>
public CacheMetricsMXBean localMxBean()
localMxBean
in interface IgniteInternalCache<K,V>
public void localLoadCache(IgniteBiPredicate<K,V> p, @Nullable Object[] args) throws IgniteCheckedException
CacheStore.loadCache(IgniteBiInClosure, Object...)
method
to load state from the underlying persistent storage. The loaded values
will then be given to the optionally passed in predicate, and, if the predicate returns
true
, will be stored in cache. If predicate is null
, then
all loaded values will be stored in cache.
Note that this method does not receive keys as a parameter, so it is up to
CacheStore
implementation to provide all the data to be loaded.
This method is not transactional and may end up loading a stale value into cache if another thread has updated the value immediately after it has been loaded. It is mostly useful when pre-loading the cache from underlying data store before start, or for read-only caches.
localLoadCache
in interface IgniteInternalCache<K,V>
p
- Optional predicate (may be null
). If provided, will be used to
filter values to be put into cache.args
- Optional user arguments to be passed into
CacheStore.loadCache(IgniteBiInClosure, Object...)
method.IgniteCheckedException
- If loading failed.public IgniteInternalFuture<?> localLoadCacheAsync(IgniteBiPredicate<K,V> p, @Nullable Object[] args)
CacheStore.loadCache(IgniteBiInClosure, Object...)
method
to reload state from the underlying persistent storage. The reloaded values
will then be given to the optionally passed in predicate, and if the predicate returns
true
, will be stored in cache. If predicate is null
, then
all reloaded values will be stored in cache.
Note that this method does not receive keys as a parameter, so it is up to
CacheStore
implementation to provide all the data to be loaded.
This method is not transactional and may end up loading a stale value into cache if another thread has updated the value immediately after it has been loaded. It is mostly useful when pre-loading the cache from underlying data store before start, or for read-only caches.
localLoadCacheAsync
in interface IgniteInternalCache<K,V>
p
- Optional predicate (may be null
). If provided, will be used to
filter values to be put into cache.args
- Optional user arguments to be passed into
CacheStore.loadCache(IgniteBiInClosure, Object...)
method.public GridCacheProxyImpl<K,V> forSubjectId(UUID subjId)
forSubjectId
in interface IgniteInternalCache<K,V>
subjId
- Client ID.public GridCacheProxyImpl<K,V> setSkipStore(boolean skipStore)
setSkipStore
in interface IgniteInternalCache<K,V>
skipStore
- Skip store flag.public <K1,V1> GridCacheProxyImpl<K1,V1> keepBinary()
Projection returned by this method will force cache not to deserialize binary objects, so keys and values will be returned from cache API methods without changes. Therefore, signature of the projection can contain only following types:
org.gridgain.grid.binary.BinaryObject
for binary classesString
and array of String
sUUID
and array of UUID
sDate
and array of Date
sTimestamp
and array of Timestamp
s
For example, if you use Integer
as a key and Value
class as a value
(which will be stored in binary format), you should acquire following projection
to avoid deserialization:
IgniteInternalCacheprj = cache.keepBinary(); // Value is not deserialized and returned in binary format. GridBinaryObject po = prj.get(1);
Note that this method makes sense only if cache is working in binary mode
(org.apache.ignite.configuration.CacheConfiguration#isBinaryEnabled()
returns true
. If not,
this method is no-op and will return current projection.
keepBinary
in interface IgniteInternalCache<K,V>
public boolean isEmpty()
true
if this map contains no key-value mappings.isEmpty
in interface IgniteInternalCache<K,V>
true
if this map contains no key-value mappings.public boolean containsKey(K key)
containsKey
in interface IgniteInternalCache<K,V>
key
- Key.True
if cache contains mapping for a given key.public boolean containsKeys(Collection<? extends K> keys)
containsKeys
in interface IgniteInternalCache<K,V>
keys
- Keys,True
if cache contains all keys.public IgniteInternalFuture<Boolean> containsKeyAsync(K key)
containsKeyAsync
in interface IgniteInternalCache<K,V>
key
- Key.public IgniteInternalFuture<Boolean> containsKeysAsync(Collection<? extends K> keys)
containsKeysAsync
in interface IgniteInternalCache<K,V>
keys
- Keys to check.@Nullable public V get(K key) throws IgniteCheckedException
null
means entry did not pass the provided filter or cache has no mapping for the
key.
If the value is not present in cache, then it will be looked up from swap storage. If
it's not present in swap, or if swap is disable, and if read-through is allowed, value
will be loaded from CacheStore
persistent storage via
CacheStore#load(Transaction, Object)
method.
get
in interface IgniteInternalCache<K,V>
key
- Key to retrieve the value for.IgniteCheckedException
- If get operation failed.@Nullable public CacheEntry<K,V> getEntry(K key) throws IgniteCheckedException
null
means entry did not pass the provided filter or cache has no mapping for the
key.
If the value is not present in cache, then it will be looked up from swap storage. If
it's not present in swap, or if swap is disable, and if read-through is allowed, value
will be loaded from CacheStore
persistent storage via
CacheStore#load(Transaction, Object)
method.
getEntry
in interface IgniteInternalCache<K,V>
key
- Key to retrieve the value for.IgniteCheckedException
- If get operation failed.public V getTopologySafe(K key) throws IgniteCheckedException
getTopologySafe
in interface IgniteInternalCache<K,V>
key
- Key.IgniteCheckedException
- If failed.public IgniteInternalFuture<V> getAsync(K key)
null
means entry did not pass the provided filter or cache has no mapping for the
key.
If the value is not present in cache, then it will be looked up from swap storage. If
it's not present in swap, or if swap is disabled, and if read-through is allowed, value
will be loaded from CacheStore
persistent storage via
CacheStore#load(Transaction, Object)
method.
getAsync
in interface IgniteInternalCache<K,V>
key
- Key for the value to get.public IgniteInternalFuture<CacheEntry<K,V>> getEntryAsync(K key)
null
means entry did not pass the provided filter or cache has no mapping for the
key.
If the value is not present in cache, then it will be looked up from swap storage. If
it's not present in swap, or if swap is disabled, and if read-through is allowed, value
will be loaded from CacheStore
persistent storage via
CacheStore#load(Transaction, Object)
method.
getEntryAsync
in interface IgniteInternalCache<K,V>
key
- Key for the value to get.public V getForcePrimary(K key) throws IgniteCheckedException
getForcePrimary
in interface IgniteInternalCache<K,V>
key
- Key to get value for.IgniteCheckedException
- If failed.public IgniteInternalFuture<V> getForcePrimaryAsync(K key)
getForcePrimaryAsync
in interface IgniteInternalCache<K,V>
key
- Key to get value for.@Nullable public Map<K,V> getAllOutTx(Set<? extends K> keys) throws IgniteCheckedException
getAllOutTx
in interface IgniteInternalCache<K,V>
keys
- Keys to get values for.IgniteCheckedException
- If failed.@Nullable public IgniteInternalFuture<Map<K,V>> getAllOutTxAsync(Set<? extends K> keys)
getAllOutTxAsync
in interface IgniteInternalCache<K,V>
keys
- Keys to get values for.public boolean isIgfsDataCache()
isIgfsDataCache
in interface IgniteInternalCache<K,V>
True
in case this cache is IGFS data cache.public long igfsDataSpaceUsed()
igfsDataSpaceUsed
in interface IgniteInternalCache<K,V>
public boolean isMongoDataCache()
isMongoDataCache
in interface IgniteInternalCache<K,V>
True
if this cache is mongo data cache.public boolean isMongoMetaCache()
isMongoMetaCache
in interface IgniteInternalCache<K,V>
True
if this cache is mongo meta cache.public Map<K,V> getAll(@Nullable Collection<? extends K> keys) throws IgniteCheckedException
If some value is not present in cache, then it will be looked up from swap storage. If
it's not present in swap, or if swap is disabled, and if read-through is allowed, value
will be loaded from CacheStore
persistent storage via
CacheStore#loadAll(Transaction, Collection, org.apache.ignite.lang.IgniteBiInClosure)
method.
getAll
in interface IgniteInternalCache<K,V>
keys
- Keys to get.IgniteCheckedException
- If get operation failed.public Collection<CacheEntry<K,V>> getEntries(@Nullable Collection<? extends K> keys) throws IgniteCheckedException
If some value is not present in cache, then it will be looked up from swap storage. If
it's not present in swap, or if swap is disabled, and if read-through is allowed, value
will be loaded from CacheStore
persistent storage via
CacheStore#loadAll(Transaction, Collection, org.apache.ignite.lang.IgniteBiInClosure)
method.
getEntries
in interface IgniteInternalCache<K,V>
keys
- Keys to get.IgniteCheckedException
- If get operation failed.public IgniteInternalFuture<Map<K,V>> getAllAsync(@Nullable Collection<? extends K> keys)
If some value is not present in cache, then it will be looked up from swap storage. If
it's not present in swap, or if swap is disabled, and if read-through is allowed, value
will be loaded from CacheStore
persistent storage via
CacheStore#loadAll(Transaction, Collection, org.apache.ignite.lang.IgniteBiInClosure)
method.
getAllAsync
in interface IgniteInternalCache<K,V>
keys
- Key for the value to get.public IgniteInternalFuture<Collection<CacheEntry<K,V>>> getEntriesAsync(@Nullable Collection<? extends K> keys)
If some value is not present in cache, then it will be looked up from swap storage. If
it's not present in swap, or if swap is disabled, and if read-through is allowed, value
will be loaded from CacheStore
persistent storage via
CacheStore#loadAll(Transaction, Collection, org.apache.ignite.lang.IgniteBiInClosure)
method.
getEntriesAsync
in interface IgniteInternalCache<K,V>
keys
- Key for the value to get.@Nullable public V getAndPut(K key, V val) throws IgniteCheckedException
CacheMode.PARTITIONED
or CacheMode.REPLICATED
caches,
the value will be loaded from the primary node, which in its turn may load the value
from the swap storage, and consecutively, if it's not in swap,
from the underlying persistent storage. If value has to be loaded from persistent
storage, CacheStore#load(Transaction, Object)
method will be used.
If the returned value is not needed, method #putx(Object, Object, org.apache.ignite.lang.IgnitePredicate[])
should
always be used instead of this one to avoid the overhead associated with returning of the previous value.
If write-through is enabled, the stored value will be persisted to CacheStore
via CacheStore#put(Transaction, Object, Object)
method.
getAndPut
in interface IgniteInternalCache<K,V>
key
- Key to store in cache.val
- Value to be associated with the given key.null
if entry did not pass the filter, or if there was no mapping for the key in swap
or in persistent storage.IgniteCheckedException
- If put operation failed.public IgniteInternalFuture<V> getAndPutAsync(K key, V val)
CacheMode.REPLICATED
caches, the value will be loaded from swap
and, if it's not there, and read-through is allowed, from the underlying
CacheStore
storage. In case of CacheMode.PARTITIONED
caches,
the value will be loaded from the primary node, which in its turn may load the value
from the swap storage, and consecutively, if it's not in swap and read-through is allowed,
from the underlying persistent storage. If value has to be loaded from persistent
storage, CacheStore#load(Transaction, Object)
method will be used.
If the returned value is not needed, method #putx(Object, Object, org.apache.ignite.lang.IgnitePredicate[])
should
always be used instead of this one to avoid the overhead associated with returning of the previous value.
If write-through is enabled, the stored value will be persisted to CacheStore
via CacheStore#put(Transaction, Object, Object)
method.
getAndPutAsync
in interface IgniteInternalCache<K,V>
key
- Key to store in cache.val
- Value to be associated with the given key.public boolean put(K key, V val) throws IgniteCheckedException
This method will return true
if value is stored in cache and false
otherwise.
Unlike #put(Object, Object, org.apache.ignite.lang.IgnitePredicate[])
method, it does not return previous
value and, therefore, does not have any overhead associated with returning a value. It
should be used whenever return value is not required.
If write-through is enabled, the stored value will be persisted to CacheStore
via CacheStore#put(Transaction, Object, Object)
method.
put
in interface IgniteInternalCache<K,V>
key
- Key to store in cache.val
- Value to be associated with the given key.True
if optional filter passed and value was stored in cache,
false
otherwise. Note that this method will return true
if filter is not
specified.IgniteCheckedException
- If put operation failed.public void putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> drMap) throws IgniteCheckedException
putAllConflict
in interface IgniteInternalCache<K,V>
drMap
- DR map.IgniteCheckedException
- If put operation failed.public IgniteInternalFuture<?> putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap) throws IgniteCheckedException
putAllConflictAsync
in interface IgniteInternalCache<K,V>
drMap
- DR map.IgniteCheckedException
- If put operation failed.public <T> javax.cache.processor.EntryProcessorResult<T> invoke(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args) throws IgniteCheckedException
invoke
in interface IgniteInternalCache<K,V>
key
- Key.entryProcessor
- Entry processor.args
- Arguments.IgniteCheckedException
- If failed.public <T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>> invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)
invokeAsync
in interface IgniteInternalCache<K,V>
key
- Key.entryProcessor
- Entry processor.args
- Arguments.public <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> invokeAll(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args) throws IgniteCheckedException
invokeAll
in interface IgniteInternalCache<K,V>
keys
- Keys.entryProcessor
- Entry processor.args
- Arguments.IgniteCheckedException
- If failed.public <T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)
invokeAllAsync
in interface IgniteInternalCache<K,V>
keys
- Keys.entryProcessor
- Entry processor.args
- Arguments.public <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> invokeAll(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args) throws IgniteCheckedException
invokeAll
in interface IgniteInternalCache<K,V>
map
- Map containing keys and entry processors to be applied to values.args
- Arguments.IgniteCheckedException
- If failed.public <T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)
invokeAllAsync
in interface IgniteInternalCache<K,V>
map
- Map containing keys and entry processors to be applied to values.args
- Arguments.public IgniteInternalFuture<Boolean> putAsync(K key, V val)
This method will return true
if value is stored in cache and false
otherwise.
Unlike #put(Object, Object, org.apache.ignite.lang.IgnitePredicate[])
method, it does not return previous
value and, therefore, does not have any overhead associated with returning of a value. It
should always be used whenever return value is not required.
If write-through is enabled, the stored value will be persisted to CacheStore
via CacheStore#put(Transaction, Object, Object)
method.
putAsync
in interface IgniteInternalCache<K,V>
key
- Key to store in cache.val
- Value to be associated with the given key.true
if optional filter
passed and value was stored in cache, false
otherwise. Note that future will
return true
if filter is not specified.@Nullable public V getAndPutIfAbsent(K key, V val) throws IgniteCheckedException
CacheMode.PARTITIONED
or CacheMode.REPLICATED
caches,
the value will be loaded from the primary node, which in its turn may load the value
from the swap storage, and consecutively, if it's not in swap,
from the underlying persistent storage. If value has to be loaded from persistent
storage, CacheStore#load(Transaction, Object)
method will be used.
If the returned value is not needed, method IgniteInternalCache.putIfAbsent(Object, Object)
should
always be used instead of this one to avoid the overhead associated with returning of the
previous value.
If write-through is enabled, the stored value will be persisted to CacheStore
via CacheStore#put(Transaction, Object, Object)
method.
getAndPutIfAbsent
in interface IgniteInternalCache<K,V>
key
- Key to store in cache.val
- Value to be associated with the given key.IgniteCheckedException
- If put operation failed.public IgniteInternalFuture<V> getAndPutIfAbsentAsync(K key, V val)
CacheMode.PARTITIONED
or CacheMode.REPLICATED
caches,
the value will be loaded from the primary node, which in its turn may load the value
from the swap storage, and consecutively, if it's not in swap,
from the underlying persistent storage. If value has to be loaded from persistent
storage, CacheStore#load(Transaction, Object)
method will be used.
If the returned value is not needed, method IgniteInternalCache.putIfAbsentAsync(Object, Object)
should
always be used instead of this one to avoid the overhead associated with returning of the
previous value.
If write-through is enabled, the stored value will be persisted to CacheStore
via CacheStore#put(Transaction, Object, Object)
method.
getAndPutIfAbsentAsync
in interface IgniteInternalCache<K,V>
key
- Key to store in cache.val
- Value to be associated with the given key.public boolean putIfAbsent(K key, V val) throws IgniteCheckedException
This method will return true
if value is stored in cache and false
otherwise.
Unlike IgniteInternalCache.getAndPutIfAbsent(Object, Object)
method, it does not return previous
value and, therefore, does not have any overhead associated with returning of a value. It
should always be used whenever return value is not required.
If write-through is enabled, the stored value will be persisted to CacheStore
via CacheStore#put(Transaction, Object, Object)
method.
putIfAbsent
in interface IgniteInternalCache<K,V>
key
- Key to store in cache.val
- Value to be associated with the given key.true
if value is stored in cache and false
otherwise.IgniteCheckedException
- If put operation failed.public IgniteInternalFuture<Boolean> putIfAbsentAsync(K key, V val)
This method will return true
if value is stored in cache and false
otherwise.
Unlike IgniteInternalCache.getAndPutIfAbsent(Object, Object)
method, it does not return previous
value and, therefore, does not have any overhead associated with returning of a value. It
should always be used whenever return value is not required.
If write-through is enabled, the stored value will be persisted to CacheStore
via CacheStore#put(Transaction, Object, Object)
method.
putIfAbsentAsync
in interface IgniteInternalCache<K,V>
key
- Key to store in cache.val
- Value to be associated with the given key.@Nullable public V getAndReplace(K key, V val) throws IgniteCheckedException
CacheMode.PARTITIONED
or CacheMode.REPLICATED
caches,
the value will be loaded from the primary node, which in its turn may load the value
from the swap storage, and consecutively, if it's not in swap,
from the underlying persistent storage. If value has to be loaded from persistent
storage, CacheStore#load(Transaction, Object)
method will be used.
If the returned value is not needed, method IgniteInternalCache.replace(Object, Object)
should
always be used instead of this one to avoid the overhead associated with returning of the
previous value.
If write-through is enabled, the stored value will be persisted to CacheStore
via CacheStore#put(Transaction, Object, Object)
method.
getAndReplace
in interface IgniteInternalCache<K,V>
key
- Key to store in cache.val
- Value to be associated with the given key.IgniteCheckedException
- If replace operation failed.public IgniteInternalFuture<V> getAndReplaceAsync(K key, V val)
CacheMode.PARTITIONED
caches, the value will be loaded from the primary node,
which in its turn may load the value from the swap storage, and consecutively, if it's not in swap,
from the underlying persistent storage. If value has to be loaded from persistent
storage, CacheStore#load(Transaction, Object)
method will be used.
If the returned value is not needed, method IgniteInternalCache.replace(Object, Object)
should
always be used instead of this one to avoid the overhead associated with returning of the
previous value.
If write-through is enabled, the stored value will be persisted to CacheStore
via CacheStore#put(Transaction, Object, Object)
method.
getAndReplaceAsync
in interface IgniteInternalCache<K,V>
key
- Key to store in cache.val
- Value to be associated with the given key.public boolean replace(K key, V val) throws IgniteCheckedException
This method will return true
if value is stored in cache and false
otherwise.
Unlike IgniteInternalCache.getAndReplace(Object, Object)
method, it does not return previous
value and, therefore, does not have any overhead associated with returning of a value. It
should always be used whenever return value is not required.
If write-through is enabled, the stored value will be persisted to CacheStore
via CacheStore#put(Transaction, Object, Object)
method.
replace
in interface IgniteInternalCache<K,V>
key
- Key to store in cache.val
- Value to be associated with the given key.True
if replace happened, false
otherwise.IgniteCheckedException
- If replace operation failed.public IgniteInternalFuture<Boolean> replaceAsync(K key, V val)
This method will return true
if value is stored in cache and false
otherwise.
Unlike IgniteInternalCache.getAndReplaceAsync(Object, Object)
method, it does not return previous
value and, therefore, does not have any overhead associated with returning of a value. It
should always be used whenever return value is not required.
If write-through is enabled, the stored value will be persisted to CacheStore
via CacheStore#put(Transaction, Object, Object)
method.
replaceAsync
in interface IgniteInternalCache<K,V>
key
- Key to store in cache.val
- Value to be associated with the given key.public boolean replace(K key, V oldVal, V newVal) throws IgniteCheckedException
'oldVal'
passed in.
This method will return true
if value is stored in cache and false
otherwise.
If write-through is enabled, the stored value will be persisted to CacheStore
via CacheStore#put(Transaction, Object, Object)
method.
replace
in interface IgniteInternalCache<K,V>
key
- Key to store in cache.oldVal
- Old value to match.newVal
- Value to be associated with the given key.True
if replace happened, false
otherwise.IgniteCheckedException
- If replace operation failed.public IgniteInternalFuture<Boolean> replaceAsync(K key, V oldVal, V newVal)
'oldVal'
passed in.
This method will return true
if value is stored in cache and false
otherwise.
If write-through is enabled, the stored value will be persisted to CacheStore
via CacheStore#put(Transaction, Object, Object)
method.
replaceAsync
in interface IgniteInternalCache<K,V>
key
- Key to store in cache.oldVal
- Old value to match.newVal
- Value to be associated with the given key.public void putAll(@Nullable Map<? extends K,? extends V> m) throws IgniteCheckedException
If write-through is enabled, the stored values will be persisted to CacheStore
via CacheStore#putAll(Transaction, Map)
method.
putAll
in interface IgniteInternalCache<K,V>
m
- Key-value pairs to store in cache.IgniteCheckedException
- If put operation failed.public IgniteInternalFuture<?> putAllAsync(@Nullable Map<? extends K,? extends V> m)
If write-through is enabled, the stored values will be persisted to CacheStore
via CacheStore#putAll(Transaction, Map)
method.
putAllAsync
in interface IgniteInternalCache<K,V>
m
- Key-value pairs to store in cache.public Set<K> keySet()
Iterator over this set will not fail if set was concurrently updated by another thread. This means that iterator may or may not return latest keys depending on whether they were added before or after current iterator position.
NOTE: this operation is not distributed and returns only the keys cached on this node.
keySet
in interface IgniteInternalCache<K,V>
public Set<K> keySetx()
keySetx
in interface IgniteInternalCache<K,V>
public Set<K> primaryKeySet()
null
because they were invalidated. You can remove elements from
this set, but you cannot add elements to this set. All removal operation will be
reflected on the cache itself.
Iterator over this set will not fail if set was concurrently updated by another thread. This means that iterator may or may not return latest keys depending on whether they were added before or after current iterator position.
NOTE: this operation is not distributed and returns only the keys cached on this node.
primaryKeySet
in interface IgniteInternalCache<K,V>
public Iterable<V> values()
Iterator over this collection will not fail if collection was concurrently updated by another thread. This means that iterator may or may not return latest values depending on whether they were added before or after current iterator position.
NOTE: this operation is not distributed and returns only the values cached on this node.
values
in interface IgniteInternalCache<K,V>
public Set<javax.cache.Cache.Entry<K,V>> entrySet()
NOTE: this operation is not distributed and returns only the entries cached on this node.
entrySet
in interface IgniteInternalCache<K,V>
public Set<javax.cache.Cache.Entry<K,V>> entrySet(int part)
null
if partition is not found locally.
NOTE: this operation is not distributed and returns only the entries cached on this node.
entrySet
in interface IgniteInternalCache<K,V>
part
- Partition.null
if partition is
not found locally.public Set<javax.cache.Cache.Entry<K,V>> entrySetx(CacheEntryPredicate... filter)
entrySetx
in interface IgniteInternalCache<K,V>
filter
- Filter.public Iterator<javax.cache.Cache.Entry<K,V>> scanIterator(boolean keepBinary, @Nullable IgniteBiPredicate<Object,Object> p) throws IgniteCheckedException
scanIterator
in interface IgniteInternalCache<K,V>
keepBinary
- Keep binary flag.p
- Optional key/value predicate.IgniteCheckedException
- If failed.public GridNearTxLocal txStartEx(TransactionConcurrency concurrency, TransactionIsolation isolation)
txStartEx
in interface IgniteInternalCache<K,V>
concurrency
- Concurrency.isolation
- Isolation.public Transaction txStart(TransactionConcurrency concurrency, TransactionIsolation isolation)
txStart
in interface IgniteInternalCache<K,V>
concurrency
- Concurrency.isolation
- Isolation.public Transaction txStart(TransactionConcurrency concurrency, TransactionIsolation isolation, long timeout, int txSize)
txStart
in interface IgniteInternalCache<K,V>
concurrency
- Concurrency.isolation
- Isolation.timeout
- Timeout.txSize
- Number of entries participating in transaction (may be approximate).public GridNearTxLocal tx()
null
if this thread does
not have a transaction.tx
in interface IgniteInternalCache<K,V>
null
if this thread
does not have a transaction.@Nullable public V localPeek(K key, CachePeekMode[] peekModes, @Nullable IgniteCacheExpiryPolicy plc) throws IgniteCheckedException
localPeek
in interface IgniteInternalCache<K,V>
key
- Key.peekModes
- Peek modes.plc
- Expiry policy if TTL should be updated.IgniteCheckedException
- If failed.public Iterable<javax.cache.Cache.Entry<K,V>> localEntries(CachePeekMode[] peekModes) throws IgniteCheckedException
localEntries
in interface IgniteInternalCache<K,V>
peekModes
- Peek modes.IgniteCheckedException
- If failed.public boolean evict(K key)
evict
in interface IgniteInternalCache<K,V>
key
- Key to evict from cache.True
if entry could be evicted, false
otherwise.public void evictAll(@Nullable Collection<? extends K> keys)
evictAll
in interface IgniteInternalCache<K,V>
keys
- Keys to evict.public void clearLocally(boolean srv, boolean near, boolean readers)
Note that this operation is local as it merely clears entries from local cache. It does not remove entries from remote caches or from underlying persistent storage.
clearLocally
in interface IgniteInternalCache<K,V>
srv
- Whether to clear server cache.near
- Whether to clear near cache.readers
- Whether to clear readers.public void clear() throws IgniteCheckedException
IgniteInternalCache.clearLocally(boolean, boolean, boolean)
method which only
clears local node's cache.
Ignite will make the best attempt to clear caches on all nodes. If some caches could not be cleared, then exception will be thrown.
clear
in interface IgniteInternalCache<K,V>
IgniteCheckedException
- In case of cache could not be cleared on any of the nodes.public IgniteInternalFuture<?> clearAsync()
clearAsync
in interface IgniteInternalCache<K,V>
public IgniteInternalFuture<?> clearAsync(K key)
clearAsync
in interface IgniteInternalCache<K,V>
key
- Key to clear.public IgniteInternalFuture<?> clearAllAsync(Set<? extends K> keys)
clearAllAsync
in interface IgniteInternalCache<K,V>
keys
- Keys to clear.public boolean clearLocally(K key)
Note that this operation is local as it merely clears an entry from local cache. It does not remove entries from remote caches or from underlying persistent storage.
clearLocally
in interface IgniteInternalCache<K,V>
key
- Key to clearLocally.True
if entry was successfully cleared from cache, false
if entry was in use at the time of this method invocation and could not be
cleared.public void clearLocallyAll(Set<? extends K> keys, boolean srv, boolean near, boolean readers)
Note that this operation is local as it merely clears an entry from local cache. It does not remove entries from remote caches or from underlying persistent storage.
clearLocallyAll
in interface IgniteInternalCache<K,V>
keys
- Keys to clearLocally.srv
- Whether to clear server cache.near
- Whether to clear near cache.readers
- Whether to clear readers.public void clear(K key) throws IgniteCheckedException
IgniteInternalCache.clearLocally(Object)
method which only
clears local node's cache.
Ignite will make the best attempt to clear caches on all nodes. If some caches could not be cleared, then exception will be thrown.
clear
in interface IgniteInternalCache<K,V>
key
- Key to clear.IgniteCheckedException
- In case of cache could not be cleared on any of the nodes.public void clearAll(Set<? extends K> keys) throws IgniteCheckedException
IgniteInternalCache.clearLocallyAll(Set, boolean, boolean, boolean)
method which only
clears local node's cache.
Ignite will make the best attempt to clear caches on all nodes. If some caches could not be cleared, then exception will be thrown.
clearAll
in interface IgniteInternalCache<K,V>
keys
- Keys to clear.IgniteCheckedException
- In case of cache could not be cleared on any of the nodes.@Nullable public V getAndRemove(K key) throws IgniteCheckedException
CacheMode.PARTITIONED
or CacheMode.REPLICATED
caches, the value will be loaded from the primary node, which in its turn may load the value
from the disk-based swap storage, and consecutively, if it's not in swap,
from the underlying persistent storage. If value has to be loaded from persistent
storage, CacheStore#load(Transaction, Object)
method will be used.
If the returned value is not needed, method #removex(Object, org.apache.ignite.lang.IgnitePredicate[])
should
always be used instead of this one to avoid the overhead associated with returning of the
previous value.
If write-through is enabled, the value will be removed from CacheStore
via CacheStore#remove(Transaction, Object)
method.
getAndRemove
in interface IgniteInternalCache<K,V>
key
- Key whose mapping is to be removed from cache.null
if there was no value for this key.IgniteCheckedException
- If remove operation failed.public IgniteInternalFuture<V> getAndRemoveAsync(K key)
CacheMode.PARTITIONED
or CacheMode.REPLICATED
caches, the value will be loaded from the primary node, which in its turn may load the value
from the swap storage, and consecutively, if it's not in swap,
from the underlying persistent storage. If value has to be loaded from persistent
storage, CacheStore#load(Transaction, Object)
method will be used.
If the returned value is not needed, method #removex(Object, org.apache.ignite.lang.IgnitePredicate[])
should
always be used instead of this one to avoid the overhead associated with returning of the
previous value.
If write-through is enabled, the value will be removed from CacheStore
via CacheStore#remove(Transaction, Object)
method.
getAndRemoveAsync
in interface IgniteInternalCache<K,V>
key
- Key whose mapping is to be removed from cache.public boolean remove(K key) throws IgniteCheckedException
This method will return true
if remove did occur, which means that all optionally
provided filters have passed and there was something to remove, false
otherwise.
If write-through is enabled, the value will be removed from CacheStore
via CacheStore#remove(Transaction, Object)
method.
remove
in interface IgniteInternalCache<K,V>
key
- Key whose mapping is to be removed from cache.True
if filter passed validation and entry was removed, false
otherwise.
Note that if filter is not specified, this method will return true
.IgniteCheckedException
- If remove failed.public void removeAllConflict(Map<KeyCacheObject,GridCacheVersion> drMap) throws IgniteCheckedException
removeAllConflict
in interface IgniteInternalCache<K,V>
drMap
- DR map.IgniteCheckedException
- If remove failed.public IgniteInternalFuture<?> removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap) throws IgniteCheckedException
removeAllConflictAsync
in interface IgniteInternalCache<K,V>
drMap
- DR map.IgniteCheckedException
- If remove failed.public IgniteInternalFuture<Boolean> removeAsync(K key)
This method will return true
if remove did occur, which means that all optionally
provided filters have passed and there was something to remove, false
otherwise.
If write-through is enabled, the value will be removed from CacheStore
via CacheStore#remove(Transaction, Object)
method.
removeAsync
in interface IgniteInternalCache<K,V>
key
- Key whose mapping is to be removed from cache.true
if optional filters passed validation and remove did occur, false
otherwise.
Note that if filter is not specified, this method will return true
.public boolean remove(K key, V val) throws IgniteCheckedException
If write-through is enabled, the value will be removed from CacheStore
via CacheStore#remove(Transaction, Object)
method.
remove
in interface IgniteInternalCache<K,V>
key
- Key whose mapping is to be removed from cache.val
- Value to match against currently cached value.True
if entry was removed and passed in value matched the cached one,
false
otherwise.IgniteCheckedException
- If remove failed.public IgniteInternalFuture<Boolean> removeAsync(K key, V val)
This method will return true
if remove did occur, which means that all optionally
provided filters have passed and there was something to remove, false
otherwise.
If write-through is enabled, the value will be removed from CacheStore
via CacheStore#remove(Transaction, Object)
method.
removeAsync
in interface IgniteInternalCache<K,V>
key
- Key whose mapping is to be removed from cache.val
- Value to match against currently cached value.true
if currently cached value will match the passed in one.public void removeAll(@Nullable Collection<? extends K> keys) throws IgniteCheckedException
If write-through is enabled, the values will be removed from CacheStore
via IgniteDataStreamer
.
removeAll
in interface IgniteInternalCache<K,V>
keys
- Keys whose mappings are to be removed from cache.IgniteCheckedException
- If remove failed.public IgniteInternalFuture<?> removeAllAsync(@Nullable Collection<? extends K> keys)
If write-through is enabled, the values will be removed from CacheStore
via IgniteDataStreamer
.
removeAllAsync
in interface IgniteInternalCache<K,V>
keys
- Keys whose mappings are to be removed from cache.@Nullable public <T> javax.cache.processor.EntryProcessorResult<T> invoke(AffinityTopologyVersion topVer, K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args) throws IgniteCheckedException
invoke
in interface IgniteInternalCache<K,V>
topVer
- Locked topology version.key
- Key.entryProcessor
- Entry processor.args
- Arguments.IgniteCheckedException
- If failed.public void removeAll() throws IgniteCheckedException
USE WITH CARE - if your cache has many entries then transaction will quickly become very heavy and slow.
If write-through is enabled, the values will be removed from CacheStore
via IgniteDataStreamer
.
removeAll
in interface IgniteInternalCache<K,V>
IgniteCheckedException
- If remove failed.public IgniteInternalFuture<?> removeAllAsync()
removeAllAsync
in interface IgniteInternalCache<K,V>
public boolean lock(K key, long timeout) throws IgniteCheckedException
TransactionConcurrency.PESSIMISTIC
concurrency control for transaction
which will acquire explicit locks for relevant cache operations.lock
in interface IgniteInternalCache<K,V>
key
- Key to lock.timeout
- Timeout in milliseconds to wait for lock to be acquired
('0'
for no expiration), -1
for immediate failure if
lock cannot be acquired immediately).True
if all filters passed and lock was acquired,
false
otherwise.IgniteCheckedException
- If lock acquisition resulted in error.public IgniteInternalFuture<Boolean> lockAsync(K key, long timeout)
TransactionConcurrency.PESSIMISTIC
concurrency control for transaction
which will acquire explicit locks for relevant cache operations.lockAsync
in interface IgniteInternalCache<K,V>
key
- Key to lock.timeout
- Timeout in milliseconds to wait for lock to be acquired
('0'
for no expiration, -1
for immediate failure if
lock cannot be acquired immediately).true
whenever all filters pass and locks are acquired before timeout is expired,
false
otherwise.public boolean lockAll(@Nullable Collection<? extends K> keys, long timeout) throws IgniteCheckedException
TransactionConcurrency.PESSIMISTIC
concurrency control for transaction
which will acquire explicit locks for relevant cache operations.lockAll
in interface IgniteInternalCache<K,V>
keys
- Keys to lock.timeout
- Timeout in milliseconds to wait for lock to be acquired
('0'
for no expiration).True
if all filters passed and locks were acquired before
timeout has expired, false
otherwise.IgniteCheckedException
- If lock acquisition resulted in error.public IgniteInternalFuture<Boolean> lockAllAsync(@Nullable Collection<? extends K> keys, long timeout)
TransactionConcurrency.PESSIMISTIC
concurrency control for transaction
which will acquire explicit locks for relevant cache operations.lockAllAsync
in interface IgniteInternalCache<K,V>
keys
- Keys to lock.timeout
- Timeout in milliseconds to wait for lock to be acquired
('0'
for no expiration).true
if all filters passed and locks were acquired before
timeout has expired, false
otherwise.public void unlock(K key) throws IgniteCheckedException
TransactionConcurrency.PESSIMISTIC
concurrency control for transaction
which will acquire explicit locks for relevant cache operations.unlock
in interface IgniteInternalCache<K,V>
key
- Key to unlock.IgniteCheckedException
- If unlock execution resulted in error.public void unlockAll(@Nullable Collection<? extends K> keys) throws IgniteCheckedException
TransactionConcurrency.PESSIMISTIC
concurrency control for transaction
which will acquire explicit locks for relevant cache operations.unlockAll
in interface IgniteInternalCache<K,V>
keys
- Keys to unlock.IgniteCheckedException
- If unlock execution resulted in error.public boolean isLocked(K key)
This is a local in-VM operation and does not involve any network trips or access to persistent storage in any way.
isLocked
in interface IgniteInternalCache<K,V>
key
- Key to check.True
if lock is owned by some node.public boolean isLockedByThread(K key)
This is a local in-VM operation and does not involve any network trips or access to persistent storage in any way.
isLockedByThread
in interface IgniteInternalCache<K,V>
key
- Key to check.True
if key is locked by current thread.public int size()
IgniteInternalCache
. It is essentially the
size of cache key set and is semantically identical to {Cache.keySet().size()
.
NOTE: this operation is not distributed and returns only the number of entries cached on this node.
size
in interface IgniteInternalCache<K,V>
public long sizeLong()
IgniteInternalCache
. It is essentially the
size of cache key set and is semantically identical to {Cache.keySet().size()
.
NOTE: this operation is not distributed and returns only the number of entries cached on this node.
sizeLong
in interface IgniteInternalCache<K,V>
public int size(CachePeekMode[] peekModes) throws IgniteCheckedException
size
in interface IgniteInternalCache<K,V>
peekModes
- Peek modes.IgniteCheckedException
- If failed.public long sizeLong(CachePeekMode[] peekModes) throws IgniteCheckedException
sizeLong
in interface IgniteInternalCache<K,V>
peekModes
- Peek modes.IgniteCheckedException
- If failed.public long sizeLong(int partition, CachePeekMode[] peekModes) throws IgniteCheckedException
sizeLong
in interface IgniteInternalCache<K,V>
partition
- partitionpeekModes
- Peek modes.IgniteCheckedException
- If failed.public IgniteInternalFuture<Integer> sizeAsync(CachePeekMode[] peekModes)
sizeAsync
in interface IgniteInternalCache<K,V>
peekModes
- Peek modes.public IgniteInternalFuture<Long> sizeLongAsync(CachePeekMode[] peekModes)
sizeLongAsync
in interface IgniteInternalCache<K,V>
peekModes
- Peek modes.public IgniteInternalFuture<Long> sizeLongAsync(int partition, CachePeekMode[] peekModes)
sizeLongAsync
in interface IgniteInternalCache<K,V>
partition
- partitonpeekModes
- Peek modes.public int localSize(CachePeekMode[] peekModes) throws IgniteCheckedException
localSize
in interface IgniteInternalCache<K,V>
peekModes
- Peek modes.IgniteCheckedException
- If failed.public long localSizeLong(CachePeekMode[] peekModes) throws IgniteCheckedException
localSizeLong
in interface IgniteInternalCache<K,V>
peekModes
- Peek modes.IgniteCheckedException
- If failed.public long localSizeLong(int partition, CachePeekMode[] peekModes) throws IgniteCheckedException
localSizeLong
in interface IgniteInternalCache<K,V>
partition
- partition.peekModes
- Peek modes.IgniteCheckedException
- If failed.public int nearSize()
Note that for LOCAL
non-distributed caches this method will always return 0
nearSize
in interface IgniteInternalCache<K,V>
0
if cache is not CacheMode.PARTITIONED
.public int primarySize()
CacheMode.LOCAL
non-distributed
cache mode, this method is identical to IgniteInternalCache.size()
.
For CacheMode.PARTITIONED
and CacheMode.REPLICATED
modes, this method will
return number of primary entries cached on this node (excluding any backups). The complexity of
this method is O(P), where P is the total number of partitions.
NOTE: this operation is not distributed and returns only the number of primary entries cached on this node.
primarySize
in interface IgniteInternalCache<K,V>
public long primarySizeLong()
CacheMode.LOCAL
non-distributed cache mode, this method is identical to IgniteInternalCache.size()
.
For CacheMode.PARTITIONED
and CacheMode.REPLICATED
modes, this method will
return number of primary entries cached on this node (excluding any backups). The complexity of
this method is O(P), where P is the total number of partitions.
NOTE: this operation is not distributed and returns only the number of primary entries cached on this node.
primarySizeLong
in interface IgniteInternalCache<K,V>
public long offHeapEntriesCount()
offHeapEntriesCount
in interface IgniteInternalCache<K,V>
public long offHeapAllocatedSize()
offHeapAllocatedSize
in interface IgniteInternalCache<K,V>
public IgniteInternalFuture<?> rebalance()
CacheConfiguration.getRebalanceDelay()
configuration parameter has non-zero value.
When many nodes are started or stopped almost concurrently, it is more efficient to delay
rebalancing until the node topology is stable to make sure that no redundant re-partitioning
happens.
In case ofCacheMode.PARTITIONED
caches, for better efficiency user should
usually make sure that new nodes get placed on the same place of consistent hash ring as
the left nodes, and that nodes are restarted before
rebalanceDelay
expires. To place nodes
on the same place in consistent hash ring, use
IgniteConfiguration.setConsistentId(Serializable)
to make sure that
a node maps to the same hash ID if re-started.
See CacheConfiguration.getRebalanceDelay()
for more information on how to configure
rebalance re-partition delay.
rebalance
in interface IgniteInternalCache<K,V>
@Nullable public javax.cache.expiry.ExpiryPolicy expiry()
expiry
in interface IgniteInternalCache<K,V>
ExpiryPolicy
associated with this projection.public GridCacheProxyImpl<K,V> withExpiryPolicy(javax.cache.expiry.ExpiryPolicy plc)
withExpiryPolicy
in interface IgniteInternalCache<K,V>
plc
- ExpiryPolicy
to associate with this projection.public IgniteInternalCache<K,V> withNoRetries()
withNoRetries
in interface IgniteInternalCache<K,V>
public Collection<Integer> lostPartitions()
lostPartitions
in interface IgniteInternalCache<K,V>
public void writeExternal(ObjectOutput out) throws IOException
writeExternal
in interface Externalizable
IOException
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
readExternal
in interface Externalizable
IOException
ClassNotFoundException
Follow @ApacheIgnite
Ignite Fabric : ver. 2.0.0 Release Date : April 30 2017