GridCacheContext (gridgain-core 6.1.9 API)

java.lang.Object
- org.gridgain.grid.kernal.processors.cache.GridCacheContext<K,V>

All Implemented Interfaces:: Externalizable, Serializable

@GridToStringExclude
public class GridCacheContext<K,V>
extends Object
implements Externalizable

Cache context.

See Also:: Serialized Form

Constructor Summary

Constructors
Constructor and Description
`GridCacheContext()` Empty constructor required for `Externalizable`.
GridCacheContext(GridKernalContext ctx, GridCacheConfiguration cacheCfg, GridCacheMvccManager<K,V> mvccMgr, GridCacheVersionManager<K,V> verMgr, GridCacheEventManager<K,V> evtMgr, GridCacheSwapManager<K,V> swapMgr, GridCacheStoreManager<K,V> storeMgr, GridCacheDeploymentManager<K,V> depMgr, GridCacheEvictionManager<K,V> evictMgr, GridCacheIoManager<K,V> ioMgr, GridCacheQueryManager<K,V> qryMgr, GridCacheContinuousQueryManager<K,V> contQryMgr, GridCacheDgcManager<K,V> dgcMgr, GridCacheAffinityManager<K,V> affMgr, GridCacheTxManager<K,V> txMgr, GridCacheDataStructuresManager<K,V> dataStructuresMgr, GridCacheTtlManager<K,V> ttlMgr, GridCacheDrManager<K,V> drMgr, GridCacheJtaManagerAdapter<K,V> jtaMgr)

Method Summary

