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

Packages that use KeyCacheObject

Package	Description
org.apache.ignite.internal.portable	Contains portable APIs internal implementation.
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.local
org.apache.ignite.internal.processors.cache.local.atomic
org.apache.ignite.internal.processors.cache.portable	Implementation of portable processor.
org.apache.ignite.internal.processors.cache.query.continuous
org.apache.ignite.internal.processors.cache.store
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.
org.apache.ignite.internal.processors.offheap
org.apache.ignite.spi.swapspace	Contains APIs for swap space SPI.

Uses of KeyCacheObject in org.apache.ignite.internal.portable

Classes in org.apache.ignite.internal.portable that implement KeyCacheObject

Modifier and Type	Class and Description
class	BinaryObjectImpl Portable object implementation.

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	CacheInvokeDirectResult.key()
KeyCacheObject	GridCacheEntryInfo.key()
KeyCacheObject	GridCacheBatchSwapEntry.key()
KeyCacheObject	GridCacheEntryEx.key()
KeyCacheObject	CacheEvictionEntry.key()
KeyCacheObject	GridCacheMapEntry.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, int meta)
Iterator<KeyCacheObject>	GridCacheSwapManager.offHeapKeyIterator(boolean primary, boolean backup, AffinityTopologyVersion topVer)
Map<UUID,Collection<IgniteBiTuple<KeyCacheObject,GridCacheVersion>>>	IgniteCacheExpiryPolicy.readers()
Map<UUID,Collection<IgniteBiTuple<KeyCacheObject,GridCacheVersion>>>	GridCacheAdapter.CacheExpiryPolicy.readers()
Iterator<KeyCacheObject>	GridCacheSwapManager.swapKeyIterator(boolean primary, boolean backup, AffinityTopologyVersion 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, boolean keepBinary)
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, boolean keepBinary)
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, boolean keepPortable)
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, boolean keepPortable)
<K1,V1> void	GridCacheContext.addResult(Map<K1,V1> map, KeyCacheObject key, CacheObject val, boolean skipVals, boolean keepCacheObjects, boolean deserializePortable, boolean cpy)
boolean	GridCacheSwapManager.containsKey(KeyCacheObject key, int part)
GridCacheMapEntry	GridCacheMapEntryFactory.create(GridCacheContext ctx, AffinityTopologyVersion topVer, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, int hdrId)
GridCacheEntryEx	GridCacheAdapter.entryEx(KeyCacheObject key)
GridCacheEntryEx	GridCacheAdapter.entryEx(KeyCacheObject key, AffinityTopologyVersion topVer)
GridCacheEntryEx	GridCacheAdapter.entryEx(KeyCacheObject key, boolean touch)
protected GridCacheEntryEx	GridCacheAdapter.entryExSafe(KeyCacheObject key, AffinityTopologyVersion topVer)
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.
void	GridCacheEntryInfo.key(KeyCacheObject key)
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(AffinityTopologyVersion topVer, KeyCacheObject key, CacheObject val)
GridTriple<GridCacheMapEntry>	GridCacheConcurrentMap.putEntryIfObsoleteOrAbsent(AffinityTopologyVersion topVer, KeyCacheObject key, CacheObject val, boolean create)
GridCacheSwapEntry	GridCacheSwapManager.readOffheapBeforeRemove(KeyCacheObject key, byte[] keyBytes, int part) Reads value from offheap and unswaps it for indexing.
protected Object	GridCacheMapEntry.readThrough(IgniteInternalTx tx, KeyCacheObject key, boolean reload, UUID subjId, String taskName)
CacheObject	GridCacheSwapManager.readValue(KeyCacheObject key, boolean readOffheap, boolean readSwap)
void	GridCacheSwapManager.remove(KeyCacheObject key)
GridCacheMapEntry	GridCacheConcurrentMap.removeEntryIfObsolete(KeyCacheObject key) Removes and returns the entry associated with the specified key in the HashMap if entry is obsolete.
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)
void	GridCacheSwapManager.writeToSwap(int part, KeyCacheObject key, byte[] entry) Writes given bytes to swap.

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, int cacheId, AffinityTopologyVersion 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 canRemap, boolean needVer)
void	GridCacheConcurrentMap.putAll(Map<KeyCacheObject,CacheObject> m) 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	GridCacheProxyImpl.putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data.
void	IgniteInternalCache.putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data.
void	GridCacheAdapter.putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data.
IgniteInternalFuture<?>	GridCacheProxyImpl.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data asynchronously.
IgniteInternalFuture<?>	IgniteInternalCache.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)
void	GridCacheProxyImpl.removeAllConflict(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data.
void	IgniteInternalCache.removeAllConflict(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data.
void	GridCacheAdapter.removeAllConflict(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data.
IgniteInternalFuture<?>	GridCacheProxyImpl.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data asynchronously.
IgniteInternalFuture<?>	IgniteInternalCache.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data asynchronously.
IgniteInternalFuture<?>	GridCacheAdapter.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data asynchronously.
IgniteInternalFuture<Object>	GridCachePreloaderAdapter.request(Collection<KeyCacheObject> keys, AffinityTopologyVersion topVer) Requests that preloader sends the request for the key.
IgniteInternalFuture<Object>	GridCachePreloader.request(Collection<KeyCacheObject> keys, AffinityTopologyVersion 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)

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, GridCacheVersion ver, boolean keepPortable)
CacheInvokeEntry(GridCacheContext cctx, KeyCacheObject keyObj, CacheObject valObj, GridCacheVersion ver, boolean keepPortable)
CacheLazyEntry(GridCacheContext<K,V> ctx, KeyCacheObject keyObj, K key, CacheObject valObj, V val, boolean keepPortable)
CacheLazyEntry(GridCacheContext cctx, KeyCacheObject keyObj, CacheObject valObj, boolean keepPortable)
CacheLazyEntry(GridCacheContext cctx, KeyCacheObject keyObj, V val, boolean keepPortable)
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, 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, boolean keepPortable) 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
List<KeyCacheObject>	GridCacheTtlUpdateRequest.keys()
List<KeyCacheObject>	GridDistributedUnlockRequest.keys()
List<KeyCacheObject>	GridDistributedLockRequest.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, GridCacheContext ctx) Adds a key.
void	GridCacheTtlUpdateRequest.addNearEntry(KeyCacheObject key, GridCacheVersion ver)
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
protected abstract IgniteInternalFuture<Boolean>	GridDistributedCacheAdapter.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl)
IgniteInternalFuture<Boolean>	GridDistributedCacheAdapter.txLockAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isRead, boolean retval, TransactionIsolation isolation, boolean isInvalidate, long accessTtl)

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, int hdrId)

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

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

