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

Packages that use KeyCacheObject

Package	Description
org.apache.ignite.internal	Contains main implementation.
org.apache.ignite.internal.binary	Contains binary APIs internal implementation.
org.apache.ignite.internal.pagemem.wal.record
org.apache.ignite.internal.processors.cache
org.apache.ignite.internal.processors.cache.binary	Implementation of binary processor.
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.dht.topology
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.mvcc
org.apache.ignite.internal.processors.cache.persistence
org.apache.ignite.internal.processors.cache.query
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.tree
org.apache.ignite.internal.processors.cache.tree.mvcc.data
org.apache.ignite.internal.processors.cache.tree.mvcc.search
org.apache.ignite.internal.processors.cache.verify
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.internal.processors.query

Uses of KeyCacheObject in org.apache.ignite.internal

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

Modifier and Type	Method and Description
void	IgniteDiagnosticPrepareContext.txKeyInfo(UUID nodeId, int cacheId, Collection<KeyCacheObject> keys, String msg)

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

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

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

Methods in org.apache.ignite.internal.binary that return KeyCacheObject

Modifier and Type	Method and Description
KeyCacheObject	BinaryObjectImpl.copy(int part)

Uses of KeyCacheObject in org.apache.ignite.internal.pagemem.wal.record

Fields in org.apache.ignite.internal.pagemem.wal.record declared as KeyCacheObject

Modifier and Type	Field and Description
protected KeyCacheObject	DataEntry.key Cache object key.

Methods in org.apache.ignite.internal.pagemem.wal.record that return KeyCacheObject

Modifier and Type	Method and Description
KeyCacheObject	LazyDataEntry.key()
KeyCacheObject	DataEntry.key()
KeyCacheObject	LazyMvccDataEntry.key()

Constructors in org.apache.ignite.internal.pagemem.wal.record with parameters of type KeyCacheObject

Constructor and Description
DataEntry(int cacheId, KeyCacheObject key, CacheObject val, GridCacheOperation op, GridCacheVersion nearXidVer, GridCacheVersion writeVer, long expireTime, int partId, long partCnt)
MvccDataEntry(int cacheId, KeyCacheObject key, CacheObject val, GridCacheOperation op, GridCacheVersion nearXidVer, GridCacheVersion writeVer, long expireTime, int partId, long partCnt, MvccVersion mvccVer)
UnwrapDataEntry(int cacheId, KeyCacheObject key, CacheObject val, GridCacheOperation op, GridCacheVersion nearXidVer, GridCacheVersion writeVer, long expireTime, int partId, long partCnt, CacheObjectValueContext cacheObjValCtx, boolean keepBinary)
UnwrapMvccDataEntry(int cacheId, KeyCacheObject key, CacheObject val, GridCacheOperation op, GridCacheVersion nearXidVer, GridCacheVersion writeVer, long expireTime, int partId, long partCnt, MvccVersion mvccVer, CacheObjectValueContext cacheObjValCtx, boolean keepBinary)

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.

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

Modifier and Type	Field and Description
ConcurrentMap<KeyCacheObject,GridCacheMapEntry>	GridCacheConcurrentMap.CacheMapHolder.map

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

Modifier and Type	Method and Description
KeyCacheObject	KeyCacheObjectImpl.copy(int part)
KeyCacheObject	KeyCacheObject.copy(int part)
KeyCacheObject	GridCacheEntryEx.key()
KeyCacheObject	GridCacheMapEntry.key()
KeyCacheObject	GridCacheEntryInfo.key()
KeyCacheObject	CacheInvokeDirectResult.key()
KeyCacheObject	CacheEvictionEntry.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
GridCloseableIterator<KeyCacheObject>	IgniteCacheOffheapManager.cacheKeysIterator(int cacheId, int part)
GridCloseableIterator<KeyCacheObject>	IgniteCacheOffheapManagerImpl.cacheKeysIterator(int cacheId, int part)
Collection<KeyCacheObject>	GridCacheContext.cacheKeysView(Collection<?> keys)
Map<KeyCacheObject,GridCacheVersion>	IgniteCacheExpiryPolicy.entries()
Map<KeyCacheObject,GridCacheVersion>	GridCacheAdapter.CacheExpiryPolicy.entries()
static IgniteClosure<GridCacheEntryEx,KeyCacheObject>	GridCacheUtils.entry2Key()
Map<UUID,Collection<IgniteBiTuple<KeyCacheObject,GridCacheVersion>>>	IgniteCacheExpiryPolicy.readers()
Map<UUID,Collection<IgniteBiTuple<KeyCacheObject,GridCacheVersion>>>	GridCacheAdapter.CacheExpiryPolicy.readers()

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