Methods
Modifier and Type	Method and Description
`GridCacheAffinityManager<K,V>`	`affinity()`
`boolean`	`atomic()`
`GridCacheAdapter<K,V>`	`cache()`
`void`	`cache(GridCacheAdapter<K,V> cache)`
`boolean`	`cancelRemove(GridBiTuple<Boolean,?> interceptorRes)`
`void`	`checkSecurity(GridSecurityPermission op)`
`void`	`checkTxFlags(Collection<GridCacheFlag> flags)`
`void`	`cleanup()` Nulling references to potentially leak-prone objects.
`<T> T`	`cloneOnFlag(T obj)` Clones cached object depending on whether or not `GridCacheFlag.CLONE` flag is set thread locally.
`<T> T`	`cloneValue(T obj)` Clone cached object.
`GridClosureProcessor`	`closures()`
`GridDhtColocatedCache<K,V>`	`colocated()`
`GridCacheConfiguration`	`config()`
`GridCacheContinuousQueryManager<K,V>`	`continuousQueries()`
`GridCacheDataStructuresManager<K,V>`	`dataStructures()`
`void`	`decrementPublicSize(GridCacheMapEntry<K,V> e)`
`boolean`	`deferredDelete()`
`void`	`denyOnFlag(GridCacheFlag flag)`
`void`	`denyOnFlags(Collection<GridCacheFlag> flags)`
`void`	`denyOnFlags(GridCacheFlag[] flags)`
`void`	`denyOnLocalRead()`
`GridCacheDeploymentManager<K,V>`	`deploy()`
`boolean`	`deploymentEnabled()`
`GridCacheDgcManager<K,V>`	`dgc()`
`GridDhtCacheAdapter<K,V>`	`dht()`
`boolean`	`dhtMap(UUID nearNodeId, long topVer, GridDhtCacheEntry<K,V> entry, GridLogger log, Map<GridNode,List<GridDhtCacheEntry<K,V>>> dhtMap, Map<GridNode,List<GridDhtCacheEntry<K,V>>> nearMap)`
`GridDhtTransactionalCacheAdapter<K,V>`	`dhtTx()`
`GridDiscoveryManager`	`discovery()`
`GridCacheDrManager<K,V>`	`dr()`
`boolean`	`drNeedResolve(GridCacheVersion oldVer, GridCacheVersion newVer)` Check whether DR conflict resolution is required.
`GridDrReceiverConflictContextImpl<K,V>`	`drResolveConflict(K key, GridDrEntry<K,V> oldEntry, GridDrEntry<K,V> newEntry)` Resolve DR conflict.
`GridCacheVersion[]`	`emptyVersion()`
`GridPredicate<GridCacheEntry<K,V>>[]`	`equalsPeekArray(V val)`
`GridCacheEventManager<K,V>`	`events()`
`GridCacheEvictionManager<K,V>`	`evicts()`
`GridCachePeekMode[]`	`excludePeekModes(GridCachePeekMode[] modes)` Force peek mode excludes for current thread.
`GridCacheFlag[]`	`forcedFlags()` Gets forced flags for current thread.
`GridCacheFlag[]`	`forceFlags(GridCacheFlag[] flags)` Force projection flags for the current thread.
`GridCacheFlag[]`	`forceLocal()` Forces LOCAL flag.
`GridCacheFlag[]`	`forceLocalRead()` Forces LOCAL and READ flags.
`GridCacheGateway<K,V>`	`gate()`
`Grid`	`grid()`
`GridConfiguration`	`gridConfig()`
`GridDeploymentManager`	`gridDeploy()`
`GridEventStorageManager`	`gridEvents()`
`GridIoManager`	`gridIO()`
`String`	`gridName()`
`GridSwapSpaceManager`	`gridSwap()`
`boolean`	`hasAnyFlags(Collection<GridCacheFlag> flags)` Checks whether any of the given flags is set.
`boolean`	`hasAnyFlags(GridCacheFlag[] flags)` Checks whether any of the given flags is set.
`boolean`	`hasFlag(GridCacheFlag flag)`
`GridPredicate<GridCacheEntry<K,V>>[]`	`hasGetArray()`
`boolean`	`hasKey(Iterable<? extends K> keys, Collection<Integer> movingParts)` Checks if at least one of the given keys belongs to one of the given partitions.
`GridPredicate<GridCacheEntry<K,V>>[]`	`hasPeekArray()`
`void`	`incrementPublicSize(GridCacheMapEntry<K,V> e)`
`GridCacheIoManager<K,V>`	`io()`
`<E> boolean`	`isAll(E e, GridPredicate<? super E>[] p)` Same as `GridFunc.isAll(Object, GridPredicate[])`, but safely unwraps exceptions.
`<K,V> boolean`	`isAll(GridCacheEntryEx<K,V> e, GridPredicate<GridCacheEntry<K,V>>[] p)` Same as `GridFunc.isAll(Object, GridPredicate[])`, but safely unwraps exceptions.
`boolean`	`isColocated()`
`boolean`	`isDht()`
`boolean`	`isDhtAtomic()`
`boolean`	`isDrEnabled()`
`boolean`	`isInvalidate()`
`boolean`	`isLocal()`
`boolean`	`isLocalNode(GridNode n)`
`boolean`	`isLocalNode(UUID id)`
`boolean`	`isNear()`
`boolean`	`isOffHeapEnabled()`
`boolean`	`isReplicated()`
`boolean`	`isStoreEnabled()`
`boolean`	`isSwapOrOffheapEnabled()`
`boolean`	`isUnmarshalValues()`
`GridCacheJtaManagerAdapter<K,V>`	`jta()`
`GridKernalContext`	`kernalContext()`
`GridLocalCache<K,V>`	`local()`
`GridNode`	`localNode()`
`UUID`	`localNodeId()`
`GridLogger`	`logger(Class<?> cls)`
`GridLogger`	`logger(String ctgr)`
`List<GridCacheManager<K,V>>`	`managers()`
`GridMarshaller`	`marshaller()`
`GridCacheMvccManager<K,V>`	`mvcc()`
`String`	`name()`
`String`	`namex()` Gets public name for cache.
`String`	`namexx()` Gets public cache name substituting null name by `'default'`.
`GridNearCacheAdapter<K,V>`	`near()`
`GridNearTransactionalCache<K,V>`	`nearTx()`
`GridNode`	`node(UUID nodeId)`
`UUID`	`nodeId()`
`GridPredicate<GridCacheEntry<K,V>>[]`	`noGetArray()`
`GridPredicate<GridCacheEntry<K,V>>[]`	`noPeekArray()`
`GridOffHeapProcessor`	`offheap()`
`void`	`onDeferredDelete(GridCacheEntryEx<K,V> entry, GridCacheVersion ver)`
`GridFuture<?>`	`partitionReleaseFuture(Collection<Integer> parts, long topVer)` Waits for partition locks and transactions release.
`boolean`	`peekModeExcluded(GridCachePeekMode mode)`
`GridCachePeekMode[]`	`peekModeExcludes()`
`boolean`	`preloadEnabled()`
`GridCachePreloader<K,V>`	`preloader()`
`long`	`preloadExchangeTimeout()`
`void`	`printMemoryStats()` Print memory statistics of all cache managers.
`GridCacheProjectionImpl<K,V>`	`projectionPerCall()` Gets thread local projection.
`<T> Callable<T>`	`projectSafe(Callable<T> r)` Creates callable that can be executed safely in a different thread inheriting the same thread local projection as for the current thread.
`Runnable`	`projectSafe(Runnable r)` Creates Runnable that can be executed safely in a different thread inheriting the same thread local projection as for the current thread.
`GridCacheQueryManager<K,V>`	`queries()`
`void`	`readExternal(ObjectInput in)`
`protected Object`	`readResolve()` Reconstructs object on demarshalling.
`GridCacheStoreManager<K,V>`	`store()`
`UUID`	`subjectIdPerCall(UUID subjId)` Gets subject ID per call.
`GridCacheSwapManager<K,V>`	`swap()`
`boolean`	`syncCommit()`
`boolean`	`syncPrimary()`
`boolean`	`syncRollback()`
`GridTimeoutProcessor`	`time()`
`GridCacheTxManager<K,V>`	`tm()`
`GridDhtPartitionTopology<K,V>`	`topology()`
`GridDhtTopologyFuture`	`topologyVersionFuture()`
`String`	`toString()`
`boolean`	`transactional()`
`GridPredicate<GridCacheEntry<K,V>>[]`	`trueArray()`
`GridPredicate<GridCacheEntry<K,V>>`	`truex()`
`GridCacheTtlManager<K,V>`	`ttl()`
`GridUnsafeMemory`	`unsafeMemory()`
`GridPredicate<GridCacheEntry<K,V>>[]`	`vararg(GridPredicate<GridCacheEntry<K,V>> p)`
`GridCacheVersionManager<K,V>`	`versions()`
`GridFuture<V>`	`wrapClone(GridFuture<V> f)`
`GridFuture<Map<K,V>>`	`wrapCloneMap(GridFuture<Map<K,V>> f)`
`void`	`writeExternal(ObjectOutput out)`
`boolean`	`writeToStoreFromDht()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - GridCacheContext
```
public GridCacheContext()
```
    Empty constructor required for Externalizable.
  - GridCacheContext
```
public GridCacheContext(GridKernalContext ctx,
                GridCacheConfiguration cacheCfg,
                GridCacheMvccManager<K,V> mvccMgr,
                GridCacheVersionManager<K,V> verMgr,
                GridCacheEventManager<K,V> evtMgr,
                GridCacheSwapManager<K,V> swapMgr,
                GridCacheStoreManager<K,V> storeMgr,
                GridCacheDeploymentManager<K,V> depMgr,
                GridCacheEvictionManager<K,V> evictMgr,
                GridCacheIoManager<K,V> ioMgr,
                GridCacheQueryManager<K,V> qryMgr,
                GridCacheContinuousQueryManager<K,V> contQryMgr,
                GridCacheDgcManager<K,V> dgcMgr,
                GridCacheAffinityManager<K,V> affMgr,
                GridCacheTxManager<K,V> txMgr,
                GridCacheDataStructuresManager<K,V> dataStructuresMgr,
                GridCacheTtlManager<K,V> ttlMgr,
                GridCacheDrManager<K,V> drMgr,
                GridCacheJtaManagerAdapter<K,V> jtaMgr)