Modifier and Type	Field and Description
protected Collection<KeyCacheObject>	CacheDistributedGetFutureAdapter.keys Keys.

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

Modifier and Type	Method and Description
Set<KeyCacheObject>	GridDhtLocalPartition.keySet()
List<KeyCacheObject>	GridDhtLockRequest.nearKeys()
List<KeyCacheObject>	GridDhtUnlockRequest.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	GridDhtLockRequest.addNearKey(KeyCacheObject key, GridCacheSharedContext ctx) Adds a Near key.
void	GridDhtUnlockRequest.addNearKey(KeyCacheObject key, GridCacheSharedContext ctx) Adds a Near key.
protected ClusterNode	CacheDistributedGetFutureAdapter.affinityNode(KeyCacheObject key, AffinityTopologyVersion topVer) Affinity node to send get request to.
protected GridDistributedCacheEntry	GridDhtCacheAdapter.createEntry(KeyCacheObject key)
GridCacheEntryEx	GridDhtCacheAdapter.entryEx(KeyCacheObject key, AffinityTopologyVersion topVer)
GridCacheEntryEx	GridDhtCacheAdapter.entryEx(KeyCacheObject key, boolean touch)
GridDhtCacheEntry	GridDhtCacheAdapter.entryExx(KeyCacheObject key)
GridDhtCacheEntry	GridDhtCacheAdapter.entryExx(KeyCacheObject key, AffinityTopologyVersion topVer)
GridCacheEntryEx	GridDhtCacheAdapter.entryExx(KeyCacheObject key, AffinityTopologyVersion 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(AffinityTopologyVersion topVer, KeyCacheObject key, CacheObject val)
GridTriple<GridCacheMapEntry>	GridNoStorageCacheMap.putEntryIfObsoleteOrAbsent(AffinityTopologyVersion topVer, KeyCacheObject key, CacheObject val, 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	GridDhtTxRemote.updateNearCache(GridCacheContext cacheCtx, KeyCacheObject key, AffinityTopologyVersion topVer) Checks whether near cache should be updated.
protected boolean	GridDhtTxLocal.updateNearCache(GridCacheContext cacheCtx, KeyCacheObject key, AffinityTopologyVersion topVer) Checks whether near cache should be updated.
protected void	CacheDistributedGetFutureAdapter.versionedResult(Map map, KeyCacheObject key, Object val, GridCacheVersion ver)

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, Map<KeyCacheObject,Boolean> keys, boolean readThrough, AffinityTopologyVersion 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)
GridDhtFuture<Boolean>	GridDhtTransactionalCacheAdapter.lockAllAsyncInternal(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx txx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl, CacheEntryPredicate[] filter, boolean skipStore, boolean keepBinary) Acquires locks in partitioned cache.
void	GridNoStorageCacheMap.putAll(Map<KeyCacheObject,CacheObject> m) 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, AffinityTopologyVersion topVer, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, int hdrId)
GridDhtOffHeapCacheEntry(GridCacheContext ctx, AffinityTopologyVersion topVer, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, int hdrId)
GridPartitionedSingleGetFuture(GridCacheContext cctx, KeyCacheObject key, AffinityTopologyVersion topVer, boolean readThrough, boolean forcePrimary, UUID subjId, String taskName, boolean deserializePortable, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean canRemap, boolean needVer, boolean keepCacheObjects)

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

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

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>	GridNearAtomicUpdateResponse.failedKeys()
Collection<KeyCacheObject>	GridDhtAtomicUpdateResponse.failedKeys()
Collection<KeyCacheObject>	GridDhtAtomicUpdateRequest.keys()
Collection<KeyCacheObject>	GridDhtAtomicUpdateFuture.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	GridNearAtomicUpdateResponse.addFailedKey(KeyCacheObject key, Throwable e) Adds key to collection of failed keys.
void	GridDhtAtomicUpdateResponse.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, boolean addPrevVal, int partId, CacheObject prevVal, Long updateIdx)

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.
void	GridNearAtomicUpdateResponse.addFailedKeys(Collection<KeyCacheObject> keys, Throwable e, GridCacheContext ctx) 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)
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, AffinityTopologyVersion topVer, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, int hdrId)
GridDhtAtomicOffHeapCacheEntry(GridCacheContext ctx, AffinityTopologyVersion topVer, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, 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, AffinityTopologyVersion topVer)
GridDistributedCacheEntry	GridDhtColocatedCache.entryExx(KeyCacheObject key, AffinityTopologyVersion topVer, boolean allowDetached) Gets or creates entry for given key and given topology version.
IgniteInternalFuture<Object>	GridDhtColocatedCache.loadAsync(KeyCacheObject key, boolean readThrough, boolean forcePrimary, AffinityTopologyVersion topVer, UUID subjId, String taskName, boolean deserializePortable, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean canRemap, boolean needVer, boolean keepCacheObj)

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 forcePrimary, AffinityTopologyVersion topVer, UUID subjId, String taskName, boolean deserializePortable, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean canRemap)
IgniteInternalFuture<Map<K,V>>	GridDhtColocatedCache.loadAsync(Collection<KeyCacheObject> keys, boolean readThrough, boolean forcePrimary, AffinityTopologyVersion topVer, UUID subjId, String taskName, boolean deserializePortable, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean canRemap, boolean needVer, boolean keepCacheObj)
IgniteInternalFuture<Boolean>	GridDhtColocatedCache.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl) 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, AffinityTopologyVersion topVer, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, int hdrId)
GridDhtColocatedOffHeapCacheEntry(GridCacheContext ctx, AffinityTopologyVersion topVer, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, int hdrId)
GridDhtDetachedCacheEntry(GridCacheContext ctx, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, 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<?,?> cctx, Collection<KeyCacheObject> keys, GridNearTxLocal tx, boolean read, boolean retval, long timeout, long accessTtl, CacheEntryPredicate[] filter, boolean skipStore, boolean keepBinary)

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, AffinityTopologyVersion 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, AffinityTopologyVersion topVer, Collection<KeyCacheObject> keys, GridDhtPreloader preloader)

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

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