Modifier and Type	Method and Description
void	CacheGroupContext.addCacheEvent(int part, KeyCacheObject key, UUID evtNodeId, int type, CacheObject newVal, boolean hasNewVal, CacheObject oldVal, boolean hasOldVal, boolean keepBinary)
void	GridCacheReturn.addEntryProcessResult(GridCacheContext cctx, KeyCacheObject key, Object key0, Object res, Exception err, boolean keepBinary)
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 keepBinary)
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 keepBinary)
<K1,V1> void	GridCacheContext.addResult(Map<K1,V1> map, KeyCacheObject key, CacheObject val, boolean skipVals, boolean keepCacheObjects, boolean deserializeBinary, boolean cpy, EntryGetResult getRes, GridCacheVersion ver, long expireTime, long ttl, boolean needVer)
<K1,V1> void	GridCacheContext.addResult(Map<K1,V1> map, KeyCacheObject key, CacheObject val, boolean skipVals, boolean keepCacheObjects, boolean deserializeBinary, boolean cpy, GridCacheVersion ver, long expireTime, long ttl)
<K1,V1> void	GridCacheContext.addResult(Map<K1,V1> map, KeyCacheObject key, EntryGetResult getRes, boolean skipVals, boolean keepCacheObjects, boolean deserializeBinary, boolean cpy, boolean needVer)
GridCacheMapEntry	GridCacheMapEntryFactory.create(GridCacheContext ctx, AffinityTopologyVersion topVer, KeyCacheObject key)
static GridCacheUtils.BackupPostProcessingClosure	GridCacheUtils.createBackupPostProcessingClosure(AffinityTopologyVersion topVer, IgniteLogger log, GridCacheContext cctx, KeyCacheObject key, IgniteCacheExpiryPolicy expiryPlc, boolean readThrough, boolean skipVals) Creates closure that saves initial value to backup partition.
CacheDataRow	IgniteCacheOffheapManager.CacheDataStore.createRow(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, CacheDataRow oldRow)
CacheDataRow	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.createRow(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, CacheDataRow oldRow)
GridCursor<? extends CacheDataRow>	IgniteCacheOffheapManager.CacheDataStore.cursor(int cacheId, KeyCacheObject lower, KeyCacheObject upper)
GridCursor<? extends CacheDataRow>	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.cursor(int cacheId, KeyCacheObject lower, KeyCacheObject upper)
GridCursor<? extends CacheDataRow>	IgniteCacheOffheapManager.CacheDataStore.cursor(int cacheId, KeyCacheObject lower, KeyCacheObject upper, Object x)
GridCursor<? extends CacheDataRow>	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.cursor(int cacheId, KeyCacheObject lower, KeyCacheObject upper, Object x)
GridCursor<? extends CacheDataRow>	IgniteCacheOffheapManager.CacheDataStore.cursor(int cacheId, KeyCacheObject lower, KeyCacheObject upper, Object x, MvccSnapshot snapshot)
GridCursor<? extends CacheDataRow>	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.cursor(int cacheId, KeyCacheObject lower, KeyCacheObject upper, Object x, MvccSnapshot snapshot)
GridCacheEntryEx	GridCacheAdapter.entryEx(KeyCacheObject key)
GridCacheEntryEx	GridCacheAdapter.entryEx(KeyCacheObject key, AffinityTopologyVersion topVer)
CacheDataRow	IgniteCacheOffheapManager.CacheDataStore.find(GridCacheContext cctx, KeyCacheObject key)
CacheDataRow	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.find(GridCacheContext cctx, KeyCacheObject key)
GridCacheMapEntry	GridNoStorageCacheMap.getEntry(GridCacheContext ctx, KeyCacheObject key) Returns the entry associated with the specified key in the HashMap.
GridCacheMapEntry	GridCacheConcurrentMapImpl.getEntry(GridCacheContext ctx, KeyCacheObject key) Returns the entry associated with the specified key in the HashMap.
GridCacheMapEntry	GridCacheConcurrentMap.getEntry(GridCacheContext ctx, KeyCacheObject key) Returns the entry associated with the specified key in the HashMap.
void	IgniteCacheOffheapManager.invoke(GridCacheContext cctx, KeyCacheObject key, GridDhtLocalPartition part, IgniteCacheOffheapManager.OffheapInvokeClosure c)
void	IgniteCacheOffheapManagerImpl.invoke(GridCacheContext cctx, KeyCacheObject key, GridDhtLocalPartition part, IgniteCacheOffheapManager.OffheapInvokeClosure c)
void	IgniteCacheOffheapManager.CacheDataStore.invoke(GridCacheContext cctx, KeyCacheObject key, IgniteCacheOffheapManager.OffheapInvokeClosure c)
void	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.invoke(GridCacheContext cctx, KeyCacheObject key, IgniteCacheOffheapManager.OffheapInvokeClosure c)
void	GridCacheEntryInfo.key(KeyCacheObject key)
List<IgniteBiTuple<Object,MvccVersion>>	IgniteCacheOffheapManager.mvccAllVersions(GridCacheContext cctx, KeyCacheObject key) For testing only.
List<IgniteBiTuple<Object,MvccVersion>>	IgniteCacheOffheapManagerImpl.mvccAllVersions(GridCacheContext cctx, KeyCacheObject key) For testing only.
GridCursor<CacheDataRow>	IgniteCacheOffheapManager.mvccAllVersionsCursor(GridCacheContext cctx, KeyCacheObject key, Object x) Returns iterator over the all row versions for the given key.
GridCursor<CacheDataRow>	IgniteCacheOffheapManager.CacheDataStore.mvccAllVersionsCursor(GridCacheContext cctx, KeyCacheObject key, Object x) Returns iterator over the all row versions for the given key.
GridCursor<CacheDataRow>	IgniteCacheOffheapManagerImpl.mvccAllVersionsCursor(GridCacheContext cctx, KeyCacheObject key, Object x) Returns iterator over the all row versions for the given key.
GridCursor<CacheDataRow>	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.mvccAllVersionsCursor(GridCacheContext cctx, KeyCacheObject key, Object x) Returns iterator over the all row versions for the given key.
void	IgniteCacheOffheapManager.mvccApplyUpdate(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, GridDhtLocalPartition part, MvccVersion mvccVer)
void	IgniteCacheOffheapManagerImpl.mvccApplyUpdate(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, GridDhtLocalPartition part, MvccVersion mvccVer)
void	IgniteCacheOffheapManager.CacheDataStore.mvccApplyUpdate(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccVersion mvccVer)
void	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.mvccApplyUpdate(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccVersion mvccVer)
CacheDataRow	IgniteCacheOffheapManager.CacheDataStore.mvccFind(GridCacheContext cctx, KeyCacheObject key, MvccSnapshot snapshot)
CacheDataRow	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.mvccFind(GridCacheContext cctx, KeyCacheObject key, MvccSnapshot snapshot)
List<IgniteBiTuple<Object,MvccVersion>>	IgniteCacheOffheapManager.CacheDataStore.mvccFindAllVersions(GridCacheContext cctx, KeyCacheObject key) For testing only.
List<IgniteBiTuple<Object,MvccVersion>>	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.mvccFindAllVersions(GridCacheContext cctx, KeyCacheObject key) For testing only.
boolean	IgniteCacheOffheapManager.CacheDataStore.mvccInitialValue(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccVersion mvccVer, MvccVersion newMvccVer)
boolean	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.mvccInitialValue(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccVersion mvccVer, MvccVersion newMvccVer)
boolean	IgniteCacheOffheapManager.CacheDataStore.mvccInitialValueIfAbsent(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccVersion mvccVer, MvccVersion newMvccVer, byte txState, byte newTxState)
boolean	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.mvccInitialValueIfAbsent(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccVersion mvccVer, MvccVersion newMvccVer, byte txState, byte newTxState)
MvccUpdateResult	IgniteCacheOffheapManager.CacheDataStore.mvccLock(GridCacheContext cctx, KeyCacheObject key, MvccSnapshot mvccSnapshot)
MvccUpdateResult	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.mvccLock(GridCacheContext cctx, KeyCacheObject key, MvccSnapshot mvccSnapshot)
CacheDataRow	IgniteCacheOffheapManager.mvccRead(GridCacheContext cctx, KeyCacheObject key, MvccSnapshot ver)
CacheDataRow	IgniteCacheOffheapManagerImpl.mvccRead(GridCacheContext cctx, KeyCacheObject key, MvccSnapshot ver)
MvccUpdateResult	IgniteCacheOffheapManager.CacheDataStore.mvccRemove(GridCacheContext cctx, KeyCacheObject key, MvccSnapshot mvccSnapshot, CacheEntryPredicate filter, boolean primary, boolean needHistory, boolean needOldVal, boolean retVal)
MvccUpdateResult	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.mvccRemove(GridCacheContext cctx, KeyCacheObject key, MvccSnapshot mvccSnapshot, CacheEntryPredicate filter, boolean primary, boolean needHistory, boolean needOldVal, boolean retVal)
void	IgniteCacheOffheapManager.CacheDataStore.mvccRemoveAll(GridCacheContext cctx, KeyCacheObject key)
void	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.mvccRemoveAll(GridCacheContext cctx, KeyCacheObject key)
GridLongList	IgniteCacheOffheapManager.CacheDataStore.mvccRemoveNative(GridCacheContext cctx, boolean primary, KeyCacheObject key, MvccSnapshot mvccSnapshot)
GridLongList	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.mvccRemoveNative(GridCacheContext cctx, boolean primary, KeyCacheObject key, MvccSnapshot mvccSnapshot)
MvccUpdateResult	IgniteCacheOffheapManager.CacheDataStore.mvccUpdate(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccSnapshot mvccSnapshot, CacheEntryPredicate filter, javax.cache.processor.EntryProcessor entryProc, Object[] invokeArgs, boolean primary, boolean needHist, boolean noCreate, boolean needOldVal, boolean retVal)
MvccUpdateResult	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.mvccUpdate(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccSnapshot mvccSnapshot, CacheEntryPredicate filter, javax.cache.processor.EntryProcessor entryProc, Object[] invokeArgs, boolean primary, boolean needHistory, boolean noCreate, boolean needOldVal, boolean retVal)
GridLongList	IgniteCacheOffheapManager.CacheDataStore.mvccUpdateNative(GridCacheContext cctx, boolean primary, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccSnapshot mvccSnapshot)
GridLongList	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.mvccUpdateNative(GridCacheContext cctx, boolean primary, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccSnapshot mvccSnapshot)
boolean	IgniteCacheOffheapManager.CacheDataStore.mvccUpdateRowWithPreloadInfo(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccVersion mvccVer, MvccVersion newMvccVer, byte mvccTxState, byte newMvccTxState)
boolean	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.mvccUpdateRowWithPreloadInfo(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccVersion mvccVer, MvccVersion newMvccVer, byte mvccTxState, byte newMvccTxState)
protected boolean	GridCacheClearAllRunnable.owns(KeyCacheObject key) Check whether this worker owns particular key.
GridCacheEntryEx	GridCacheAdapter.peekEx(KeyCacheObject key)
protected GridCacheMapEntry	GridCacheConcurrentMapImpl.putEntryIfObsoleteOrAbsent(GridCacheConcurrentMap.CacheMapHolder hld, GridCacheContext ctx, AffinityTopologyVersion topVer, KeyCacheObject key, boolean create, boolean touch)
GridCacheMapEntry	GridNoStorageCacheMap.putEntryIfObsoleteOrAbsent(GridCacheContext ctx, AffinityTopologyVersion topVer, KeyCacheObject key, boolean create, boolean touch)
GridCacheMapEntry	GridCacheConcurrentMapImpl.putEntryIfObsoleteOrAbsent(GridCacheContext ctx, AffinityTopologyVersion topVer, KeyCacheObject key, boolean create, boolean touch)
GridCacheMapEntry	GridCacheConcurrentMap.putEntryIfObsoleteOrAbsent(GridCacheContext ctx, AffinityTopologyVersion topVer, KeyCacheObject key, boolean create, boolean touch)
CacheDataRow	IgniteCacheOffheapManager.read(GridCacheContext cctx, KeyCacheObject key)
CacheDataRow	IgniteCacheOffheapManagerImpl.read(GridCacheContext cctx, KeyCacheObject key)
void	GridCacheEventManager.readEvent(KeyCacheObject key, IgniteInternalTx tx, CacheObject val, UUID subjId, String taskName, boolean keepBinary)
protected Object	GridCacheMapEntry.readThrough(IgniteInternalTx tx, KeyCacheObject key, boolean reload, UUID subjId, String taskName)
void	IgniteCacheOffheapManager.CacheDataStore.remove(GridCacheContext cctx, KeyCacheObject key, int partId)
void	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.remove(GridCacheContext cctx, KeyCacheObject key, int partId)
void	IgniteCacheOffheapManager.remove(GridCacheContext cctx, KeyCacheObject key, int partId, GridDhtLocalPartition part)
void	IgniteCacheOffheapManagerImpl.remove(GridCacheContext cctx, KeyCacheObject key, int partId, GridDhtLocalPartition part)
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	IgniteCacheOffheapManager.CacheDataStore.update(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, CacheDataRow oldRow)
void	IgniteCacheOffheapManagerImpl.CacheDataStoreImpl.update(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, CacheDataRow oldRow)
void	IgniteCacheOffheapManager.update(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, GridDhtLocalPartition part, CacheDataRow oldRow)
void	IgniteCacheOffheapManagerImpl.update(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, GridDhtLocalPartition part, CacheDataRow oldRow)
void	GridCacheContext.validateKeyAndValue(KeyCacheObject key, CacheObject val) Performs validation of provided key and value against configured constraints.

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)
protected <K1,V1> IgniteInternalFuture<Map<K1,V1>>	GridCacheAdapter.getAllAsync0(Collection<KeyCacheObject> keys, ReaderArguments readerArgs, boolean readThrough, boolean checkTx, UUID subjId, String taskName, boolean deserializeBinary, IgniteCacheExpiryPolicy expiry, boolean skipVals, boolean keepCacheObjects, boolean recovery, boolean needVer, MvccSnapshot mvccSnapshot)
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.
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.
GridDhtFuture<Object>	GridCachePreloader.request(GridCacheContext cctx, Collection<KeyCacheObject> keys, AffinityTopologyVersion topVer) Requests that preloader sends the request for the key.
GridDhtFuture<Object>	GridCachePreloaderAdapter.request(GridCacheContext ctx, 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 createTtl, 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(KeyCacheObject keyObj, CacheObject valObj, GridCacheVersion ver, boolean keepBinary, GridCacheEntryEx entry) Constructor.
CacheInvokeEntry(KeyCacheObject keyObj, K key, CacheObject valObj, V val, GridCacheVersion ver, boolean keepBinary, GridCacheEntryEx entry)
CacheLazyEntry(GridCacheContext cctx, KeyCacheObject keyObj, CacheObject valObj, boolean keepBinary)
CacheLazyEntry(GridCacheContext ctx, KeyCacheObject keyObj, K key, CacheObject valObj, V val, boolean keepBinary)
CacheLazyEntry(GridCacheContext ctx, KeyCacheObject keyObj, K key, CacheObject valObj, V val, boolean keepBinary, Long updateCntr)
CacheLazyEntry(GridCacheContext cctx, KeyCacheObject keyObj, V val, boolean keepBinary)
GridCacheMapEntry(GridCacheContext<?,?> cctx, KeyCacheObject key)

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

Constructor and Description
CacheMapHolder(GridCacheContext cctx, ConcurrentMap<KeyCacheObject,GridCacheMapEntry> map)

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

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

Modifier and Type	Method and Description
KeyCacheObject	CacheObjectBinaryProcessorImpl.toCacheKeyObject(CacheObjectContext ctx, GridCacheContext cctx, Object obj, boolean userObj)
KeyCacheObject	CacheObjectBinaryProcessorImpl.toKeyCacheObject(CacheObjectContext ctx, byte type, byte[] bytes)

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)
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 createTtl, long accessTtl)
IgniteInternalFuture<Boolean>	GridDistributedCacheAdapter.txLockAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isRead, boolean retval, TransactionIsolation isolation, boolean isInvalidate, long createTtl, long accessTtl)

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