```
    Parameters:
    ctx - Kernal context.
    cacheCfg - Cache configuration.
    mvccMgr - Cache locking manager.
    verMgr - Cache version manager.
    evtMgr - Cache event manager.
    swapMgr - Cache swap manager.
    storeMgr - Store manager.
    depMgr - Cache deployment manager.
    evictMgr - Cache eviction manager.
    ioMgr - Cache communication manager.
    qryMgr - Cache query manager.
    contQryMgr - Continuous query manager.
    dgcMgr - Distributed garbage collector manager.
    affMgr - Affinity manager.
    txMgr - Cache transaction manager.
    dataStructuresMgr - Cache dataStructures manager.
    ttlMgr - TTL manager.
    drMgr - Data center replication manager.
    jtaMgr - JTA manager.
- Method Detail
  - managers
```
public List<GridCacheManager<K,V>> managers()
```
    Returns:
    Cache managers.
  - cache
```
public void cache(GridCacheAdapter<K,V> cache)
```
    Parameters:
    cache - Cache.
  - local
```
public GridLocalCache<K,V> local()
```
    Returns:
    Local cache.
  - isDht
```
public boolean isDht()
```
    Returns:
    True if cache is DHT.
  - isDhtAtomic
```
public boolean isDhtAtomic()
```
    Returns:
    True if cache is DHT atomic.
  - isColocated
```
public boolean isColocated()
```
    Returns:
    True if cache is colocated (dht with near disabled).
  - isNear
```
public boolean isNear()
```
    Returns:
    True if cache is near cache.
  - isLocal
```
public boolean isLocal()
```
    Returns:
    True if cache is local.
  - isReplicated
```
public boolean isReplicated()
```
    Returns:
    True if cache is replicated cache.
  - isDrEnabled
```
public boolean isDrEnabled()
```
    Returns:
    True in case replication is enabled.
  - deferredDelete
```
public boolean deferredDelete()
```
    Returns:
    True if entries should not be deleted from cache immediately.
  - incrementPublicSize
```
public void incrementPublicSize(GridCacheMapEntry<K,V> e)
```
    Parameters:
    e - Entry.
  - decrementPublicSize
```
public void decrementPublicSize(GridCacheMapEntry<K,V> e)
```
    Parameters:
    e - Entry.
  - dht
```
public GridDhtCacheAdapter<K,V> dht()
```
    Returns:
    DHT cache.
  - dhtTx
```
public GridDhtTransactionalCacheAdapter<K,V> dhtTx()
```
    Returns:
    Transactional DHT cache.
  - colocated
```
public GridDhtColocatedCache<K,V> colocated()
```
    Returns:
    Colocated cache.
  - near
```
public GridNearCacheAdapter<K,V> near()
```
    Returns:
    Near cache.
  - nearTx
```
public GridNearTransactionalCache<K,V> nearTx()
```
    Returns:
    Near cache for transactional mode.
  - gate
```
public GridCacheGateway<K,V> gate()
```
    Returns:
    Cache gateway.
  - unsafeMemory
```
@Nullable
public GridUnsafeMemory unsafeMemory()
```
    Returns:
    Instance of GridUnsafeMemory object.
  - kernalContext
```
public GridKernalContext kernalContext()
```
    Returns:
    Kernal context.
  - grid
```
public Grid grid()
```
    Returns:
    Grid instance.
  - gridName
```
public String gridName()
```
    Returns:
    Grid name.
  - name
```
public String name()
```
    Returns:
    Cache name.
  - namex
```
public String namex()
```
    Gets public name for cache.
    
    Returns:
    Public name of the cache.
  - namexx
```
public String namexx()
```
    Gets public cache name substituting null name by 'default'.
    
    Returns:
    Public cache name substituting null name by 'default'.
  - checkSecurity
```
public void checkSecurity(GridSecurityPermission op)
                   throws GridSecurityException
