Uses of Interface
org.apache.ignite.internal.processors.cache.KeyCacheObject

Packages that use KeyCacheObject

Package	Description
org.apache.ignite.internal.processors.cache
org.apache.ignite.internal.processors.cache.datastructures
org.apache.ignite.internal.processors.cache.distributed
org.apache.ignite.internal.processors.cache.distributed.dht
org.apache.ignite.internal.processors.cache.distributed.dht.atomic
org.apache.ignite.internal.processors.cache.distributed.dht.colocated
org.apache.ignite.internal.processors.cache.distributed.dht.preloader
org.apache.ignite.internal.processors.cache.distributed.near
org.apache.ignite.internal.processors.cache.dr
org.apache.ignite.internal.processors.cache.dr.os
org.apache.ignite.internal.processors.cache.local
org.apache.ignite.internal.processors.cache.local.atomic
org.apache.ignite.internal.processors.cache.query.continuous
org.apache.ignite.internal.processors.cache.transactions
org.apache.ignite.internal.processors.cache.version
org.apache.ignite.internal.processors.cacheobject	Cache object processor.
org.apache.ignite.internal.processors.datastreamer	Data streamer processor.
org.apache.ignite.internal.processors.dr	Data center replication processor.

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache

Classes in org.apache.ignite.internal.processors.cache that implement KeyCacheObject

Modifier and Type	Class and Description
class	KeyCacheObjectImpl

Fields in org.apache.ignite.internal.processors.cache declared as KeyCacheObject

Modifier and Type	Field and Description
protected KeyCacheObject	GridCacheMapEntry.key Key.
protected KeyCacheObject	CacheLazyEntry.keyObj Key cache object.

Methods in org.apache.ignite.internal.processors.cache that return KeyCacheObject

Modifier and Type	Method and Description
KeyCacheObject	CacheEvictionEntry.key()
KeyCacheObject	GridCacheEntryEx.key()
KeyCacheObject	GridCacheMapEntry.key()
KeyCacheObject	GridCacheBatchSwapEntry.key()
KeyCacheObject	CacheInvokeDirectResult.key()
KeyCacheObject	GridCacheMvccCandidate.key()
KeyCacheObject	GridCacheEntryInfo.key()
KeyCacheObject	GridCacheContext.toCacheKeyObject(byte[] bytes)
KeyCacheObject	GridCacheContext.toCacheKeyObject(Object obj)

Methods in org.apache.ignite.internal.processors.cache that return types with arguments of type KeyCacheObject

Modifier and Type	Method and Description
Collection<KeyCacheObject>	GridCacheContext.cacheKeysView(Collection<?> keys)
Map<KeyCacheObject,GridCacheVersion>	IgniteCacheExpiryPolicy.entries()
Map<KeyCacheObject,GridCacheVersion>	GridCacheAdapter.CacheExpiryPolicy.entries()
static IgniteClosure<GridCacheEntryEx,KeyCacheObject>	GridCacheUtils.entry2Key()
static IgnitePredicate<KeyCacheObject>	GridCacheUtils.keyHasMeta(GridCacheContext ctx, UUID meta)
Iterator<KeyCacheObject>	GridCacheSwapManager.offHeapKeyIterator(boolean primary, boolean backup, long topVer)
Map<UUID,Collection<IgniteBiTuple<KeyCacheObject,GridCacheVersion>>>	IgniteCacheExpiryPolicy.readers()
Map<UUID,Collection<IgniteBiTuple<KeyCacheObject,GridCacheVersion>>>	GridCacheAdapter.CacheExpiryPolicy.readers()
IgniteInternalFuture<Map<KeyCacheObject,CacheObject>>	GridCacheAdapter.reloadAllAsync0(Collection<KeyCacheObject> keys, boolean ret, boolean skipVals, UUID subjId, String taskName)
Iterator<KeyCacheObject>	GridCacheSwapManager.swapKeyIterator(boolean primary, boolean backup, long topVer)

Methods in org.apache.ignite.internal.processors.cache with parameters of type KeyCacheObject