Constructor and Description
GridDistributedCacheEntry(GridCacheContext ctx, KeyCacheObject key)

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
List<KeyCacheObject>	GridDhtTxQueryEnlistRequest.keys()
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) Adds a Near key.
void	GridDhtLockRequest.addNearKey(KeyCacheObject key, GridCacheSharedContext ctx) Adds a Near key.
protected GridDistributedCacheEntry	GridDhtCacheAdapter.createEntry(KeyCacheObject key)
GridCacheEntryEx	GridDhtCacheAdapter.entryEx(KeyCacheObject key, AffinityTopologyVersion topVer)
GridDhtCacheEntry	GridDhtCacheAdapter.entryExx(KeyCacheObject key)
GridDhtCacheEntry	GridDhtCacheAdapter.entryExx(KeyCacheObject key, AffinityTopologyVersion topVer)
GridCacheMapEntry	GridCachePartitionedConcurrentMap.getEntry(GridCacheContext ctx, KeyCacheObject key) Returns the entry associated with the specified key in the HashMap.
protected void	GridDhtTxQueryAbstractEnlistFuture.onEntryProcessed(KeyCacheObject key, GridCacheUpdateTxResult res) Entry processed callback.
protected abstract void	GridDhtTxAbstractEnlistFuture.onEntryProcessed(KeyCacheObject key, GridCacheUpdateTxResult res) Entry processed callback.
protected void	GridDhtTxEnlistFuture.onEntryProcessed(KeyCacheObject key, GridCacheUpdateTxResult txRes) Entry processed callback.
GridCacheVersion	GridDhtLockRequest.owned(KeyCacheObject key)
void	GridDhtLockRequest.owned(KeyCacheObject key, GridCacheVersion ownerMapped) Sets owner and its mapped version.
GridDhtCacheEntry	GridDhtCacheAdapter.peekExx(KeyCacheObject key)
GridCacheMapEntry	GridCachePartitionedConcurrentMap.putEntryIfObsoleteOrAbsent(GridCacheContext ctx, AffinityTopologyVersion topVer, KeyCacheObject key, boolean create, boolean touch)
protected boolean	GridDhtTxLocal.updateNearCache(GridCacheContext cacheCtx, KeyCacheObject key, AffinityTopologyVersion topVer) Checks whether near cache should be updated.
protected boolean	GridDhtTxRemote.updateNearCache(GridCacheContext cacheCtx, KeyCacheObject key, AffinityTopologyVersion 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, Map<KeyCacheObject,Boolean> keys, boolean addReaders, boolean readThrough, AffinityTopologyVersion topVer, UUID subjId, int taskNameHash, IgniteCacheExpiryPolicy expiry, boolean skipVals, boolean recovery, MvccSnapshot mvccSnapshot)
IgniteInternalFuture<Boolean>	GridDhtTransactionalCacheAdapter.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx txx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long createTtl, long accessTtl)
GridDhtFuture<Boolean>	GridDhtTransactionalCacheAdapter.lockAllAsyncInternal(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx txx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long createTtl, long accessTtl, CacheEntryPredicate[] filter, boolean skipStore, boolean keepBinary) Acquires locks in partitioned cache.
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)
GridDhtGetSingleFuture(GridCacheContext<K,V> cctx, long msgId, UUID reader, KeyCacheObject key, boolean addRdr, boolean readThrough, AffinityTopologyVersion topVer, UUID subjId, int taskNameHash, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean recovery, MvccSnapshot mvccSnapshot)
GridPartitionedSingleGetFuture(GridCacheContext cctx, KeyCacheObject key, AffinityTopologyVersion topVer, boolean readThrough, boolean forcePrimary, UUID subjId, String taskName, boolean deserializeBinary, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean needVer, boolean keepCacheObjects, boolean recovery, MvccSnapshot mvccSnapshot)

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 deserializeBinary, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean needVer, boolean keepCacheObjects, boolean recovery)
GridDhtGetFuture(GridCacheContext<K,V> cctx, long msgId, UUID reader, Map<KeyCacheObject,Boolean> keys, boolean readThrough, AffinityTopologyVersion topVer, UUID subjId, int taskNameHash, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean recovery, boolean addReaders, MvccSnapshot mvccSnapshot)
GridPartitionedGetFuture(GridCacheContext<K,V> cctx, Collection<KeyCacheObject> keys, boolean readThrough, boolean forcePrimary, UUID subjId, String taskName, boolean deserializeBinary, boolean recovery, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean needVer, boolean keepCacheObjects, MvccSnapshot mvccSnapshot)

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

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