Modifier and Type	Method and Description
KeyCacheObject	GridNearSingleGetRequest.key()

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, AffinityTopologyVersion topVer)
GridCacheEntryEx	GridNearCacheAdapter.entryEx(KeyCacheObject key, boolean touch)
GridNearCacheEntry	GridNearCacheAdapter.entryExx(KeyCacheObject key, AffinityTopologyVersion 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
protected IgniteCacheExpiryPolicy	GridNearTxLocal.accessPolicy(GridCacheContext cacheCtx, Collection<KeyCacheObject> keys)
void	GridNearLockMapping.distributedKeys(Collection<KeyCacheObject> distributedKeys)
IgniteInternalFuture<Map<K,V>>	GridNearCacheAdapter.loadAsync(IgniteInternalTx tx, Collection<KeyCacheObject> keys, boolean forcePrimary, UUID subjId, String taskName, boolean deserializePortable, javax.cache.expiry.ExpiryPolicy expiryPlc, boolean skipVal, boolean skipStore, boolean canRemap)
IgniteInternalFuture<Void>	GridNearTxLocal.loadMissing(GridCacheContext cacheCtx, boolean readThrough, boolean async, Collection<KeyCacheObject> keys, boolean skipVals, boolean needVer, boolean keepBinary, GridInClosure3<KeyCacheObject,Object,GridCacheVersion> c)
IgniteInternalFuture<Void>	GridNearTxLocal.loadMissing(GridCacheContext cacheCtx, boolean readThrough, boolean async, Collection<KeyCacheObject> keys, boolean skipVals, boolean needVer, boolean keepBinary, GridInClosure3<KeyCacheObject,Object,GridCacheVersion> c)
protected IgniteInternalFuture<Boolean>	GridNearTransactionalCache.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl)
protected IgniteInternalFuture<Boolean>	GridNearAtomicCache.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl)
void	GridNearAtomicCache.putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data.
IgniteInternalFuture<?>	GridNearAtomicCache.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data asynchronously.
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, int hdrId)
GridNearLockMapping(ClusterNode node, KeyCacheObject firstKey) Creates near lock mapping for specified node and key.
GridNearOffHeapCacheEntry(GridCacheContext ctx, KeyCacheObject key, int hash, CacheObject val, GridCacheMapEntry next, int hdrId)
GridNearSingleGetRequest(int cacheId, long futId, KeyCacheObject key, boolean readThrough, AffinityTopologyVersion topVer, UUID subjId, int taskNameHash, long accessTtl, boolean skipVals, boolean addReader, boolean needVer, boolean addDepInfo)

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 forcePrimary, IgniteTxLocalEx tx, UUID subjId, String taskName, boolean deserializePortable, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean canRemap, boolean needVer, boolean keepCacheObjects)
GridNearGetRequest(int cacheId, IgniteUuid futId, IgniteUuid miniId, GridCacheVersion ver, Map<KeyCacheObject,Boolean> keys, boolean readThrough, AffinityTopologyVersion topVer, UUID subjId, int taskNameHash, long accessTtl, boolean skipVals, boolean addDepInfo)
GridNearLockFuture(GridCacheContext<?,?> cctx, Collection<KeyCacheObject> keys, GridNearTxLocal tx, boolean read, boolean retval, long timeout, long accessTtl, CacheEntryPredicate[] filter, boolean skipStore, boolean keepBinary)

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.
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)

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, 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)

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

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