Modifier and Type	Method and Description
void	GridCacheReturn.addEntryProcessResult(GridCacheContext cctx, KeyCacheObject key, Object key0, Object res, Exception err)
void	GridCacheEventManager.addEvent(int part, KeyCacheObject key, IgniteInternalTx tx, GridCacheMvccCandidate owner, int type, CacheObject newVal, boolean hasNewVal, CacheObject oldVal, boolean hasOldVal, UUID subjId, String cloClsName, String taskName)
void	GridCacheEventManager.addEvent(int part, KeyCacheObject key, UUID evtNodeId, GridCacheMvccCandidate owner, int type, CacheObject newVal, boolean hasNewVal, CacheObject oldVal, boolean hasOldVal, UUID subjId, String cloClsName, String taskName)
void	GridCacheEventManager.addEvent(int part, KeyCacheObject key, UUID nodeId, IgniteInternalTx tx, GridCacheMvccCandidate owner, int type, CacheObject newVal, boolean hasNewVal, CacheObject oldVal, boolean hasOldVal, UUID subjId, String cloClsName, String taskName)
void	GridCacheEventManager.addEvent(int part, KeyCacheObject key, UUID evtNodeId, IgniteUuid xid, Object lockId, int type, CacheObject newVal, boolean hasNewVal, CacheObject oldVal, boolean hasOldVal, UUID subjId, String cloClsName, String taskName)
<K1,V1> void	GridCacheContext.addResult(Map<K1,V1> map, KeyCacheObject key, CacheObject val, boolean skipVals, boolean keepCacheObjects, boolean deserializePortable, boolean cpy)
GridCacheMvccCandidate	GridCacheExplicitLockSpan.candidate(KeyCacheObject key, GridCacheVersion ver) Gets explicit lock candidate for given key.
boolean	GridCacheSwapManager.containsKey(KeyCacheObject key)
GridCacheMapEntry	GridCacheMapEntryFactory.create(GridCacheContext ctx, long topVer, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, long ttl, int hdrId)
GridCacheEntryEx	GridCacheAdapter.entryEx(KeyCacheObject key)
GridCacheEntryEx	GridCacheAdapter.entryEx(KeyCacheObject key, boolean touch)
GridCacheEntryEx	GridCacheAdapter.entryEx(KeyCacheObject key, long topVer)
protected GridCacheEntryEx	GridCacheAdapter.entryExSafe(KeyCacheObject key, long topVer)
GridCacheMvccCandidate	GridCacheMvccManager.explicitLock(KeyCacheObject key, GridCacheVersion ver) Gets explicit lock candidate added by any thread by given key and lock version.
GridCacheMvccCandidate	GridCacheMvccManager.explicitLock(long threadId, KeyCacheObject key) Gets last added explicit lock candidate by thread id and key.
boolean	GridCacheEntryEx.initialValue(KeyCacheObject key, GridCacheSwapEntry unswapped) Sets new value if current version is 0 using swap entry data.
boolean	GridCacheMapEntry.initialValue(KeyCacheObject key, GridCacheSwapEntry unswapped) Sets new value if current version is 0 using swap entry data.
boolean	GridCacheMvccManager.isLockedByThread(KeyCacheObject key, long threadId) Checks if given key is locked by thread with given id or any thread.
void	GridCacheEntryInfo.key(KeyCacheObject key)
Object	GridCacheStoreManager.loadFromStore(IgniteInternalTx tx, KeyCacheObject key) Loads data from persistent store.
void	GridCacheMvccManager.markExplicitOwner(KeyCacheObject key, long threadId) Marks candidates for given thread and given key as owned.
void	GridCacheExplicitLockSpan.markOwned(KeyCacheObject key) Marks all candidates added for given key as owned.
void	GridCacheSwapListener.onEntryUnswapped(int part, KeyCacheObject key, GridCacheSwapEntry e)
void	GridCacheEntryInfoCollectSwapListener.onEntryUnswapped(int part, KeyCacheObject key, GridCacheSwapEntry swapEntry)
protected boolean	GridCacheClearAllRunnable.owns(KeyCacheObject key) Check whether this worker owns particular key.
GridCacheEntryEx	GridCacheAdapter.peekEx(KeyCacheObject key)
GridCacheMapEntry	GridCacheConcurrentMap.putEntry(long topVer, KeyCacheObject key, CacheObject val, long ttl)
GridTriple<GridCacheMapEntry>	GridCacheConcurrentMap.putEntryIfObsoleteOrAbsent(long topVer, KeyCacheObject key, CacheObject val, long ttl, boolean create)
GridCacheSwapEntry	GridCacheSwapManager.read(KeyCacheObject key, boolean readOffheap, boolean readSwap)
protected Object	GridCacheMapEntry.readThrough(IgniteInternalTx tx, KeyCacheObject key, boolean reload, UUID subjId, String taskName)
void	GridCacheSwapManager.remove(KeyCacheObject key)
GridCacheMvccCandidate	GridCacheExplicitLockSpan.removeCandidate(KeyCacheObject key, GridCacheVersion ver) Removes lock by key and optional version.
GridCacheMapEntry	GridCacheConcurrentMap.removeEntryIfObsolete(KeyCacheObject key) Removes and returns the entry associated with the specified key in the HashMap if entry is obsolete.
GridCacheMvccCandidate	GridCacheMvccManager.removeExplicitLock(long threadId, KeyCacheObject key, GridCacheVersion ver) Removes explicit lock for given thread id, key and optional version.
void	GridCacheAdapter.removeIfObsolete(KeyCacheObject key)
void	IgniteCacheExpiryPolicy.ttlUpdated(KeyCacheObject key, GridCacheVersion ver, Collection<UUID> rdrs) Callback for ttl update on entry access.
void	GridCacheAdapter.CacheExpiryPolicy.ttlUpdated(KeyCacheObject key, GridCacheVersion ver, Collection<UUID> rdrs)
IgniteTxKey	GridCacheContext.txKey(KeyCacheObject key)

Method parameters in org.apache.ignite.internal.processors.cache with type arguments of type KeyCacheObject