Modifier and Type	Field and Description
protected KeyCacheObject	GridDhtAtomicSingleUpdateRequest.key Key to update.
protected KeyCacheObject	GridNearAtomicSingleUpdateRequest.key Key to update.

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

Modifier and Type	Method and Description
KeyCacheObject	GridDhtAtomicSingleUpdateRequest.key(int idx)
abstract KeyCacheObject	GridNearAtomicAbstractUpdateRequest.key(int idx)
abstract KeyCacheObject	GridDhtAtomicAbstractUpdateRequest.key(int idx)
KeyCacheObject	GridDhtAtomicUpdateRequest.key(int idx)
KeyCacheObject	GridNearAtomicSingleUpdateRequest.key(int idx)
KeyCacheObject	GridNearAtomicFullUpdateRequest.key(int idx)
KeyCacheObject	GridDhtAtomicSingleUpdateRequest.nearKey(int idx)
abstract KeyCacheObject	GridDhtAtomicAbstractUpdateRequest.nearKey(int idx)
KeyCacheObject	GridDhtAtomicUpdateRequest.nearKey(int idx)
KeyCacheObject	GridDhtAtomicSingleUpdateRequest.obsoleteNearKey(int idx)
abstract KeyCacheObject	GridDhtAtomicAbstractUpdateRequest.obsoleteNearKey(int idx)
KeyCacheObject	GridDhtAtomicUpdateRequest.obsoleteNearKey(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>	UpdateErrors.failedKeys()
abstract List<KeyCacheObject>	GridNearAtomicAbstractUpdateRequest.keys()
List<KeyCacheObject>	GridNearAtomicSingleUpdateRequest.keys()
List<KeyCacheObject>	GridNearAtomicFullUpdateRequest.keys()

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

Modifier and Type	Method and Description
protected abstract void	GridDhtAtomicAbstractUpdateFuture.addDhtKey(KeyCacheObject key, List<ClusterNode> dhtNodes)
void	GridNearAtomicUpdateResponse.addFailedKey(KeyCacheObject key, Throwable e) Adds key to collection of failed keys.
void	GridDhtAtomicNearResponse.addFailedKey(KeyCacheObject key, Throwable e)
protected abstract void	GridDhtAtomicAbstractUpdateFuture.addNearKey(KeyCacheObject key, GridDhtCacheEntry.ReaderId[] readers)
void	GridDhtAtomicSingleUpdateRequest.addNearWriteValue(KeyCacheObject key, CacheObject val, javax.cache.processor.EntryProcessor<Object,Object,Object> entryProcessor, long ttl, long expireTime)
abstract void	GridDhtAtomicAbstractUpdateRequest.addNearWriteValue(KeyCacheObject key, CacheObject val, javax.cache.processor.EntryProcessor<Object,Object,Object> entryProcessor, long ttl, long expireTime)
void	GridDhtAtomicUpdateRequest.addNearWriteValue(KeyCacheObject key, CacheObject val, javax.cache.processor.EntryProcessor<Object,Object,Object> entryProcessor, long ttl, long expireTime)
void	GridNearAtomicSingleUpdateRequest.addUpdateEntry(KeyCacheObject key, Object val, long conflictTtl, long conflictExpireTime, GridCacheVersion conflictVer)
void	GridNearAtomicFullUpdateRequest.addUpdateEntry(KeyCacheObject key, Object val, long conflictTtl, long conflictExpireTime, GridCacheVersion conflictVer)
void	GridNearAtomicSingleUpdateInvokeRequest.addUpdateEntry(KeyCacheObject key, Object val, long conflictTtl, long conflictExpireTime, GridCacheVersion conflictVer)
void	GridDhtAtomicSingleUpdateRequest.addWriteValue(KeyCacheObject key, CacheObject val, javax.cache.processor.EntryProcessor<Object,Object,Object> entryProcessor, long ttl, long conflictExpireTime, GridCacheVersion conflictVer, boolean addPrevVal, CacheObject prevVal, long updateCntr, GridCacheOperation cacheOp)
abstract void	GridDhtAtomicAbstractUpdateRequest.addWriteValue(KeyCacheObject key, CacheObject val, javax.cache.processor.EntryProcessor<Object,Object,Object> entryProcessor, long ttl, long conflictExpireTime, GridCacheVersion conflictVer, boolean addPrevVal, CacheObject prevVal, long updateCntr, GridCacheOperation cacheOp)
void	GridDhtAtomicUpdateRequest.addWriteValue(KeyCacheObject key, CacheObject val, javax.cache.processor.EntryProcessor<Object,Object,Object> entryProcessor, long ttl, long conflictExpireTime, GridCacheVersion conflictVer, boolean addPrevVal, CacheObject prevVal, long updateCntr, GridCacheOperation cacheOp)
boolean	GridDhtAtomicSingleUpdateRequest.hasKey(KeyCacheObject key)
abstract boolean	GridDhtAtomicAbstractUpdateRequest.hasKey(KeyCacheObject key)
boolean	GridDhtAtomicUpdateRequest.hasKey(KeyCacheObject key)

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

Modifier and Type	Method and Description
protected IgniteInternalFuture<Boolean>	GridDhtAtomicCache.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long createTtl, long accessTtl)
void	GridDhtAtomicUpdateResponse.nearEvicted(List<KeyCacheObject> nearEvicted)
void	GridDhtAtomicCache.putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> conflictMap) Store DR data.
IgniteInternalFuture<?>	GridDhtAtomicCache.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> conflictMap) Store DR data asynchronously.
void	GridDhtAtomicCache.removeAllConflict(Map<KeyCacheObject,GridCacheVersion> conflictMap) Removes DR data.
IgniteInternalFuture<?>	GridDhtAtomicCache.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> conflictMap) Removes DR data asynchronously.

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
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 deserializeBinary, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean needVer, boolean keepCacheObj, boolean recovery, MvccSnapshot mvccSnapshot)

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 deserializeBinary, boolean recovery, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals, boolean needVer, boolean keepCacheObj, MvccSnapshot mvccSnapshot)
IgniteInternalFuture<Boolean>	GridDhtColocatedCache.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long createTtl, 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
GridDhtDetachedCacheEntry(GridCacheContext ctx, KeyCacheObject key)

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 createTtl, long accessTtl, CacheEntryPredicate[] filter, boolean skipStore, boolean keepBinary, boolean recovery)

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(GridCacheContext cctx, 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)

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

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