```
    Parameters:
    op - Operation to check.
    
    Throws:
    
    GridSecurityException - If security check failed.
  - preloader
```
public GridCachePreloader<K,V> preloader()
```
    Returns:
    Preloader.
  - nodeId
```
public UUID nodeId()
```
    Returns:
    Local node ID.
  - preloadEnabled
```
public boolean preloadEnabled()
```
    Returns:
    True if preload is enabled.
  - atomic
```
public boolean atomic()
```
    Returns:
    True if atomic.
  - transactional
```
public boolean transactional()
```
    Returns:
    True if transactional.
  - localNode
```
public GridNode localNode()
```
    Returns:
    Local node.
  - localNodeId
```
public UUID localNodeId()
```
    Returns:
    Local node ID.
  - isLocalNode
```
public boolean isLocalNode(GridNode n)
```
    Parameters:
    n - Node to check.
    
    Returns:
    True if node is local.
  - isLocalNode
```
public boolean isLocalNode(UUID id)
```
    Parameters:
    id - Node ID to check.
    
    Returns:
    True if node ID is local.
  - node
```
@Nullable
public GridNode node(UUID nodeId)
```
    Parameters:
    nodeId - Node id.
    
    Returns:
    Node.
  - topology
```
public GridDhtPartitionTopology<K,V> topology()
```
    Returns:
    Partition topology.
  - topologyVersionFuture
```
public GridDhtTopologyFuture topologyVersionFuture()
```
    Returns:
    Topology version future.
  - marshaller
```
public GridMarshaller marshaller()
```
    Returns:
    Marshaller.
  - logger
```
public GridLogger logger(String ctgr)
```
    Parameters:
    ctgr - Category to log.
    
    Returns:
    Logger.
  - logger
```
public GridLogger logger(Class<?> cls)
```
    Parameters:
    cls - Class to log.
    
    Returns:
    Logger.
  - gridConfig
```
public GridConfiguration gridConfig()
```
    Returns:
    Grid configuration.
  - gridIO
```
public GridIoManager gridIO()
```
    Returns:
    Grid communication manager.
  - time
```
public GridTimeoutProcessor time()
```
    Returns:
    Grid timeout processor.
  - offheap
```
public GridOffHeapProcessor offheap()
```
    Returns:
    Grid off-heap processor.
  - gridDeploy
```
public GridDeploymentManager gridDeploy()
```
    Returns:
    Grid deployment manager.
  - gridSwap
```
public GridSwapSpaceManager gridSwap()
```
    Returns:
    Grid swap space manager.
  - gridEvents
```
public GridEventStorageManager gridEvents()
```
    Returns:
    Grid event storage manager.
  - closures
```
public GridClosureProcessor closures()
```
    Returns:
    Closures processor.
  - discovery
```
public GridDiscoveryManager discovery()
```
    Returns:
    Grid discovery manager.
  - cache
```
public GridCacheAdapter<K,V> cache()
```
    Returns:
    Cache instance.
  - config
```
public GridCacheConfiguration config()
```
    Returns:
    Cache configuration for given cache instance.
  - writeToStoreFromDht
```
public boolean writeToStoreFromDht()
```
    Returns:
    True If store writes should be performed from dht transactions. This happens if both writeBehindEnabled and writeBehindPreferPrimary cache configuration properties are set to true or the store is local.
  - tm
```
public GridCacheTxManager<K,V> tm()
```
    Returns:
    Cache transaction manager.
  - affinity
```
public GridCacheAffinityManager<K,V> affinity()
```
    Returns:
    Cache affinity manager.
  - versions
```
public GridCacheVersionManager<K,V> versions()
```
    Returns:
    Lock order manager.
  - mvcc
```
public GridCacheMvccManager<K,V> mvcc()
```
    Returns:
    Lock manager.
  - events
```
public GridCacheEventManager<K,V> events()
```
    Returns:
    Event manager.
  - queries
```
@Nullable
public GridCacheQueryManager<K,V> queries()
```
    Returns:
    Query manager.
  - continuousQueries
```
@Nullable
public GridCacheContinuousQueryManager<K,V> continuousQueries()
```
    Returns:
    Continuous query manager.
  - swap
```
public GridCacheSwapManager<K,V> swap()
```
    Returns:
    Swap manager.
  - store
```
public GridCacheStoreManager<K,V> store()
```
    Returns:
    Store manager.
  - dgc
```
public GridCacheDgcManager<K,V> dgc()
```
    Returns:
    Swap manager.
  - deploy
```
public GridCacheDeploymentManager<K,V> deploy()
```
    Returns:
    Cache deployment manager.
  - io
```
public GridCacheIoManager<K,V> io()
```
    Returns:
    Cache communication manager.
  - evicts
```
public GridCacheEvictionManager<K,V> evicts()
```
    Returns:
    Eviction manager.
  - dataStructures
```
public GridCacheDataStructuresManager<K,V> dataStructures()
```
    Returns:
    Data structures manager.
  - dr
```
public GridCacheDrManager<K,V> dr()
```
    Returns:
    DR manager.
  - ttl
```
public GridCacheTtlManager<K,V> ttl()
```
    Returns:
    TTL manager.
  - jta
```
public GridCacheJtaManagerAdapter<K,V> jta()
```
    Returns:
    JTA manager.
  - noGetArray
```
public GridPredicate<GridCacheEntry<K,V>>[] noGetArray()
```
    Returns:
    No get-value filter.
  - hasGetArray
```
public GridPredicate<GridCacheEntry<K,V>>[] hasGetArray()
```
    Returns:
    Has get-value filer.
  - noPeekArray
```
public GridPredicate<GridCacheEntry<K,V>>[] noPeekArray()
```
    Returns:
    No get-value filter.
  - hasPeekArray
```
public GridPredicate<GridCacheEntry<K,V>>[] hasPeekArray()
```
    Returns:
    Has get-value filer.
  - equalsPeekArray
```
public GridPredicate<GridCacheEntry<K,V>>[] equalsPeekArray(V val)
```
    Parameters:
    val - Value to check.
    
    Returns:
    Predicate array that checks for value.
  - truex
```
public GridPredicate<GridCacheEntry<K,V>> truex()
```
    Returns:
    Empty filter.
  - trueArray
```
public GridPredicate<GridCacheEntry<K,V>>[] trueArray()
```
    Returns:
    No-op array.
  - emptyVersion
```
public GridCacheVersion[] emptyVersion()
```
    Returns:
    Empty cache version array.
  - vararg
```
public GridPredicate<GridCacheEntry<K,V>>[] vararg(GridPredicate<GridCacheEntry<K,V>> p)
```
    Parameters:
    p - Single predicate.
    
    Returns:
    Array containing single predicate.
  - isAll
```
public <K,V> boolean isAll(GridCacheEntryEx<K,V> e,
                  @Nullable
                  GridPredicate<GridCacheEntry<K,V>>[] p)
              throws GridException