Modifier and Type	Method and Description
KeyCacheObject	CacheObjectBinaryProcessorImpl.toCacheKeyObject(CacheObjectContext ctx, Object obj, boolean userObj)

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(KeyCacheObject key, CacheObject newVal, CacheObject oldVal, boolean internal, int partId, boolean primary, boolean preload, long updateCntr, AffinityTopologyVersion topVer)
void	CacheContinuousQueryManager.skipUpdateEvent(KeyCacheObject key, int partId, long updCntr, AffinityTopologyVersion topVer)

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

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

Modifier and Type	Method and Description
Object	CacheStoreManager.load(IgniteInternalTx tx, KeyCacheObject key) Loads data from persistent store.
Object	GridCacheStoreManagerAdapter.load(IgniteInternalTx tx, KeyCacheObject key) Loads data from persistent store.

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

Modifier and Type	Method and Description
boolean	CacheStoreManager.loadAll(IgniteInternalTx tx, Collection<? extends KeyCacheObject> keys, IgniteBiInClosure<KeyCacheObject,Object> vis) Loads data from persistent store.
boolean	CacheStoreManager.loadAll(IgniteInternalTx tx, Collection<? extends KeyCacheObject> keys, IgniteBiInClosure<KeyCacheObject,Object> vis) Loads data from persistent store.
boolean	CacheStoreManager.loadCache(GridInClosure3<KeyCacheObject,Object,GridCacheVersion> vis, Object[] args) Loads data from persistent store.
void	CacheStoreManager.localStoreLoadAll(IgniteInternalTx tx, Collection<? extends KeyCacheObject> keys, GridInClosure3<KeyCacheObject,Object,GridCacheVersion> vis)
void	CacheStoreManager.localStoreLoadAll(IgniteInternalTx tx, Collection<? extends KeyCacheObject> keys, GridInClosure3<KeyCacheObject,Object,GridCacheVersion> vis)

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	IgniteTxKey.key()
KeyCacheObject	IgniteTxEntry.key()

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