Modifier and Type	Method and Description
void	GridCacheAdapter.clearLocally(Collection<KeyCacheObject> keys, boolean readers)
IgniteInternalFuture<?>	GridCacheMvccManager.finishKeys(Collection<KeyCacheObject> keys, long topVer)
<K1,V1> IgniteInternalFuture<Map<K1,V1>>	GridCacheAdapter.getAllAsync0(Collection<KeyCacheObject> keys, boolean readThrough, boolean checkTx, UUID subjId, String taskName, boolean deserializePortable, IgniteCacheExpiryPolicy expiry, boolean skipVals, boolean keepCacheObjects)
boolean	GridCacheStoreManager.loadAllFromStore(IgniteInternalTx tx, Collection<? extends KeyCacheObject> keys, IgniteBiInClosure<KeyCacheObject,Object> vis) Loads data from persistent store.
boolean	GridCacheStoreManager.loadAllFromStore(IgniteInternalTx tx, Collection<? extends KeyCacheObject> keys, IgniteBiInClosure<KeyCacheObject,Object> vis) Loads data from persistent store.
boolean	GridCacheStoreManager.loadCache(GridInClosure3<KeyCacheObject,Object,GridCacheVersion> vis, Object[] args) Loads data from persistent store.
Collection<GridCacheVersion>	GridCacheMvccManager.localDhtPendingVersions(Collection<KeyCacheObject> keys, GridCacheVersion base)
void	GridCacheStoreManager.localStoreLoadAll(IgniteInternalTx tx, Collection<? extends KeyCacheObject> keys, GridInClosure3<KeyCacheObject,Object,GridCacheVersion> vis)
void	GridCacheStoreManager.localStoreLoadAll(IgniteInternalTx tx, Collection<? extends KeyCacheObject> keys, GridInClosure3<KeyCacheObject,Object,GridCacheVersion> vis)
void	GridCacheConcurrentMap.putAll(Map<KeyCacheObject,CacheObject> m, long ttl) Copies all of the mappings from the specified map to this map These mappings will replace any mappings that this map had for any of the keys currently in the specified map.
void	GridCacheProjectionImpl.putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data.
void	GridCacheProjectionEx.putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data.
void	GridCacheProxyImpl.putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data.
void	GridCacheAdapter.putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data.
IgniteInternalFuture<?>	GridCacheProjectionImpl.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data asynchronously.
IgniteInternalFuture<?>	GridCacheProjectionEx.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data asynchronously.
IgniteInternalFuture<?>	GridCacheProxyImpl.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data asynchronously.
IgniteInternalFuture<?>	GridCacheAdapter.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data asynchronously.
Collection<GridCacheBatchSwapEntry>	GridCacheSwapManager.readAndRemove(Collection<? extends KeyCacheObject> keys)
IgniteInternalFuture<Object>	GridCacheAdapter.readThroughAllAsync(Collection<KeyCacheObject> keys, boolean reload, boolean skipVals, IgniteInternalTx tx, UUID subjId, String taskName, IgniteBiInClosure<KeyCacheObject,Object> vis)
IgniteInternalFuture<Object>	GridCacheAdapter.readThroughAllAsync(Collection<KeyCacheObject> keys, boolean reload, boolean skipVals, IgniteInternalTx tx, UUID subjId, String taskName, IgniteBiInClosure<KeyCacheObject,Object> vis)
IgniteInternalFuture<Map<KeyCacheObject,CacheObject>>	GridCacheAdapter.reloadAllAsync0(Collection<KeyCacheObject> keys, boolean ret, boolean skipVals, UUID subjId, String taskName)
void	GridCacheProjectionImpl.removeAllConflict(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data.
void	GridCacheProjectionEx.removeAllConflict(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data.
void	GridCacheProxyImpl.removeAllConflict(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data.
void	GridCacheAdapter.removeAllConflict(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data.
IgniteInternalFuture<?>	GridCacheProjectionImpl.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data asynchronously.
IgniteInternalFuture<?>	GridCacheProjectionEx.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data asynchronously.
IgniteInternalFuture<?>	GridCacheProxyImpl.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data asynchronously.
IgniteInternalFuture<?>	GridCacheAdapter.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data asynchronously.
IgniteInternalFuture<Object>	GridCachePreloader.request(Collection<KeyCacheObject> keys, long topVer) Requests that preloader sends the request for the key.
IgniteInternalFuture<Object>	GridCachePreloaderAdapter.request(Collection<KeyCacheObject> keys, long topVer) Requests that preloader sends the request for the key.
abstract IgniteInternalFuture<Boolean>	GridCacheAdapter.txLockAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isRead, boolean retval, TransactionIsolation isolation, boolean invalidate, long accessTtl, CacheEntryPredicate[] filter)

Constructors in org.apache.ignite.internal.processors.cache with parameters of type KeyCacheObject

Constructor and Description
CacheEvictionEntry(KeyCacheObject key, GridCacheVersion ver, boolean near)
CacheInvokeDirectResult(KeyCacheObject key, CacheObject res)
CacheInvokeDirectResult(KeyCacheObject key, Exception err)
CacheInvokeEntry(GridCacheContext<K,V> ctx, KeyCacheObject keyObj, K key, CacheObject valObj, V val)
CacheInvokeEntry(GridCacheContext cctx, KeyCacheObject keyObj, CacheObject valObj)
CacheLazyEntry(GridCacheContext<K,V> ctx, KeyCacheObject keyObject, K key, CacheObject valObj, V val)
CacheLazyEntry(GridCacheContext cctx, KeyCacheObject keyObj, CacheObject valObj)
CacheLazyEntry(GridCacheContext cctx, KeyCacheObject keyObj, V val)
GridCacheBatchSwapEntry(KeyCacheObject key, int part, ByteBuffer valBytes, byte type, GridCacheVersion ver, long ttl, long expireTime, IgniteUuid keyClsLdrId, IgniteUuid valClsLdrId) Creates batch swap entry.
GridCacheMapEntry(GridCacheContext<?,?> cctx, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, long ttl, int hdrId)

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.datastructures

Methods in org.apache.ignite.internal.processors.cache.datastructures with parameters of type KeyCacheObject

Modifier and Type	Method and Description
void	CacheDataStructuresManager.onEntryUpdated(KeyCacheObject key, boolean rmv) Entry update callback.

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.distributed

Methods in org.apache.ignite.internal.processors.cache.distributed that return types with arguments of type KeyCacheObject

Modifier and Type	Method and Description
Map<KeyCacheObject,Collection<GridCacheMvccCandidate>>	GridDistributedBaseMessage.candidatesByKey()
List<KeyCacheObject>	GridDistributedLockRequest.keys()
List<KeyCacheObject>	GridDistributedUnlockRequest.keys()
List<KeyCacheObject>	GridCacheTtlUpdateRequest.keys()
List<KeyCacheObject>	GridCacheTtlUpdateRequest.nearKeys()

Methods in org.apache.ignite.internal.processors.cache.distributed with parameters of type KeyCacheObject

Modifier and Type	Method and Description
void	GridCacheTtlUpdateRequest.addEntry(KeyCacheObject key, GridCacheVersion ver)
void	GridDistributedUnlockRequest.addKey(KeyCacheObject key, GridCacheContext ctx)
void	GridDistributedLockRequest.addKeyBytes(KeyCacheObject key, boolean retVal, Collection<GridCacheMvccCandidate> cands, GridCacheContext ctx) Adds a key.
void	GridCacheTtlUpdateRequest.addNearEntry(KeyCacheObject key, GridCacheVersion ver)
Collection<GridCacheMvccCandidate>	GridDistributedBaseMessage.candidatesByKey(KeyCacheObject key)
void	GridDistributedBaseMessage.candidatesByKey(KeyCacheObject key, Collection<GridCacheMvccCandidate> candsByKey)
Collection<GridCacheMvccCandidate>	GridDistributedTxPrepareResponse.candidatesForKey(KeyCacheObject key)
<K,V> GridTuple<CacheObject>	GridDistributedTxRemoteAdapter.peek(GridCacheContext cacheCtx, boolean failFast, KeyCacheObject key, CacheEntryPredicate[] filter)
void	GridDistributedCacheAdapter.removeVersionedEntry(KeyCacheObject key, GridCacheVersion ver)

Method parameters in org.apache.ignite.internal.processors.cache.distributed with type arguments of type KeyCacheObject

Modifier and Type	Method and Description
void	GridDistributedTxPrepareResponse.candidates(Map<KeyCacheObject,Collection<GridCacheMvccCandidate>> cands)
protected abstract IgniteInternalFuture<Boolean>	GridDistributedCacheAdapter.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl, CacheEntryPredicate[] filter)
IgniteInternalFuture<Boolean>	GridDistributedCacheAdapter.txLockAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isRead, boolean retval, TransactionIsolation isolation, boolean isInvalidate, long accessTtl, CacheEntryPredicate[] filter)

Constructors in org.apache.ignite.internal.processors.cache.distributed with parameters of type KeyCacheObject

Constructor and Description
GridDistributedCacheEntry(GridCacheContext ctx, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, long ttl, int hdrId)

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.distributed.dht

Methods in org.apache.ignite.internal.processors.cache.distributed.dht that return types with arguments of type KeyCacheObject

Modifier and Type	Method and Description
List<KeyCacheObject>	GridDhtUnlockRequest.nearKeys()
List<KeyCacheObject>	GridDhtLockRequest.nearKeys()

Methods in org.apache.ignite.internal.processors.cache.distributed.dht with parameters of type KeyCacheObject

Modifier and Type	Method and Description
void	GridDhtLockRequest.addDhtKey(KeyCacheObject key, boolean invalidateEntry, GridCacheContext ctx) Adds a DHT key.
void	GridDhtUnlockRequest.addNearKey(KeyCacheObject key, GridCacheSharedContext ctx) Adds a Near key.
void	GridDhtLockRequest.addNearKey(KeyCacheObject key, GridCacheSharedContext ctx) Adds a Near key.
GridCacheEntryEx	GridDhtCacheAdapter.entryEx(KeyCacheObject key, boolean touch)
GridCacheEntryEx	GridDhtCacheAdapter.entryEx(KeyCacheObject key, long topVer)
GridDhtCacheEntry	GridDhtCacheAdapter.entryExx(KeyCacheObject key)
GridDhtCacheEntry	GridDhtCacheAdapter.entryExx(KeyCacheObject key, long topVer)
GridCacheEntryEx	GridDhtCacheAdapter.entryExx(KeyCacheObject key, long topVer, boolean allowDetached, boolean touch) Gets or creates entry for given key.
void	GridDhtLocalPartition.onDeferredDelete(KeyCacheObject key, GridCacheVersion ver)
void	GridDhtLocalPartition.onEntryEvicted(KeyCacheObject key, GridCacheVersion ver)
GridCacheVersion	GridDhtLockRequest.owned(KeyCacheObject key)
void	GridDhtLockRequest.owned(KeyCacheObject key, GridCacheVersion ownerMapped) Sets owner and its mapped version.
GridDhtCacheEntry	GridDhtCacheAdapter.peekExx(KeyCacheObject key)
boolean	GridDhtLocalPartition.preloadingPermitted(KeyCacheObject key, GridCacheVersion ver) Cache preloader should call this method within partition lock.
GridCacheMapEntry	GridNoStorageCacheMap.putEntry(long topVer, KeyCacheObject key, CacheObject val, long ttl)
GridTriple<GridCacheMapEntry>	GridNoStorageCacheMap.putEntryIfObsoleteOrAbsent(long topVer, KeyCacheObject key, CacheObject val, long ttl, boolean create)
GridCacheMapEntry	GridNoStorageCacheMap.removeEntryIfObsolete(KeyCacheObject key) Removes and returns the entry associated with the specified key in the HashMap if entry is obsolete.
protected boolean	GridDhtTxLocal.updateNearCache(GridCacheContext cacheCtx, KeyCacheObject key, long topVer) Checks whether near cache should be updated.
protected boolean	GridDhtTxRemote.updateNearCache(GridCacheContext cacheCtx, KeyCacheObject key, long topVer) Checks whether near cache should be updated.

Method parameters in org.apache.ignite.internal.processors.cache.distributed.dht with type arguments of type KeyCacheObject

Modifier and Type	Method and Description
GridDhtFuture<Collection<GridCacheEntryInfo>>	GridDhtCacheAdapter.getDhtAsync(UUID reader, long msgId, LinkedHashMap<KeyCacheObject,Boolean> keys, boolean readThrough, boolean reload, long topVer, UUID subjId, int taskNameHash, IgniteCacheExpiryPolicy expiry, boolean skipVals)
IgniteInternalFuture<Boolean>	GridDhtTransactionalCacheAdapter.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx txx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl, CacheEntryPredicate[] filter)
GridDhtFuture<Boolean>	GridDhtTransactionalCacheAdapter.lockAllAsyncInternal(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx txx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl, CacheEntryPredicate[] filter) Acquires locks in partitioned cache.
void	GridNoStorageCacheMap.putAll(Map<KeyCacheObject,CacheObject> m, long ttl) Copies all of the mappings from the specified map to this map These mappings will replace any mappings that this map had for any of the keys currently in the specified map.
void	GridDhtTransactionalCacheAdapter.removeLocks(UUID nodeId, GridCacheVersion ver, Iterable<KeyCacheObject> keys, boolean unmap)