```
    Same as GridFunc.isAll(Object, GridPredicate[]), but safely unwraps exceptions.
    
    Parameters:
    e - Element.
    p - Predicates.
    
    Returns:
    True if predicates passed.
    
    Throws:
    
    GridException - If failed.
  - isAll
```
public <E> boolean isAll(E e,
                @Nullable
                GridPredicate<? super E>[] p)
              throws GridException
```
    Same as GridFunc.isAll(Object, GridPredicate[]), but safely unwraps exceptions.
    
    Type Parameters:
    E - Element type.
    Parameters:
    e - Element.
    p - Predicates.
    
    Returns:
    True if predicates passed.
    
    Throws:
    
    GridException - If failed.
  - forceLocal
```
@Nullable
public GridCacheFlag[] forceLocal()
```
    Forces LOCAL flag.
    
    Returns:
    Previously forced flags.
  - forceLocalRead
```
@Nullable
public GridCacheFlag[] forceLocalRead()
```
    Forces LOCAL and READ flags.
    
    Returns:
    Forced flags that were set prior to method call.
  - forceFlags
```
@Nullable
public GridCacheFlag[] forceFlags(@Nullable
                                  GridCacheFlag[] flags)
```
    Force projection flags for the current thread. These flags will affect all projections (even without flags) used within the current thread.
    
    Parameters:
    flags - Flags to force.
    
    Returns:
    Forced flags that were set prior to method call.
  - forcedFlags
```
public GridCacheFlag[] forcedFlags()
```
    Gets forced flags for current thread.
    
    Returns:
    Forced flags.
  - excludePeekModes
```
public GridCachePeekMode[] excludePeekModes(@Nullable
                                   GridCachePeekMode[] modes)