Modifier and Type	Method and Description
void	GridDhtLocalPartition.onDeferredDelete(int cacheId, KeyCacheObject key, GridCacheVersion ver)

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()
List<KeyCacheObject>	GridNearAtomicCache.processDhtAtomicUpdateRequest(UUID nodeId, GridDhtAtomicAbstractUpdateRequest req, GridDhtAtomicNearResponse res)

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.
GridCacheMapEntry	GridNearCacheAdapter.entryEx(KeyCacheObject key, AffinityTopologyVersion topVer)
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)
<K,V> IgniteInternalFuture<Map<K,V>>	GridNearTxLocal.getAllAsync(GridCacheContext cacheCtx, AffinityTopologyVersion entryTopVer, Collection<KeyCacheObject> keys, boolean deserializeBinary, boolean skipVals, boolean keepCacheObjects, boolean skipStore, boolean recovery, boolean needVer)
IgniteInternalFuture<Map<K,V>>	GridNearCacheAdapter.loadAsync(IgniteInternalTx tx, Collection<KeyCacheObject> keys, boolean forcePrimary, UUID subjId, String taskName, boolean deserializeBinary, boolean recovery, javax.cache.expiry.ExpiryPolicy expiryPlc, boolean skipVal, boolean skipStore, boolean needVer)
protected IgniteInternalFuture<Boolean>	GridNearTransactionalCache.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long createTtl, long accessTtl)
protected IgniteInternalFuture<Boolean>	GridNearAtomicCache.lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long createTtl, long accessTtl)
void	GridNearAtomicCache.putAllConflict(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data.
IgniteInternalFuture<?>	GridNearAtomicCache.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap) Store DR data asynchronously.
IgniteInternalFuture<?>	GridNearTxLocal.putAllDrAsync(GridCacheContext cacheCtx, Map<KeyCacheObject,GridCacheDrInfo> drMap)
void	GridNearAtomicCache.removeAllConflict(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data.
IgniteInternalFuture<?>	GridNearAtomicCache.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap) Removes DR data asynchronously.
IgniteInternalFuture<?>	GridNearTxLocal.removeAllDrAsync(GridCacheContext cacheCtx, Map<KeyCacheObject,GridCacheVersion> drMap)
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)
GridNearLockMapping(ClusterNode node, KeyCacheObject firstKey) Creates near lock mapping for specified node and key.
GridNearSingleGetRequest(int cacheId, long futId, KeyCacheObject key, boolean readThrough, AffinityTopologyVersion topVer, UUID subjId, int taskNameHash, long createTtl, long accessTtl, boolean skipVals, boolean addReader, boolean needVer, boolean addDepInfo, boolean recovery, MvccSnapshot mvccSnapshot)

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

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	GridOsCacheDrManager.replicate(KeyCacheObject key, CacheObject val, long ttl, long expireTime, GridCacheVersion ver, GridDrType drType, AffinityTopologyVersion topVer) Performs replication.
void	GridCacheDrManager.replicate(KeyCacheObject key, CacheObject val, long ttl, long expireTime, GridCacheVersion ver, GridDrType drType, AffinityTopologyVersion topVer) 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
boolean	GridLocalLockFuture.addEntries(Collection<KeyCacheObject> keys)
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 createTtl, long accessTtl)

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 createTtl, long accessTtl)

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

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

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

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