Constructors in org.apache.ignite.internal.processors.cache.distributed.dht with parameters of type KeyCacheObject

Constructor and Description
GridDhtCacheEntry(GridCacheContext ctx, long topVer, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, long ttl, int hdrId)

Constructor parameters in org.apache.ignite.internal.processors.cache.distributed.dht with type arguments of type KeyCacheObject

Constructor and Description
GridDhtGetFuture(GridCacheContext<K,V> cctx, long msgId, UUID reader, LinkedHashMap<KeyCacheObject,Boolean> keys, boolean readThrough, boolean reload, IgniteTxLocalEx tx, long topVer, UUID subjId, int taskNameHash, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals)
GridPartitionedGetFuture(GridCacheContext<K,V> cctx, Collection<KeyCacheObject> keys, long topVer, boolean readThrough, boolean reload, boolean forcePrimary, UUID subjId, String taskName, boolean deserializePortable, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals)

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.distributed.dht.atomic

Methods in org.apache.ignite.internal.processors.cache.distributed.dht.atomic that return KeyCacheObject

Modifier and Type	Method and Description
KeyCacheObject	GridDhtAtomicUpdateRequest.key(int idx)
KeyCacheObject	GridDhtAtomicUpdateRequest.nearKey(int idx)

Methods in org.apache.ignite.internal.processors.cache.distributed.dht.atomic that return types with arguments of type KeyCacheObject