```
    Force peek mode excludes for current thread.
    
    Parameters:
    modes - Peek modes to exclude.
    
    Returns:
    Excludes prior to this call.
  - peekModeExcludes
```
public GridCachePeekMode[] peekModeExcludes()
```
    Returns:
    Peek mode excludes.
  - peekModeExcluded
```
public boolean peekModeExcluded(GridCachePeekMode mode)
```
    Parameters:
    mode - Peek mode.
    
    Returns:
    true if given peek mode is excluded.
  - cloneValue
```
@Nullable
public <T> T cloneValue(@Nullable
                        T obj)
             throws GridException
```
    Clone cached object.
    
    Parameters:
    obj - Object to clone
    
    Returns:
    Clone of the given object.
    
    Throws:
    
    GridException - If failed to clone object.
  - projectionPerCall
```
public GridCacheProjectionImpl<K,V> projectionPerCall()
```
    Gets thread local projection.
    
    Returns:
    Projection per call.
  - subjectIdPerCall
```
public UUID subjectIdPerCall(@Nullable
                    UUID subjId)
```
    Gets subject ID per call.
    
    Parameters:
    subjId - Optional already existing subject ID.
    
    Returns:
    Subject ID per call.
  - hasFlag
```
public boolean hasFlag(GridCacheFlag flag)
```
    Parameters:
    flag - Flag to check.
    
    Returns:
    true if the given flag is set.
  - hasAnyFlags
```
public boolean hasAnyFlags(GridCacheFlag[] flags)
```
    Checks whether any of the given flags is set.
    
    Parameters:
    flags - Flags to check.
    
    Returns:
    true if any of the given flags is set.
  - hasAnyFlags
```
public boolean hasAnyFlags(Collection<GridCacheFlag> flags)
```
    Checks whether any of the given flags is set.
    
    Parameters:
    flags - Flags to check.
    
    Returns:
    true if any of the given flags is set.
  - denyOnFlag
```
public void denyOnFlag(GridCacheFlag flag)
```
    Parameters:
    flag - Flag to check.
  - denyOnLocalRead
```
public void denyOnLocalRead()
```
  - denyOnFlags
```
public void denyOnFlags(GridCacheFlag[] flags)
```
    Parameters:
    flags - Flags.
  - denyOnFlags
```
public void denyOnFlags(Collection<GridCacheFlag> flags)
```
    Parameters:
    flags - Flags.
  - cloneOnFlag
```
@Nullable
public <T> T cloneOnFlag(@Nullable
                         T obj)
              throws GridException