Modifier and Type	Method and Description
void	MvccCachingManager.addEnlisted(KeyCacheObject key, CacheObject val, long ttl, long expireTime, GridCacheVersion ver, CacheObject oldVal, boolean primary, AffinityTopologyVersion topVer, MvccVersion mvccVer, int cacheId, IgniteInternalTx tx, IgniteUuid futId, int batchNum) Adds enlisted tx entry to cache.
Map<UUID,CacheContinuousQueryListener>	MvccCachingManager.continuousQueryListeners(GridCacheContext ctx0, IgniteInternalTx tx, KeyCacheObject key)
boolean	MvccCachingManager.needDrReplicate(GridCacheContext ctx0, KeyCacheObject key)

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

Constructor and Description
MvccTxEntry(KeyCacheObject key, CacheObject val, long ttl, long expireTime, GridCacheVersion ver, CacheObject oldVal, boolean primary, AffinityTopologyVersion topVer, MvccVersion mvccVer, int cacheId)

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

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

Modifier and Type	Field and Description
protected KeyCacheObject	CacheDataRowAdapter.key

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

Modifier and Type	Method and Description
KeyCacheObject	CacheDataRowAdapter.key()
KeyCacheObject	CacheSearchRow.key()

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

Modifier and Type	Method and Description
CacheDataRow	GridCacheOffheapManager.GridCacheDataStore.createRow(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, CacheDataRow oldRow)
GridCursor<? extends CacheDataRow>	GridCacheOffheapManager.GridCacheDataStore.cursor(int cacheId, KeyCacheObject lower, KeyCacheObject upper)
GridCursor<? extends CacheDataRow>	GridCacheOffheapManager.GridCacheDataStore.cursor(int cacheId, KeyCacheObject lower, KeyCacheObject upper, Object x)
GridCursor<? extends CacheDataRow>	GridCacheOffheapManager.GridCacheDataStore.cursor(int cacheId, KeyCacheObject lower, KeyCacheObject upper, Object x, MvccSnapshot mvccSnapshot)
CacheDataRow	GridCacheOffheapManager.GridCacheDataStore.find(GridCacheContext cctx, KeyCacheObject key)
void	GridCacheOffheapManager.GridCacheDataStore.invoke(GridCacheContext cctx, KeyCacheObject key, IgniteCacheOffheapManager.OffheapInvokeClosure c)
void	CacheDataRowAdapter.key(KeyCacheObject key)
void	CacheDataRow.key(KeyCacheObject key)
GridCursor<CacheDataRow>	GridCacheOffheapManager.GridCacheDataStore.mvccAllVersionsCursor(GridCacheContext cctx, KeyCacheObject key, Object x) Returns iterator over the all row versions for the given key.
void	GridCacheOffheapManager.GridCacheDataStore.mvccApplyUpdate(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccVersion mvccVer)
CacheDataRow	GridCacheOffheapManager.GridCacheDataStore.mvccFind(GridCacheContext cctx, KeyCacheObject key, MvccSnapshot snapshot)
List<IgniteBiTuple<Object,MvccVersion>>	GridCacheOffheapManager.GridCacheDataStore.mvccFindAllVersions(GridCacheContext cctx, KeyCacheObject key) For testing only.
boolean	GridCacheOffheapManager.GridCacheDataStore.mvccInitialValue(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccVersion mvccVer, MvccVersion newMvccVer)
boolean	GridCacheOffheapManager.GridCacheDataStore.mvccInitialValueIfAbsent(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccVersion mvccVer, MvccVersion newMvccVer, byte txState, byte newTxState)
MvccUpdateResult	GridCacheOffheapManager.GridCacheDataStore.mvccLock(GridCacheContext cctx, KeyCacheObject key, MvccSnapshot mvccSnapshot)
MvccUpdateResult	GridCacheOffheapManager.GridCacheDataStore.mvccRemove(GridCacheContext cctx, KeyCacheObject key, MvccSnapshot mvccVer, CacheEntryPredicate filter, boolean primary, boolean needHistory, boolean needOldVal, boolean retVal)
void	GridCacheOffheapManager.GridCacheDataStore.mvccRemoveAll(GridCacheContext cctx, KeyCacheObject key)
GridLongList	GridCacheOffheapManager.GridCacheDataStore.mvccRemoveNative(GridCacheContext cctx, boolean primary, KeyCacheObject key, MvccSnapshot mvccSnapshot)
MvccUpdateResult	GridCacheOffheapManager.GridCacheDataStore.mvccUpdate(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccSnapshot mvccVer, CacheEntryPredicate filter, javax.cache.processor.EntryProcessor entryProc, Object[] invokeArgs, boolean primary, boolean needHistory, boolean noCreate, boolean needOldVal, boolean retVal)
GridLongList	GridCacheOffheapManager.GridCacheDataStore.mvccUpdateNative(GridCacheContext cctx, boolean primary, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccSnapshot mvccSnapshot)
boolean	GridCacheOffheapManager.GridCacheDataStore.mvccUpdateRowWithPreloadInfo(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccVersion mvccVer, MvccVersion newMvccVer, byte mvccTxState, byte newMvccTxState)
void	GridCacheOffheapManager.GridCacheDataStore.remove(GridCacheContext cctx, KeyCacheObject key, int partId)
void	GridCacheOffheapManager.GridCacheDataStore.update(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, CacheDataRow oldRow)

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