Modifier and Type	Method and Description
Collection<KeyCacheObject>	GridDhtAtomicUpdateResponse.failedKeys()
Collection<KeyCacheObject>	GridNearAtomicUpdateResponse.failedKeys()
Collection<KeyCacheObject>	GridDhtAtomicUpdateFuture.keys()
Collection<KeyCacheObject>	GridDhtAtomicUpdateRequest.keys()
List<KeyCacheObject>	GridNearAtomicUpdateRequest.keys()
Collection<KeyCacheObject>	GridDhtAtomicUpdateResponse.nearEvicted()
Collection<KeyCacheObject>	GridNearAtomicUpdateResponse.remapKeys()

Methods in org.apache.ignite.internal.processors.cache.distributed.dht.atomic with parameters of type KeyCacheObject

Modifier and Type	Method and Description
void	GridDhtAtomicUpdateResponse.addFailedKey(KeyCacheObject key, Throwable e) Adds key to collection of failed keys.
void	GridNearAtomicUpdateResponse.addFailedKey(KeyCacheObject key, Throwable e) Adds key to collection of failed keys.
void	GridDhtAtomicUpdateResponse.addNearEvicted(KeyCacheObject key) Adds near evicted key..
void	GridDhtAtomicUpdateRequest.addNearWriteValue(KeyCacheObject key, CacheObject val, javax.cache.processor.EntryProcessor<Object,Object,Object> entryProcessor, long ttl, long expireTime)
void	GridNearAtomicUpdateRequest.addUpdateEntry(KeyCacheObject key, Object val, long conflictTtl, long conflictExpireTime, GridCacheVersion conflictVer, boolean primary)
void	GridDhtAtomicUpdateRequest.addWriteValue(KeyCacheObject key, CacheObject val, javax.cache.processor.EntryProcessor<Object,Object,Object> entryProcessor, long ttl, long conflictExpireTime, GridCacheVersion conflictVer)

Method parameters in org.apache.ignite.internal.processors.cache.distributed.dht.atomic with type arguments of type KeyCacheObject

Modifier and Type	Method and Description
void	GridNearAtomicUpdateResponse.addFailedKeys(Collection<KeyCacheObject> keys, Throwable e) Adds keys to collection of failed keys.
protected IgniteInternalFuture<Boolean>	GridDhtAtomicCache.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl, CacheEntryPredicate[] filter)
void	GridDhtAtomicCache.putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> conflictMap) Store DR data.
IgniteInternalFuture<?>	GridDhtAtomicCache.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> conflictMap) Store DR data asynchronously.
void	GridNearAtomicUpdateResponse.remapKeys(List<KeyCacheObject> remapKeys)
void	GridDhtAtomicCache.removeAllConflict(Map<KeyCacheObject,GridCacheVersion> conflictMap) Removes DR data.
IgniteInternalFuture<?>	GridDhtAtomicCache.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> conflictMap) Removes DR data asynchronously.

Constructors in org.apache.ignite.internal.processors.cache.distributed.dht.atomic with parameters of type KeyCacheObject

Constructor and Description
GridDhtAtomicCacheEntry(GridCacheContext ctx, long topVer, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, long ttl, int hdrId)

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.distributed.dht.colocated

Methods in org.apache.ignite.internal.processors.cache.distributed.dht.colocated with parameters of type KeyCacheObject

Modifier and Type	Method and Description
protected GridCacheEntryEx	GridDhtColocatedCache.entryExSafe(KeyCacheObject key, long topVer)
GridDistributedCacheEntry	GridDhtColocatedCache.entryExx(KeyCacheObject key, long topVer, boolean allowDetached) Gets or creates entry for given key and given topology version.

Method parameters in org.apache.ignite.internal.processors.cache.distributed.dht.colocated with type arguments of type KeyCacheObject

Modifier and Type	Method and Description
IgniteInternalFuture<Map<K,V>>	GridDhtColocatedCache.loadAsync(Collection<KeyCacheObject> keys, boolean readThrough, boolean reload, boolean forcePrimary, long topVer, UUID subjId, String taskName, boolean deserializePortable, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals)
IgniteInternalFuture<Boolean>	GridDhtColocatedCache.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl, CacheEntryPredicate[] filter) This is an entry point to pessimistic locking within transaction.
void	GridDhtColocatedCache.removeLocks(long threadId, GridCacheVersion ver, Collection<KeyCacheObject> keys) Removes locks regardless of whether they are owned or not for given version and keys.

Constructors in org.apache.ignite.internal.processors.cache.distributed.dht.colocated with parameters of type KeyCacheObject

Constructor and Description
GridDhtColocatedCacheEntry(GridCacheContext ctx, long topVer, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, long ttl, int hdrId)
GridDhtDetachedCacheEntry(GridCacheContext ctx, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, long ttl, int hdrId)

Constructor parameters in org.apache.ignite.internal.processors.cache.distributed.dht.colocated with type arguments of type KeyCacheObject

Constructor and Description
GridDhtColocatedLockFuture(GridCacheContext<K,V> cctx, Collection<KeyCacheObject> keys, GridNearTxLocal tx, boolean read, boolean retval, long timeout, long accessTtl, CacheEntryPredicate[] filter)

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.distributed.dht.preloader

Methods in org.apache.ignite.internal.processors.cache.distributed.dht.preloader that return types with arguments of type KeyCacheObject

Modifier and Type	Method and Description
Collection<KeyCacheObject>	GridDhtForceKeysRequest.keys()
Collection<KeyCacheObject>	GridDhtForceKeysResponse.missedKeys()

Methods in org.apache.ignite.internal.processors.cache.distributed.dht.preloader with parameters of type KeyCacheObject

Modifier and Type	Method and Description
void	GridDhtForceKeysResponse.addMissed(KeyCacheObject key)

Method parameters in org.apache.ignite.internal.processors.cache.distributed.dht.preloader with type arguments of type KeyCacheObject

Modifier and Type	Method and Description
GridDhtFuture<Object>	GridDhtPreloader.request(Collection<KeyCacheObject> keys, long topVer)

Constructor parameters in org.apache.ignite.internal.processors.cache.distributed.dht.preloader with type arguments of type KeyCacheObject