Modifier and Type	Method and Description
GridTuple<CacheObject>	IgniteTxLocalAdapter.peek(GridCacheContext cacheCtx, boolean failFast, KeyCacheObject key, CacheEntryPredicate[] filter)
GridTuple<CacheObject>	IgniteInternalTx.peek(GridCacheContext ctx, boolean failFast, KeyCacheObject key, CacheEntryPredicate[] filter)
protected boolean	IgniteTxAdapter.updateNearCache(GridCacheContext<?,?> cacheCtx, KeyCacheObject key, AffinityTopologyVersion 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 IgniteCacheExpiryPolicy	IgniteTxLocalAdapter.accessPolicy(GridCacheContext cacheCtx, Collection<KeyCacheObject> keys)
<K,V> IgniteInternalFuture<Map<K,V>>	IgniteTxLocalAdapter.getAllAsync(GridCacheContext cacheCtx, Collection<KeyCacheObject> keys, boolean deserializePortable, boolean skipVals, boolean keepCacheObjects, boolean skipStore)
<K,V> IgniteInternalFuture<Map<K,V>>	IgniteTxLocalEx.getAllAsync(GridCacheContext cacheCtx, Collection<KeyCacheObject> keys, boolean deserializePortable, boolean skipVals, boolean keepCacheObjects, boolean skipStore)
IgniteInternalFuture<Void>	IgniteTxLocalAdapter.loadMissing(GridCacheContext cacheCtx, boolean readThrough, boolean async, Collection<KeyCacheObject> keys, boolean skipVals, boolean needVer, boolean keepBinary, GridInClosure3<KeyCacheObject,Object,GridCacheVersion> c)
IgniteInternalFuture<Void>	IgniteTxLocalAdapter.loadMissing(GridCacheContext cacheCtx, boolean readThrough, boolean async, Collection<KeyCacheObject> keys, boolean skipVals, boolean needVer, boolean keepBinary, GridInClosure3<KeyCacheObject,Object,GridCacheVersion> c)
IgniteInternalFuture<Void>	IgniteTxLocalEx.loadMissing(GridCacheContext cacheCtx, boolean readThrough, boolean async, Collection<KeyCacheObject> keys, boolean skipVals, boolean needVer, boolean keepBinary, GridInClosure3<KeyCacheObject,Object,GridCacheVersion> c)
IgniteInternalFuture<Void>	IgniteTxLocalEx.loadMissing(GridCacheContext cacheCtx, boolean readThrough, boolean async, Collection<KeyCacheObject> keys, boolean skipVals, boolean needVer, boolean keepBinary, GridInClosure3<KeyCacheObject,Object,GridCacheVersion> c)
protected void	IgniteTxLocalAdapter.postLockWrite(GridCacheContext cacheCtx, Iterable<KeyCacheObject> keys, GridCacheReturn ret, boolean rmv, boolean retval, boolean read, long accessTtl, CacheEntryPredicate[] filter, boolean computeInvoke) Post lock processing for put or remove.
IgniteInternalFuture<?>	IgniteTxLocalAdapter.putAllDrAsync(GridCacheContext cacheCtx, Map<KeyCacheObject,GridCacheDrInfo> drMap)
IgniteInternalFuture<?>	IgniteTxLocalEx.putAllDrAsync(GridCacheContext cacheCtx, Map<KeyCacheObject,GridCacheDrInfo> drMap)
IgniteInternalFuture<?>	IgniteTxLocalAdapter.removeAllDrAsync(GridCacheContext cacheCtx, Map<KeyCacheObject,GridCacheVersion> drMap)
IgniteInternalFuture<?>	IgniteTxLocalEx.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.receive(IgniteCache<KeyCacheObject,CacheObject> cache0, Collection<Map.Entry<KeyCacheObject,CacheObject>> col) Updates cache with batch of entries.
void	IgniteDrDataStreamerCacheUpdater.receive(IgniteCache<KeyCacheObject,CacheObject> cache0, Collection<Map.Entry<KeyCacheObject,CacheObject>> col) Updates cache with batch of entries.

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

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

Modifier and Type	Method and Description
boolean	GridOffHeapProcessor.contains(String spaceName, int part, KeyCacheObject key, byte[] keyBytes) Checks if offheap space contains value for the given key.
void	GridOffHeapProcessor.enableEviction(String spaceName, int part, KeyCacheObject key, byte[] keyBytes) Enables eviction for entry after GridOffHeapProcessor.valuePointer(java.lang.String, int, org.apache.ignite.internal.processors.cache.KeyCacheObject, byte[]) was called.
byte[]	GridOffHeapProcessor.get(String spaceName, int part, KeyCacheObject key, byte[] keyBytes) Gets value bytes from offheap space for the given key.
<T> T	GridOffHeapProcessor.getValue(String spaceName, int part, KeyCacheObject key, byte[] keyBytes, ClassLoader ldr) Gets value from offheap space for the given key.
void	GridOffHeapProcessor.put(String spaceName, int part, KeyCacheObject key, byte[] keyBytes, byte[] valBytes) Puts the given value to offheap space for the given key.
byte[]	GridOffHeapProcessor.remove(String spaceName, int part, KeyCacheObject key, byte[] keyBytes) Removes value from offheap space for the given key.
boolean	GridOffHeapProcessor.removex(String spaceName, int part, KeyCacheObject key, byte[] keyBytes) Removes value from offheap space for the given key.
boolean	GridOffHeapProcessor.removex(String spaceName, int part, KeyCacheObject key, byte[] keyBytes, IgniteBiPredicate<Long,Integer> p) Removes value from offheap space for the given key.
IgniteBiTuple<Long,Integer>	GridOffHeapProcessor.valuePointer(String spaceName, int part, KeyCacheObject key, byte[] keyBytes) Gets value pointer from offheap space for the given key.

Uses of KeyCacheObject in org.apache.ignite.spi.swapspace

Constructors in org.apache.ignite.spi.swapspace with parameters of type KeyCacheObject

Constructor and Description
SwapKey(KeyCacheObject key, int part, byte[] keyBytes)