Constructor and Description
CacheDataRowAdapter(KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime)

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

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

Modifier and Type	Method and Description
void	GridCacheQueryManager.remove(KeyCacheObject key, CacheDataRow prevRow)

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, GridDhtAtomicAbstractUpdateFuture fut, AffinityTopologyVersion topVer)
void	CacheContinuousQueryManager.onEntryUpdated(Map<UUID,CacheContinuousQueryListener> lsnrCol, KeyCacheObject key, CacheObject newVal, CacheObject oldVal, boolean internal, int partId, boolean primary, boolean preload, long updateCntr, GridDhtAtomicAbstractUpdateFuture fut, 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.
boolean	CacheStoreManager.put(IgniteInternalTx tx, KeyCacheObject key, CacheObject val, GridCacheVersion ver) Puts key-value pair into storage.
boolean	GridCacheStoreManagerAdapter.put(IgniteInternalTx tx, KeyCacheObject key, CacheObject val, GridCacheVersion ver) Puts key-value pair into storage.
boolean	CacheStoreManager.remove(IgniteInternalTx tx, KeyCacheObject key)
boolean	GridCacheStoreManagerAdapter.remove(IgniteInternalTx tx, KeyCacheObject key)

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)
boolean	CacheStoreManager.putAll(IgniteInternalTx tx, Map<? extends KeyCacheObject,IgniteBiTuple<? extends CacheObject,GridCacheVersion>> map) Puts key-value pair into storage.
boolean	GridCacheStoreManagerAdapter.putAll(IgniteInternalTx tx, Map<? extends KeyCacheObject,IgniteBiTuple<? extends CacheObject,GridCacheVersion>> map) Puts key-value pair into storage.
boolean	CacheStoreManager.removeAll(IgniteInternalTx tx, Collection<? extends KeyCacheObject> keys)
boolean	GridCacheStoreManagerAdapter.removeAll(IgniteInternalTx tx, Collection<? extends KeyCacheObject> keys)

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 with parameters of type KeyCacheObject