```
    Clones cached object depending on whether or not GridCacheFlag.CLONE flag is set thread locally.
    
    Parameters:
    obj - Object to clone.
    
    Returns:
    Clone of the given object.
    
    Throws:
    
    GridException - If failed to clone.
  - wrapClone
```
public GridFuture<V> wrapClone(GridFuture<V> f)
```
    Parameters:
    f - Target future.
    
    Returns:
    Wrapped future that is aware of cloning behaviour.
  - wrapCloneMap
```
public GridFuture<Map<K,V>> wrapCloneMap(GridFuture<Map<K,V>> f)
```
    Parameters:
    f - Target future.
    
    Returns:
    Wrapped future that is aware of cloning behaviour.
  - checkTxFlags
```
public void checkTxFlags(@Nullable
                Collection<GridCacheFlag> flags)
                  throws GridCacheFlagException
```
    Parameters:
    flags - Flags to turn on.
    
    Throws:
    
    GridCacheFlagException - If given flags are conflicting with given transaction.
  - projectSafe
```
public Runnable projectSafe(Runnable r)
```
    Creates Runnable that can be executed safely in a different thread inheriting the same thread local projection as for the current thread. If no projection is set for current thread then there's no need to create new object and method simply returns given Runnable.
    
    Parameters:
    r - Runnable.
    
    Returns:
    Runnable that can be executed in a different thread with the same projection as for current thread.
  - projectSafe
```
public <T> Callable<T> projectSafe(Callable<T> r)
```
    Creates callable that can be executed safely in a different thread inheriting the same thread local projection as for the current thread. If no projection is set for current thread then there's no need to create new object and method simply returns given callable.
    
    Parameters:
    r - Callable.
    
    Returns:
    Callable that can be executed in a different thread with the same projection as for current thread.
  - isUnmarshalValues
```
public boolean isUnmarshalValues()
```
    Returns:
    True if values should be always unmarshalled.
  - deploymentEnabled
```
public boolean deploymentEnabled()
```
    Returns:
    True if deployment enabled.
  - isSwapOrOffheapEnabled
```
public boolean isSwapOrOffheapEnabled()
```
    Returns:
    True if swap store of off-heap cache are enabled.
  - isOffHeapEnabled
```
public boolean isOffHeapEnabled()
```
    Returns:
    True if offheap storage is enabled.
  - isStoreEnabled
```
public boolean isStoreEnabled()
```
    Returns:
    True if store is enabled.
  - isInvalidate
```
public boolean isInvalidate()
```
    Returns:
    True if invalidation is enabled.
  - syncCommit
```
public boolean syncCommit()
```
    Returns:
    True if synchronous commit is enabled.
  - syncRollback
```
public boolean syncRollback()
```
    Returns:
    True if synchronous rollback is enabled.
  - syncPrimary
```
public boolean syncPrimary()
```
    Returns:
    True if only primary node should be updated synchronously.
  - dhtMap
```
public boolean dhtMap(UUID nearNodeId,
             long topVer,
             GridDhtCacheEntry<K,V> entry,
             GridLogger log,
             Map<GridNode,List<GridDhtCacheEntry<K,V>>> dhtMap,
             Map<GridNode,List<GridDhtCacheEntry<K,V>>> nearMap)
               throws GridCacheEntryRemovedException