Constructor and Description
GridDhtForceKeysFuture(GridCacheContext<K,V> cctx, long topVer, Collection<KeyCacheObject> keys, GridDhtPreloader<K,V> preloader)
GridDhtForceKeysRequest(Collection<KeyCacheObject> keys)

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.distributed.near

Methods in org.apache.ignite.internal.processors.cache.distributed.near that return types with arguments of type KeyCacheObject

Modifier and Type	Method and Description
Collection<KeyCacheObject>	GridNearLockMapping.distributedKeys()
LinkedHashMap<KeyCacheObject,Boolean>	GridNearGetRequest.keys()
Collection<KeyCacheObject>	GridNearLockMapping.mappedKeys()

Methods in org.apache.ignite.internal.processors.cache.distributed.near with parameters of type KeyCacheObject

Modifier and Type	Method and Description
void	GridNearLockMapping.addKey(KeyCacheObject key)
void	GridNearLockRequest.addKeyBytes(KeyCacheObject key, boolean retVal, GridCacheVersion dhtVer, GridCacheContext ctx) Adds a key.
GridCacheEntryEx	GridNearCacheAdapter.entryEx(KeyCacheObject key, boolean touch)
GridCacheEntryEx	GridNearCacheAdapter.entryEx(KeyCacheObject key, long topVer)
GridNearCacheEntry	GridNearCacheAdapter.entryExx(KeyCacheObject key, long topVer)
GridNearCacheEntry	GridNearCacheAdapter.peekExx(KeyCacheObject key)
protected Object	GridNearCacheEntry.readThrough(IgniteInternalTx tx, KeyCacheObject key, boolean reload, UUID subjId, String taskName)

Method parameters in org.apache.ignite.internal.processors.cache.distributed.near with type arguments of type KeyCacheObject

Modifier and Type	Method and Description
void	GridNearLockMapping.distributedKeys(Collection<KeyCacheObject> distributedKeys)
IgniteInternalFuture<Map<K,V>>	GridNearCacheAdapter.loadAsync(IgniteInternalTx tx, Collection<KeyCacheObject> keys, boolean reload, boolean forcePrimary, UUID subjId, String taskName, boolean deserializePortable, javax.cache.expiry.ExpiryPolicy expiryPlc, boolean skipVal)
IgniteInternalFuture<Boolean>	GridNearTxLocal.loadMissing(GridCacheContext cacheCtx, boolean readThrough, boolean async, Collection<KeyCacheObject> keys, boolean deserializePortable, boolean skipVals, IgniteBiInClosure<KeyCacheObject,Object> c)
IgniteInternalFuture<Boolean>	GridNearTxLocal.loadMissing(GridCacheContext cacheCtx, boolean readThrough, boolean async, Collection<KeyCacheObject> keys, boolean deserializePortable, boolean skipVals, IgniteBiInClosure<KeyCacheObject,Object> c)
protected IgniteInternalFuture<Boolean>	GridNearAtomicCache.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl, CacheEntryPredicate[] filter)
protected IgniteInternalFuture<Boolean>	GridNearTransactionalCache.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl, CacheEntryPredicate[] filter)
void	GridNearAtomicCache.putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data.
IgniteInternalFuture<?>	GridNearAtomicCache.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data asynchronously.
IgniteInternalFuture<Object>	GridNearCacheAdapter.readThroughAllAsync(Collection<KeyCacheObject> keys, boolean reload, boolean skipVals, IgniteInternalTx tx, UUID subjId, String taskName, IgniteBiInClosure<KeyCacheObject,Object> vis)
IgniteInternalFuture<Object>	GridNearCacheAdapter.readThroughAllAsync(Collection<KeyCacheObject> keys, boolean reload, boolean skipVals, IgniteInternalTx tx, UUID subjId, String taskName, IgniteBiInClosure<KeyCacheObject,Object> vis)
void	GridNearAtomicCache.removeAllConflict(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data.
IgniteInternalFuture<?>	GridNearAtomicCache.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data asynchronously.
void	GridNearTransactionalCache.removeLocks(GridCacheVersion ver, Collection<KeyCacheObject> keys) Removes locks regardless of whether they are owned or not for given version and keys.

Constructors in org.apache.ignite.internal.processors.cache.distributed.near with parameters of type KeyCacheObject

Constructor and Description
GridNearCacheEntry(GridCacheContext ctx, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, long ttl, int hdrId)
GridNearLockMapping(ClusterNode node, KeyCacheObject firstKey) Creates near lock mapping for specified node and key.

Constructor parameters in org.apache.ignite.internal.processors.cache.distributed.near with type arguments of type KeyCacheObject

Constructor and Description
GridNearGetFuture(GridCacheContext<K,V> cctx, Collection<KeyCacheObject> keys, boolean readThrough, boolean reload, boolean forcePrimary, IgniteTxLocalEx tx, UUID subjId, String taskName, boolean deserializePortable, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals)
GridNearGetRequest(int cacheId, IgniteUuid futId, IgniteUuid miniId, GridCacheVersion ver, LinkedHashMap<KeyCacheObject,Boolean> keys, boolean readThrough, boolean reload, long topVer, UUID subjId, int taskNameHash, long accessTtl, boolean skipVals)
GridNearLockFuture(GridCacheContext<K,V> cctx, Collection<KeyCacheObject> keys, GridNearTxLocal tx, boolean read, boolean retval, long timeout, long accessTtl, CacheEntryPredicate[] filter)

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.dr

Methods in org.apache.ignite.internal.processors.cache.dr with parameters of type KeyCacheObject

Modifier and Type	Method and Description
void	GridCacheDrManager.replicate(KeyCacheObject key, CacheObject val, long ttl, long expireTime, GridCacheVersion ver, GridDrType drType) Performs replication.

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.dr.os

Methods in org.apache.ignite.internal.processors.cache.dr.os with parameters of type KeyCacheObject

Modifier and Type	Method and Description
void	GridOsCacheDrManager.replicate(KeyCacheObject key, CacheObject val, long ttl, long expireTime, GridCacheVersion ver, GridDrType drType) Performs replication.

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.local

Method parameters in org.apache.ignite.internal.processors.cache.local with type arguments of type KeyCacheObject

Modifier and Type	Method and Description
IgniteInternalFuture<Boolean>	GridLocalCache.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, CacheEntryPredicate[] filter)
IgniteInternalFuture<Boolean>	GridLocalCache.txLockAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isRead, boolean retval, TransactionIsolation isolation, boolean invalidate, long accessTtl, CacheEntryPredicate[] filter)