Modifier and Type	Method and Description
GridTuple<CacheObject>	IgniteTxLocalAdapter.peek(GridCacheContext cacheCtx, boolean failFast, KeyCacheObject key)
GridTuple<CacheObject>	IgniteInternalTx.peek(GridCacheContext ctx, boolean failFast, KeyCacheObject key)
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)
void	IgniteTxHandler.mvccEnlistBatch(GridDhtTxRemote tx, GridCacheContext ctx, EnlistOperation op, List<KeyCacheObject> keys, List<Message> vals, MvccSnapshot snapshot, IgniteUuid futId, int batchNum) Writes updated values on the backup node.
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.

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

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

Modifier and Type	Field and Description
KeyCacheObject	PendingRow.key

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

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

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

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

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

Constructor and Description
DataRow(KeyCacheObject key, CacheObject val, GridCacheVersion ver, int part, long expireTime, int cacheId)
SearchRow(int cacheId, KeyCacheObject key)

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.tree.mvcc.data

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

Constructor and Description
MvccDataRow(KeyCacheObject key, CacheObject val, GridCacheVersion ver, int part, long expireTime, int cacheId, MvccVersion mvccVer, MvccVersion newMvccVer)
MvccUpdateDataRow(GridCacheContext cctx, KeyCacheObject key, CacheObject val, GridCacheVersion ver, int part, long expireTime, MvccSnapshot mvccSnapshot, MvccVersion newVer, CacheEntryPredicate filter, boolean primary, boolean lockOnly, boolean needHist, boolean fastUpdate, boolean needOldVal, boolean needPrevValue)
MvccUpdateDataRowNative(KeyCacheObject key, CacheObject val, GridCacheVersion ver, long expireTime, MvccSnapshot mvccSnapshot, MvccVersion newVer, int part, GridCacheContext cctx)

Uses of KeyCacheObject in org.apache.ignite.internal.processors.cache.tree.mvcc.search

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

Constructor and Description
MvccLinkAwareSearchRow(int cacheId, KeyCacheObject key, long crdVer, long mvccCntr, int mvccOpCntr, long link)
MvccMaxSearchRow(int cacheId, KeyCacheObject key)
MvccMinSearchRow(int cacheId, KeyCacheObject key)
MvccSearchRow(int cacheId, KeyCacheObject key, long crdVer, long cntr, int opCntr)
MvccSnapshotSearchRow(GridCacheContext cctx, KeyCacheObject key, MvccSnapshot snapshot) Constructor.

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

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

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

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

Constructor and Description
PartitionEntryHashRecord(int cacheId, String cacheName, KeyCacheObject key, String keyStr, byte[] keyBytes, GridCacheVersion ver, int valHash)
PartitionEntryHashRecord(int cacheId, String cacheName, KeyCacheObject key, String keyStr, byte[] keyBytes, GridCacheVersion ver, int valHash, CacheObject val, String valStr, byte[] valBytes)

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
GridCacheLazyPlainVersionedEntry(GridCacheContext cctx, KeyCacheObject keyObj, CacheObject valObj, long ttl, long expireTime, GridCacheVersion ver, boolean keepBinary)
GridCacheLazyPlainVersionedEntry(GridCacheContext cctx, KeyCacheObject keyObj, CacheObject valObj, long ttl, long expireTime, GridCacheVersion ver, boolean isStartVer, boolean keepBinary)
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

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

Modifier and Type	Class and Description
class	UserKeyCacheObjectImpl Wraps key provided by user, must be serialized before stored in cache.

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

Modifier and Type	Method and Description
KeyCacheObject	UserKeyCacheObjectImpl.copy(int part)
KeyCacheObject	IgniteCacheObjectProcessor.toCacheKeyObject(CacheObjectContext ctx, GridCacheContext cctx, Object obj, boolean userObj)
KeyCacheObject	IgniteCacheObjectProcessorImpl.toCacheKeyObject(CacheObjectContext ctx, GridCacheContext cctx, Object obj, boolean userObj)
protected KeyCacheObject	IgniteCacheObjectProcessorImpl.toCacheKeyObject0(CacheObjectContext ctx, GridCacheContext cctx, Object obj, boolean userObj)
KeyCacheObject	IgniteCacheObjectProcessor.toKeyCacheObject(CacheObjectContext ctx, byte type, byte[] bytes)
KeyCacheObject	IgniteCacheObjectProcessorImpl.toKeyCacheObject(CacheObjectContext ctx, byte type, byte[] bytes)

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)

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

Modifier and Type	Method and Description
void	DataStreamerImpl.IsolatedUpdater.receive(IgniteCache<KeyCacheObject,CacheObject> cache, Collection<Map.Entry<KeyCacheObject,CacheObject>> entries) Updates cache with batch of entries.
void	DataStreamerImpl.IsolatedUpdater.receive(IgniteCache<KeyCacheObject,CacheObject> cache, Collection<Map.Entry<KeyCacheObject,CacheObject>> entries) Updates cache with batch of entries.

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.internal.processors.query

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

Modifier and Type	Method and Description
boolean	GridQueryProcessor.belongsToTable(GridCacheContext cctx, String expCacheName, String expTblName, KeyCacheObject key, CacheObject val) Check whether provided key and value belongs to expected cache and table.
void	GridQueryProcessor.validateKeyAndValue(CacheObjectContext coctx, KeyCacheObject key, CacheObject val) Performs validation of provided key and value against configured constraints.