```
    Parameters:
    nearNodeId - Near node ID.
    topVer - Topology version.
    entry - Entry.
    log - Log.
    dhtMap - Dht mappings.
    nearMap - Near mappings.
    
    Returns:
    True if mapped.
    
    Throws:
    
    GridCacheEntryRemovedException - If reader for entry is removed.
  - preloadExchangeTimeout
```
public long preloadExchangeTimeout()
```
    Returns:
    Timeout for initial map exchange before preloading. We make it 4 times bigger than network timeout by default.
  - partitionReleaseFuture
```
public GridFuture<?> partitionReleaseFuture(Collection<Integer> parts,
                                   long topVer)
```
    Waits for partition locks and transactions release.
    
    Parameters:
    parts - Partitions.
    topVer - Topology version.
    
    Returns:
    true if waiting was successful.
  - hasKey
```
public boolean hasKey(Iterable<? extends K> keys,
             Collection<Integer> movingParts)
```
    Checks if at least one of the given keys belongs to one of the given partitions.
    
    Parameters:
    keys - Collection of keys to check.
    movingParts - Collection of partitions to check against.
    
    Returns:
    True if there exist a key in collection keys that belongs to one of partitions in movingParts
  - drNeedResolve
```
public boolean drNeedResolve(GridCacheVersion oldVer,
                    GridCacheVersion newVer)
```
    Check whether DR conflict resolution is required.
    
    Parameters:
    oldVer - Old version.
    newVer - New version.
    
    Returns:
    True in case DR is required.
  - drResolveConflict
```
public GridDrReceiverConflictContextImpl<K,V> drResolveConflict(K key,
                                                       GridDrEntry<K,V> oldEntry,
                                                       GridDrEntry<K,V> newEntry)
                                                         throws GridException
```
    Resolve DR conflict.
    
    Parameters:
    key - Key.
    oldEntry - Old entry.
    newEntry - New entry.
    
    Returns:
    Conflict resolution result.
    
    Throws:
    
    GridException - In case of exception.
  - onDeferredDelete
```
public void onDeferredDelete(GridCacheEntryEx<K,V> entry,
                    GridCacheVersion ver)
```
    Parameters:
    entry - Entry.
    ver - Version.
  - cancelRemove
```
public boolean cancelRemove(@Nullable
                   GridBiTuple<Boolean,?> interceptorRes)
```
    Parameters:
    interceptorRes - Result of GridCacheInterceptor.onBeforeRemove(K, V) callback.
    
    Returns:
    True if interceptor cancels remove.
  - cleanup
```
public void cleanup()
```
    Nulling references to potentially leak-prone objects.
  - printMemoryStats
```
public void printMemoryStats()
```
    Print memory statistics of all cache managers. NOTE: this method is for testing and profiling purposes only.
  - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
    Specified by:
    
    writeExternal in interface Externalizable
    
    Throws:
    
    IOException
  - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
    Specified by:
    
    readExternal in interface Externalizable
    
    Throws:
    
    IOException
    
    ClassNotFoundException
  - readResolve
```
protected Object readResolve()
                      throws ObjectStreamException
```
    Reconstructs object on demarshalling.
    
    Returns:
    Reconstructed object.
    
    Throws:
    
    ObjectStreamException - Thrown in case of demarshalling error.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class GridCacheContext<K,V>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

GridCacheContext

GridCacheContext

Method Detail

managers

cache

local

isDht

isDhtAtomic

isColocated

isNear

isLocal

isReplicated

isDrEnabled

deferredDelete

incrementPublicSize

decrementPublicSize

dht

dhtTx

colocated

near

nearTx

gate

unsafeMemory

kernalContext

grid

gridName

name

namex

namexx

checkSecurity

preloader

nodeId

preloadEnabled

atomic

transactional

localNode

localNodeId

isLocalNode

isLocalNode

node

topology

topologyVersionFuture

marshaller

logger

logger

gridConfig

gridIO

time

offheap

gridDeploy

gridSwap

gridEvents

closures

discovery

cache

config

writeToStoreFromDht

tm

affinity

versions

mvcc

events

queries

continuousQueries

swap

store

dgc

deploy

io

evicts

dataStructures

dr

ttl

jta

noGetArray