Constructors in org.apache.ignite.internal.processors.cache.local with parameters of type KeyCacheObject

Constructor and Description
GridLocalCacheEntry(GridCacheContext ctx, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, long ttl, int hdrId)

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.local.atomic

Method parameters in org.apache.ignite.internal.processors.cache.local.atomic with type arguments of type KeyCacheObject

Modifier and Type	Method and Description
IgniteInternalFuture<Boolean>	GridLocalAtomicCache.txLockAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isRead, boolean retval, TransactionIsolation isolation, boolean invalidate, long accessTtl, CacheEntryPredicate[] filter)

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.query.continuous

Methods in org.apache.ignite.internal.processors.cache.query.continuous with parameters of type KeyCacheObject

Modifier and Type	Method and Description
void	CacheContinuousQueryManager.onEntryExpired(GridCacheEntryEx e, KeyCacheObject key, CacheObject oldVal)
void	CacheContinuousQueryManager.onEntryUpdated(GridCacheEntryEx e, KeyCacheObject key, CacheObject newVal, CacheObject oldVal, boolean preload)

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.transactions

Methods in org.apache.ignite.internal.processors.cache.transactions that return KeyCacheObject

Modifier and Type	Method and Description
KeyCacheObject	IgniteTxEntry.key()
KeyCacheObject	IgniteTxKey.key()

Methods in org.apache.ignite.internal.processors.cache.transactions that return types with arguments of type KeyCacheObject

Modifier and Type	Method and Description
protected <K,V> IgniteInternalFuture<Set<KeyCacheObject>>	IgniteTxLocalAdapter.enlistWrite(GridCacheContext cacheCtx, Collection<?> keys, GridCacheEntryEx cached, javax.cache.expiry.ExpiryPolicy expiryPlc, boolean implicit, Map<?,?> lookup, Map<?,javax.cache.processor.EntryProcessor<K,V,Object>> invokeMap, Object[] invokeArgs, boolean retval, boolean lockOnly, CacheEntryPredicate[] filter, GridCacheReturn ret, Collection<KeyCacheObject> enlisted, Map<KeyCacheObject,GridCacheDrInfo> drPutMap, Map<KeyCacheObject,GridCacheVersion> drRmvMap) Internal routine for putAll(..)
protected Set<KeyCacheObject>	IgniteTxLocalAdapter.postLockWrite(GridCacheContext cacheCtx, Iterable<KeyCacheObject> keys, Set<KeyCacheObject> failed, GridCacheReturn ret, boolean rmv, boolean retval, boolean read, long accessTtl, CacheEntryPredicate[] filter, boolean computeInvoke) Post lock processing for put or remove.

Methods in org.apache.ignite.internal.processors.cache.transactions with parameters of type KeyCacheObject

Modifier and Type	Method and Description
<K,V> GridTuple<CacheObject>	IgniteTxLocalAdapter.peek(GridCacheContext cacheCtx, boolean failFast, KeyCacheObject key, CacheEntryPredicate[] filter)
<K,V> GridTuple<CacheObject>	IgniteInternalTx.peek(GridCacheContext ctx, boolean failFast, KeyCacheObject key, CacheEntryPredicate[] filter)
protected boolean	IgniteTxAdapter.updateNearCache(GridCacheContext<?,?> cacheCtx, KeyCacheObject key, long topVer) Checks whether near cache should be updated.

Method parameters in org.apache.ignite.internal.processors.cache.transactions with type arguments of type KeyCacheObject

Modifier and Type	Method and Description
protected <K,V> IgniteInternalFuture<Set<KeyCacheObject>>	IgniteTxLocalAdapter.enlistWrite(GridCacheContext cacheCtx, Collection<?> keys, GridCacheEntryEx cached, javax.cache.expiry.ExpiryPolicy expiryPlc, boolean implicit, Map<?,?> lookup, Map<?,javax.cache.processor.EntryProcessor<K,V,Object>> invokeMap, Object[] invokeArgs, boolean retval, boolean lockOnly, CacheEntryPredicate[] filter, GridCacheReturn ret, Collection<KeyCacheObject> enlisted, Map<KeyCacheObject,GridCacheDrInfo> drPutMap, Map<KeyCacheObject,GridCacheVersion> drRmvMap) Internal routine for putAll(..)
protected <K,V> IgniteInternalFuture<Set<KeyCacheObject>>	IgniteTxLocalAdapter.enlistWrite(GridCacheContext cacheCtx, Collection<?> keys, GridCacheEntryEx cached, javax.cache.expiry.ExpiryPolicy expiryPlc, boolean implicit, Map<?,?> lookup, Map<?,javax.cache.processor.EntryProcessor<K,V,Object>> invokeMap, Object[] invokeArgs, boolean retval, boolean lockOnly, CacheEntryPredicate[] filter, GridCacheReturn ret, Collection<KeyCacheObject> enlisted, Map<KeyCacheObject,GridCacheDrInfo> drPutMap, Map<KeyCacheObject,GridCacheVersion> drRmvMap) Internal routine for putAll(..)
protected <K,V> IgniteInternalFuture<Set<KeyCacheObject>>	IgniteTxLocalAdapter.enlistWrite(GridCacheContext cacheCtx, Collection<?> keys, GridCacheEntryEx cached, javax.cache.expiry.ExpiryPolicy expiryPlc, boolean implicit, Map<?,?> lookup, Map<?,javax.cache.processor.EntryProcessor<K,V,Object>> invokeMap, Object[] invokeArgs, boolean retval, boolean lockOnly, CacheEntryPredicate[] filter, GridCacheReturn ret, Collection<KeyCacheObject> enlisted, Map<KeyCacheObject,GridCacheDrInfo> drPutMap, Map<KeyCacheObject,GridCacheVersion> drRmvMap) Internal routine for putAll(..)
<K,V> IgniteInternalFuture<Map<K,V>>	IgniteTxLocalEx.getAllAsync(GridCacheContext cacheCtx, Collection<KeyCacheObject> keys, GridCacheEntryEx cached, boolean deserializePortable, boolean skipVals, boolean keepCacheObjects)
<K,V> IgniteInternalFuture<Map<K,V>>	IgniteTxLocalAdapter.getAllAsync(GridCacheContext cacheCtx, Collection<KeyCacheObject> keys, GridCacheEntryEx cached, boolean deserializePortable, boolean skipVals, boolean keepCacheObjects)
IgniteInternalFuture<Boolean>	IgniteTxLocalEx.loadMissing(GridCacheContext cacheCtx, boolean readThrough, boolean async, Collection<KeyCacheObject> keys, boolean deserializePortable, boolean skipVals, IgniteBiInClosure<KeyCacheObject,Object> c)
IgniteInternalFuture<Boolean>	IgniteTxLocalEx.loadMissing(GridCacheContext cacheCtx, boolean readThrough, boolean async, Collection<KeyCacheObject> keys, boolean deserializePortable, boolean skipVals, IgniteBiInClosure<KeyCacheObject,Object> c)
IgniteInternalFuture<Boolean>	IgniteTxLocalAdapter.loadMissing(GridCacheContext cacheCtx, boolean readThrough, boolean async, Collection<KeyCacheObject> keys, boolean deserializePortable, boolean skipVals, IgniteBiInClosure<KeyCacheObject,Object> c)
IgniteInternalFuture<Boolean>	IgniteTxLocalAdapter.loadMissing(GridCacheContext cacheCtx, boolean readThrough, boolean async, Collection<KeyCacheObject> keys, boolean deserializePortable, boolean skipVals, IgniteBiInClosure<KeyCacheObject,Object> c)
protected Set<KeyCacheObject>	IgniteTxLocalAdapter.postLockWrite(GridCacheContext cacheCtx, Iterable<KeyCacheObject> keys, Set<KeyCacheObject> failed, GridCacheReturn ret, boolean rmv, boolean retval, boolean read, long accessTtl, CacheEntryPredicate[] filter, boolean computeInvoke) Post lock processing for put or remove.
protected Set<KeyCacheObject>	IgniteTxLocalAdapter.postLockWrite(GridCacheContext cacheCtx, Iterable<KeyCacheObject> keys, Set<KeyCacheObject> failed, GridCacheReturn ret, boolean rmv, boolean retval, boolean read, long accessTtl, CacheEntryPredicate[] filter, boolean computeInvoke) Post lock processing for put or remove.
IgniteInternalFuture<?>	IgniteTxLocalEx.putAllDrAsync(GridCacheContext cacheCtx, Map<KeyCacheObject,GridCacheDrInfo> drMap)
IgniteInternalFuture<?>	IgniteTxLocalAdapter.putAllDrAsync(GridCacheContext cacheCtx, Map<KeyCacheObject,GridCacheDrInfo> drMap)
IgniteInternalFuture<?>	IgniteTxLocalEx.removeAllDrAsync(GridCacheContext cacheCtx, Map<KeyCacheObject,GridCacheVersion> drMap)
IgniteInternalFuture<?>	IgniteTxLocalAdapter.removeAllDrAsync(GridCacheContext cacheCtx, Map<KeyCacheObject,GridCacheVersion> drMap)

Constructors in org.apache.ignite.internal.processors.cache.transactions with parameters of type KeyCacheObject

Constructor and Description
IgniteTxKey(KeyCacheObject key, int cacheId)

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.version

Methods in org.apache.ignite.internal.processors.cache.version with parameters of type KeyCacheObject

Modifier and Type	Method and Description
void	GridCacheRawVersionedEntry.key(KeyCacheObject key)

Constructors in org.apache.ignite.internal.processors.cache.version with parameters of type KeyCacheObject

Constructor and Description
GridCacheRawVersionedEntry(KeyCacheObject key, CacheObject val, long ttl, long expireTime, GridCacheVersion ver) Constructor used for local store load when key and value are available.

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cacheobject

Methods in org.apache.ignite.internal.processors.cacheobject that return KeyCacheObject

Modifier and Type	Method and Description
KeyCacheObject	IgniteCacheObjectProcessorImpl.toCacheKeyObject(CacheObjectContext ctx, Object obj, boolean userObj)
KeyCacheObject	IgniteCacheObjectProcessor.toCacheKeyObject(CacheObjectContext ctx, Object obj, boolean userObj)
protected KeyCacheObject	IgniteCacheObjectProcessorImpl.toCacheKeyObject0(Object obj, boolean userObj)

Uses of KeyCacheObject in org.apache.ignite.internal.processors.datastreamer

Fields in org.apache.ignite.internal.processors.datastreamer declared as KeyCacheObject

Modifier and Type	Field and Description
protected KeyCacheObject	DataStreamerEntry.key

Methods in org.apache.ignite.internal.processors.datastreamer that return KeyCacheObject

Modifier and Type	Method and Description
KeyCacheObject	DataStreamerEntry.getKey()

Methods in org.apache.ignite.internal.processors.datastreamer with parameters of type KeyCacheObject

Modifier and Type	Method and Description
IgniteFuture<?>	DataStreamerImpl.addDataInternal(KeyCacheObject key, CacheObject val)
IgniteFuture<?>	DataStreamerImpl.removeDataInternal(KeyCacheObject key)

Constructors in org.apache.ignite.internal.processors.datastreamer with parameters of type KeyCacheObject

Constructor and Description
DataStreamerEntry(KeyCacheObject key, CacheObject val)

Uses of KeyCacheObject in org.apache.ignite.internal.processors.dr

Method parameters in org.apache.ignite.internal.processors.dr with type arguments of type KeyCacheObject

Modifier and Type	Method and Description
void	IgniteDrDataStreamerCacheUpdater.update(IgniteCache<KeyCacheObject,CacheObject> cache0, Collection<Map.Entry<KeyCacheObject,CacheObject>> col) Updates cache with batch of entries.
void	IgniteDrDataStreamerCacheUpdater.update(IgniteCache<KeyCacheObject,CacheObject> cache0, Collection<Map.Entry<KeyCacheObject,CacheObject>> col) Updates cache with batch of entries.