java.lang.Object
- org.eclipse.persistence.internal.sessions.IdentityMapAccessor

All Implemented Interfaces:

Serializable, IdentityMapAccessor

Direct Known Subclasses:

ClientSessionIdentityMapAccessor, DistributedSessionIdentityMapAccessor, IsolatedClientSessionIdentityMapAccessor, SessionBrokerIdentityMapAccessor, UnitOfWorkIdentityMapAccessor
```
public class IdentityMapAccessor
extends Object
implements IdentityMapAccessor, Serializable
```
INTERNAL: Internal subclass that provides access to identity maps through the session. Implements the IdentityMapAccessor interface which provides all publicly available identity map functionality to users. This is the main class that should be used to access identity maps. In general, any function that accesses the identity map manager should go through this class Any session specific functionality appears in subclasses

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type Field Description

protected IdentityMapManager identityMapManager
This is the identity map manager for this accessor.

protected AbstractSession session

Constructor Summary

Constructors
Constructor	Description
`IdentityMapAccessor()`	INTERNAL:
`IdentityMapAccessor(AbstractSession session)`	INTERNAL: An IdentityMapAccessor sits between the session and the identityMapManager It needs references in both directions.
`IdentityMapAccessor(AbstractSession session, IdentityMapManager identityMapManager)`	INTERNAL: An IdentityMapAccessor sits between the session and the identityMapManager It needs references in both directions.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`CacheKey`	`acquireDeferredLock(Object primarKey, Class<?> javaClass, ClassDescriptor descriptor, boolean isCacheCheckComplete)`	INTERNAL: Deferred lock the identity map for the object, this is used for avoiding deadlock The return cacheKey should be used to release the deferred lock.
`CacheKey`	`acquireLock(Object primaryKey, Class<?> domainClass, boolean forMerge, ClassDescriptor descriptor, boolean isCacheCheckComplete)`	INTERNAL: Provides access for setting a concurrency lock on an object in the IdentityMap.
`CacheKey`	`acquireLock(Object primarKey, Class<?> javaClass, ClassDescriptor descriptor, boolean isCacheCheckComplete)`	INTERNAL: Lock the identity map for the object, this must be done when building objects.
`CacheKey`	`acquireLockNoWait(Object primaryKey, Class<?> domainClass, boolean forMerge, ClassDescriptor descriptor)`	INTERNAL: Provides access for setting a concurrency lock on an object in the IdentityMap.
`CacheKey`	`acquireLockWithWait(Object primaryKey, Class<?> domainClass, boolean forMerge, ClassDescriptor descriptor, int wait)`	INTERNAL: Provides access for setting a concurrency lock on an object in the IdentityMap.
`CacheKey`	`acquireReadLockOnCacheKey(Object primaryKey, Class<?> domainClass, ClassDescriptor descriptor)`	INTERNAL: Find the cachekey for the provided primary key and place a readlock on it.
`CacheKey`	`acquireReadLockOnCacheKeyNoWait(Object primaryKey, Class<?> domainClass, ClassDescriptor descriptor)`	INTERNAL: Find the cachekey for the provided primary key and place a readlock on it.
`boolean`	`acquireWriteLock()`	INTERNAL: Lock the entire cache if the cache isolation requires.
`void`	`clearQueryCache()`	ADVANCED: Clear all the query caches
`void`	`clearQueryCache(String sessionQueryName)`	ADVANCED: Clear the query cache associated with the named query on the session
`void`	`clearQueryCache(String descriptorQueryName, Class<?> queryClass)`	ADVANCED: Clear the query cache associated with the named query on the descriptor for the given class
`void`	`clearQueryCache(ReadQuery query)`	ADVANCED: Clear the query class associated with the passed-in read query
`boolean`	`containsObjectInIdentityMap(Object object)`	ADVANCED: Return if their is an object for the primary key.
`boolean`	`containsObjectInIdentityMap(Object primaryKey, Class<?> theClass)`	ADVANCED: Return if their is an object for the primary key.
`boolean`	`containsObjectInIdentityMap(Object primaryKey, Class<?> theClass, ClassDescriptor descriptor)`	INTERNAL: Return if their is an object for the primary key.
`boolean`	`containsObjectInIdentityMap(DataRecord rowContainingPrimaryKey, Class<?> theClass)`	ADVANCED: Return if their is an object for the row containing primary key and the class.
`protected Object`	`extractPrimaryKeyFromRow(DataRecord rowContainingPrimaryKey, Class<?> theClass)`	INTERNAL: Extract primary key from a row.
`Map<Object,CacheKey>`	`getAllCacheKeysFromIdentityMapWithEntityPK(Object[] pkList, ClassDescriptor descriptor)`	ADVANCED: Using a list of Entity PK this method will attempt to bulk load the entire list from the cache.
`Vector`	`getAllFromIdentityMap(Expression selectionCriteria, Class<?> theClass, DataRecord translationRow)`	ADVANCED: Query the cache in-memory.
`Vector`	`getAllFromIdentityMap(Expression selectionCriteria, Class<?> theClass, DataRecord translationRow, int valueHolderPolicy)`	ADVANCED: Query the cache in-memory.
`Vector`	`getAllFromIdentityMap(Expression selectionCriteria, Class<?> theClass, DataRecord translationRow, int valueHolderPolicy, boolean shouldReturnInvalidatedObjects)`	ADVANCED: Query the cache in-memory.
`Vector`	`getAllFromIdentityMap(Expression selectionCriteria, Class<?> theClass, DataRecord translationRow, InMemoryQueryIndirectionPolicy valueHolderPolicy)`	ADVANCED: Query the cache in-memory.
`Vector`	`getAllFromIdentityMap(Expression selectionCriteria, Class<?> theClass, DataRecord translationRow, InMemoryQueryIndirectionPolicy valueHolderPolicy, boolean shouldReturnInvalidatedObjects)`	ADVANCED: Query the cache in-memory.
`Map<Object,Object>`	`getAllFromIdentityMapWithEntityPK(Object[] pkList, ClassDescriptor descriptor)`	ADVANCED: Using a list of Entity PK this method will attempt to bulk load the entire list from the cache.
`CacheKey`	`getCacheKeyByIndex(CacheIndex index, CacheId indexValues, boolean shouldCheckExpiry, ClassDescriptor descriptor)`	Return the cache key for the cache index or null if not found.
`CacheKey`	`getCacheKeyForObject(Object object)`	INTERNAL: Retrieve the cache key for the given object.
`CacheKey`	`getCacheKeyForObject(Object primaryKey, Class<?> myClass, ClassDescriptor descriptor, boolean forMerge)`	INTERNAL: Retrieve the cache key for the given identity information.
`CacheKey`	`getCacheKeyForObject(Object object, ClassDescriptor descriptor)`	INTERNAL: Retrieve the cache key for the given object from the identity maps.
`CacheKey`	`getCacheKeyForObjectForLock(Object primaryKey, Class<?> myClass, ClassDescriptor descriptor)`	INTERNAL: Retrieve the cache key for the given identity information.
`Vector`	`getClassesRegistered()`	INTERNAL: This method is used to get a list of those classes with IdentityMaps in the Session.
`Object`	`getFromIdentityMap(Object object)`	ADVANCED: Return the object from the identity with primary and class of the given object.
`Object`	`getFromIdentityMap(Object primaryKey, Class<?> theClass)`	ADVANCED: Return the object from the identity with the primary and class.
`Object`	`getFromIdentityMap(Object primaryKey, Class<?> theClass, boolean shouldReturnInvalidatedObjects)`	ADVANCED: Return the object from the identity with the primary and class.
`Object`	`getFromIdentityMap(Object primaryKey, Class<?> theClass, ClassDescriptor descriptor)`	ADVANCED: Return the object from the identity with the primary and class.
`Object`	`getFromIdentityMap(Object primaryKey, Object object, Class<?> theClass, boolean shouldReturnInvalidatedObjects, ClassDescriptor descriptor)`	INTERNAL: Return the object from the identity with the primary and class.
`Object`	`getFromIdentityMap(Expression selectionCriteria, Class<?> theClass, DataRecord translationRow)`	ADVANCED: Query the cache in-memory.
`Object`	`getFromIdentityMap(Expression selectionCriteria, Class<?> theClass, DataRecord translationRow, int valueHolderPolicy)`	ADVANCED: Query the cache in-memory.
`Object`	`getFromIdentityMap(Expression selectionCriteria, Class<?> theClass, DataRecord translationRow, int valueHolderPolicy, boolean conforming)`	INTERNAL: Query the cache in-memory.
`Object`	`getFromIdentityMap(Expression selectionCriteria, Class<?> theClass, DataRecord translationRow, int valueHolderPolicy, boolean conforming, boolean shouldReturnInvalidatedObjects)`	INTERNAL: Query the cache in-memory.
`Object`	`getFromIdentityMap(Expression selectionCriteria, Class<?> theClass, DataRecord translationRow, int valueHolderPolicy, boolean conforming, boolean shouldReturnInvalidatedObjects, ClassDescriptor descriptor)`	INTERNAL: Query the cache in-memory.
`Object`	`getFromIdentityMap(Expression selectionCriteria, Class<?> theClass, DataRecord translationRow, InMemoryQueryIndirectionPolicy valueHolderPolicy)`	ADVANCED: Query the cache in-memory.
`Object`	`getFromIdentityMap(DataRecord rowContainingPrimaryKey, Class<?> theClass)`	ADVANCED: Return the object from the identity with the primary and class.
`Object`	`getFromIdentityMap(DataRecord rowContainingPrimaryKey, Class<?> theClass, boolean shouldReturnInvalidatedObjects)`	ADVANCED: Return the object from the identity with the primary and class.
`Object`	`getFromIdentityMapWithDeferredLock(Object primaryKey, Class<?> theClass, boolean shouldReturnInvalidatedObjects, ClassDescriptor descriptor)`	INTERNAL: Return the object from the identity with the primary and class.
`Object`	`getFromIdentityMapWithDeferredLock(Object primaryKey, Class<?> theClass, ClassDescriptor descriptor)`	INTERNAL: Return the object from the identity with the primary and class.
`Object`	`getFromLocalIdentityMap(Object primaryKey, Class<?> theClass, boolean shouldReturnInvalidatedObjects, ClassDescriptor descriptor)`	INTERNAL: Return the object from the local identity map with the primary and class.
`Object`	`getFromLocalIdentityMapWithDeferredLock(Object primaryKey, Class<?> theClass, boolean shouldReturnInvalidatedObjects, ClassDescriptor descriptor)`	INTERNAL: Return the object from the local identity map with the primary and class.
`IdentityMap`	`getIdentityMap(Class<?> theClass)`	INTERNAL: (public to allow test cases to check) Return the identity map for the class, if missing create a new one.
`IdentityMap`	`getIdentityMap(ClassDescriptor descriptor)`	INTERNAL: Get the identity map for the given class from the IdentityMapManager
`IdentityMap`	`getIdentityMap(ClassDescriptor descriptor, boolean returnNullIfMissing)`	INTERNAL: Get the identity map for the given class from the IdentityMapManager
`IdentityMapManager`	`getIdentityMapManager()`	INTERNAL: Get the IdentityMapManager for this IdentityMapAccessor This method should be used for all IdentityMapManager access since it may be overridden in sub classes.
`Object`	`getQueryResult(ReadQuery query, List parameters, boolean checkExpiry)`	INTERNAL: Get the cached results associated with a query.
`long`	`getRemainingValidTime(Object object)`	ADVANCED: Return the remaining life of this object.
`AbstractSession`	`getSession()`	INTERNAL: get the session associated with this IdentityMapAccessor
`Object`	`getWrapper(Object primaryKey, Class<?> theClass)`	INTERNAL: Get the wrapper object from the cache key associated with the given primary key, this is used for EJB.
`WriteLockManager`	`getWriteLockManager()`	INTERNAL: Returns the single write Lock manager for this session
`Object`	`getWriteLockValue(Object object)`	ADVANCED: Extract the write lock value from the identity map.
`Object`	`getWriteLockValue(Object primaryKey, Class<?> theClass)`	ADVANCED: Extract the write lock value from the identity map.
`Object`	`getWriteLockValue(Object primaryKey, Class<?> theClass, ClassDescriptor descriptor)`	ADVANCED: Extract the write lock value from the identity map.
`void`	`initializeAllIdentityMaps()`	PUBLIC: Reset the entire object cache.
`void`	`initializeIdentityMap(Class<?> theClass)`	PUBLIC: Reset the identity map for only the instances of the class.
`void`	`initializeIdentityMaps()`	PUBLIC: Reset the entire local object cache.
`CacheKey`	`internalPutInIdentityMap(Object object, Object key, Object writeLockValue, long readTime, ClassDescriptor descriptor)`	INTERNAL: Register the object with the cache.
`void`	`invalidateAll()`	ADVANCED: Set all of the objects from all identity maps to be invalid in the cache.
`void`	`invalidateClass(Class<?> myClass)`	ADVANCED: Set all of the objects of a specific class to be invalid in the cache.
`void`	`invalidateClass(Class<?> myClass, boolean recurseAndInvalidateToParentRoot)`	ADVANCED: Set all of the objects of a specific class to be invalid in the cache.
`void`	`invalidateObject(Object object)`	ADVANCED: Set an object to be invalid in the cache.
`void`	`invalidateObject(Object object, boolean invalidateCluster)`	ADVANCED: Set an object to be invalid in the cache.
`void`	`invalidateObject(Object primaryKey, Class<?> theClass)`	ADVANCED: Set an object to be invalid in the cache.
`void`	`invalidateObject(Object primaryKey, Class<?> theClass, boolean invalidateCluster)`	ADVANCED: Set an object to be invalid in the cache.
`void`	`invalidateObject(DataRecord rowContainingPrimaryKey, Class<?> theClass)`	ADVANCED: Set an object to be invalid in the cache.
`void`	`invalidateObject(DataRecord rowContainingPrimaryKey, Class<?> theClass, boolean invalidateCluster)`	ADVANCED: Set an object to be invalid in the cache.
`void`	`invalidateObjects(Collection collection)`	ADVANCED: Set all of the objects in the given collection to be invalid in the cache.
`void`	`invalidateObjects(Collection collection, boolean invalidateCluster)`	ADVANCED: Set all of the objects in the given collection to be invalid in the cache.
`void`	`invalidateObjects(Expression selectionCriteria)`	ADVANCED: Set all of the objects from the given Expression to be invalid in the cache.
`void`	`invalidateObjects(Expression selectionCriteria, Class<?> theClass, DataRecord translationRow, boolean shouldInvalidateOnException)`	ADVANCED: Queries the cache in-memory with the passed in criteria and invalidates matching Objects.
`void`	`invalidateQueryCache(Class<?> classThatChanged)`	Invalidate/remove any results for the class from the query cache.
`boolean`	`isValid(Object object)`	ADVANCED: Return if this object is valid in the cache.
`boolean`	`isValid(Object primaryKey, Class<?> theClass)`	ADVANCED: Return if this object is valid in the cache.
`boolean`	`isValid(DataRecord rowContainingPrimaryKey, Class<?> theClass)`	ADVANCED: Return if this object is valid in the cache.
`void`	`printIdentityMap(Class<?> businessClass)`	PUBLIC: Used to print all the objects in the identity map of the passed in class.
`void`	`printIdentityMapLocks()`	PUBLIC: Used to print all the locks in every identity map in this session.
`void`	`printIdentityMaps()`	PUBLIC: Used to print all the objects in every identity map in this session.
`void`	`putCacheKeyByIndex(CacheIndex index, CacheId indexValues, CacheKey cacheKey, ClassDescriptor descriptor)`	Index the cache key by the index values.
`Object`	`putInIdentityMap(Object object)`	ADVANCED: Register the object with the cache.
`Object`	`putInIdentityMap(Object object, Object key)`	ADVANCED: Register the object with the cache.
`Object`	`putInIdentityMap(Object object, Object key, Object writeLockValue)`	ADVANCED: Register the object with the cache.
`Object`	`putInIdentityMap(Object object, Object key, Object writeLockValue, long readTime)`	ADVANCED: Register the object with the cache.
`Object`	`putInIdentityMap(Object object, Object key, Object writeLockValue, long readTime, ClassDescriptor descriptor)`	ADVANCED: Register the object with the cache.
`void`	`putQueryResult(ReadQuery query, List parameters, Object results)`	INTERNAL: Set the results for a query.
`void`	`releaseWriteLock()`	INTERNAL: Lock the entire cache if the cache isolation requires.
`Object`	`removeFromIdentityMap(Object object)`	ADVANCED: Remove the object from the object cache.
`Object`	`removeFromIdentityMap(Object key, Class<?> theClass)`	ADVANCED: Remove the object from the object cache.
`Object`	`removeFromIdentityMap(Object key, Class<?> theClass, ClassDescriptor descriptor, Object object)`	INTERNAL: Remove the object from the object cache.
`void`	`setIdentityMapManager(IdentityMapManager identityMapManager)`	INTERNAL: Set the IdentityMapManager for this IdentityMapAccessor
`void`	`setWrapper(Object primaryKey, Class<?> theClass, Object wrapper)`	INTERNAL: Update the wrapper object the cache key associated with the given primary key, this is used for EJB.
`void`	`updateWriteLockValue(Object primaryKey, Class<?> theClass, Object writeLockValue)`	ADVANCED: Update the write lock value in the cache.
`void`	`updateWriteLockValue(Object object, Object writeLockValue)`	ADVANCED: Update the write lock value in the cache.
`void`	`validateCache()`	INTERNAL: This can be used to help debugging an object identity problem.

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

- Field Detail
  - identityMapManager
```
protected IdentityMapManager identityMapManager
```
    This is the identity map manager for this accessor. It should only be accessed through the getter
  - session
```
protected AbstractSession session
```
- Constructor Detail
  - IdentityMapAccessor
```
public IdentityMapAccessor()
```
    INTERNAL:
  - IdentityMapAccessor
```
public IdentityMapAccessor(AbstractSession session)
```
    INTERNAL: An IdentityMapAccessor sits between the session and the identityMapManager It needs references in both directions.
  - IdentityMapAccessor
```
public IdentityMapAccessor(AbstractSession session,
                           IdentityMapManager identityMapManager)
```
    INTERNAL: An IdentityMapAccessor sits between the session and the identityMapManager It needs references in both directions.
- Method Detail
  - acquireDeferredLock
```
public CacheKey acquireDeferredLock(Object primarKey,
                                    Class<?> javaClass,
                                    ClassDescriptor descriptor,
                                    boolean isCacheCheckComplete)
```
    INTERNAL: Deferred lock the identity map for the object, this is used for avoiding deadlock The return cacheKey should be used to release the deferred lock.
  - acquireLock
```
public CacheKey acquireLock(Object primarKey,
                            Class<?> javaClass,
                            ClassDescriptor descriptor,
                            boolean isCacheCheckComplete)
```
    INTERNAL: Lock the identity map for the object, this must be done when building objects. The return cacheKey should be used to release the lock.
  - acquireLock
```
public CacheKey acquireLock(Object primaryKey,
                            Class<?> domainClass,
                            boolean forMerge,
                            ClassDescriptor descriptor,
                            boolean isCacheCheckComplete)
```
    INTERNAL: Provides access for setting a concurrency lock on an object in the IdentityMap. Called with true from the merge process, if true then the refresh will not refresh the object.
  - acquireLockNoWait
```
public CacheKey acquireLockNoWait(Object primaryKey,
                                  Class<?> domainClass,
                                  boolean forMerge,
                                  ClassDescriptor descriptor)
```
    INTERNAL: Provides access for setting a concurrency lock on an object in the IdentityMap. Called with true from the merge process, if true then the refresh will not refresh the object.
  - acquireLockWithWait
```
public CacheKey acquireLockWithWait(Object primaryKey,
                                    Class<?> domainClass,
                                    boolean forMerge,
                                    ClassDescriptor descriptor,
                                    int wait)
```
    INTERNAL: Provides access for setting a concurrency lock on an object in the IdentityMap. Called with true from the merge process, if true then the refresh will not refresh the object.
  - acquireReadLockOnCacheKey
```
public CacheKey acquireReadLockOnCacheKey(Object primaryKey,
                                          Class<?> domainClass,
                                          ClassDescriptor descriptor)
```
    INTERNAL: Find the cachekey for the provided primary key and place a readlock on it. This will allow multiple users to read the same object but prevent writes to the object while the read lock is held.
  - acquireReadLockOnCacheKeyNoWait
```
public CacheKey acquireReadLockOnCacheKeyNoWait(Object primaryKey,
                                                Class<?> domainClass,
                                                ClassDescriptor descriptor)
```
    INTERNAL: Find the cachekey for the provided primary key and place a readlock on it. This will allow multiple users to read the same object but prevent writes to the object while the read lock is held. If no readlock can be acquired then do not wait but return null.
  - acquireWriteLock
```
public boolean acquireWriteLock()
```
    INTERNAL: Lock the entire cache if the cache isolation requires. By default concurrent reads and writes are allowed. By write, unit of work merge is meant.
  - clearQueryCache
```
public void clearQueryCache()
```
    ADVANCED: Clear all the query caches
    
    Specified by:
    
    clearQueryCache in interface IdentityMapAccessor
  - clearQueryCache
```
public void clearQueryCache(ReadQuery query)
```
    ADVANCED: Clear the query class associated with the passed-in read query
    
    Specified by:
    
    clearQueryCache in interface IdentityMapAccessor
  - clearQueryCache
```
public void clearQueryCache(String sessionQueryName)
```
    ADVANCED: Clear the query cache associated with the named query on the session
    
    Specified by:
    
    clearQueryCache in interface IdentityMapAccessor
  - clearQueryCache
```
public void clearQueryCache(String descriptorQueryName,
                            Class<?> queryClass)
```
    ADVANCED: Clear the query cache associated with the named query on the descriptor for the given class
    
    Specified by:
    
    clearQueryCache in interface IdentityMapAccessor
  - containsObjectInIdentityMap
```
public boolean containsObjectInIdentityMap(Object object)
```
    ADVANCED: Return if their is an object for the primary key.
    
    Specified by:
    
    containsObjectInIdentityMap in interface IdentityMapAccessor
  - containsObjectInIdentityMap
```
public boolean containsObjectInIdentityMap(Object primaryKey,
                                           Class<?> theClass)
```
    ADVANCED: Return if their is an object for the primary key.
    
    Specified by:
    
    containsObjectInIdentityMap in interface IdentityMapAccessor
  - containsObjectInIdentityMap
```
public boolean containsObjectInIdentityMap(Object primaryKey,
                                           Class<?> theClass,
                                           ClassDescriptor descriptor)
```
    INTERNAL: Return if their is an object for the primary key.
  - containsObjectInIdentityMap
```
public boolean containsObjectInIdentityMap(DataRecord rowContainingPrimaryKey,
                                           Class<?> theClass)
```
    ADVANCED: Return if their is an object for the row containing primary key and the class.
    
    Specified by:
    
    containsObjectInIdentityMap in interface IdentityMapAccessor
  - extractPrimaryKeyFromRow
```
protected Object extractPrimaryKeyFromRow(DataRecord rowContainingPrimaryKey,
                                          Class<?> theClass)
```
    INTERNAL: Extract primary key from a row.
  - getCacheKeyForObject
```
public CacheKey getCacheKeyForObject(Object object,
                                     ClassDescriptor descriptor)
```
    INTERNAL: Retrieve the cache key for the given object from the identity maps.
    
    Parameters:
    
    object - the object to get the cache key for.
  - getClassesRegistered
```
public Vector getClassesRegistered()
```
    INTERNAL: This method is used to get a list of those classes with IdentityMaps in the Session.
  - getAllFromIdentityMap
```
public Vector getAllFromIdentityMap(Expression selectionCriteria,
                                    Class<?> theClass,
                                    DataRecord translationRow)
                             throws QueryException
```
    ADVANCED: Query the cache in-memory. If the expression is too complex an exception will be thrown.
    
    Throws:
    
    QueryException
  - getAllFromIdentityMap
```
public Vector getAllFromIdentityMap(Expression selectionCriteria,
                                    Class<?> theClass,
                                    DataRecord translationRow,
                                    InMemoryQueryIndirectionPolicy valueHolderPolicy)
                             throws QueryException
```
    ADVANCED: Query the cache in-memory. If the expression is too complex an exception will be thrown.
    
    Specified by:
    
    getAllFromIdentityMap in interface IdentityMapAccessor
    
    Parameters:
    
    selectionCriteria - Expression selecting the Objects to be returned
    
    theClass - Class to be considered
    
    translationRow - Record
    
    valueHolderPolicy - see InMemoryQueryIndirectionPolicy
    
    Returns:
    
    Vector of Objects with type theClass and matching the selectionCriteria
    
    Throws:
    
    QueryException
  - getAllFromIdentityMap
```
public Vector getAllFromIdentityMap(Expression selectionCriteria,
                                    Class<?> theClass,
                                    DataRecord translationRow,
                                    int valueHolderPolicy)
                             throws QueryException
```
    ADVANCED: Query the cache in-memory. If the expression is too complex an exception will be thrown.
    
    Specified by:
    
    getAllFromIdentityMap in interface IdentityMapAccessor
    
    Parameters:
    
    selectionCriteria - Expression selecting the Objects to be returned
    
    theClass - Class to be considered
    
    translationRow - Record
    
    valueHolderPolicy - see InMemoryQueryIndirectionPolicy
    
    Returns:
    
    Vector of Objects with type theClass and matching the selectionCriteria
    
    Throws:
    
    QueryException
  - getAllFromIdentityMap
```
public Vector getAllFromIdentityMap(Expression selectionCriteria,
                                    Class<?> theClass,
                                    DataRecord translationRow,
                                    InMemoryQueryIndirectionPolicy valueHolderPolicy,
                                    boolean shouldReturnInvalidatedObjects)
                             throws QueryException
```
    ADVANCED: Query the cache in-memory. If the expression is too complex an exception will be thrown. Only return objects that are invalid in the cache if specified.
    
    Specified by:
    
    getAllFromIdentityMap in interface IdentityMapAccessor
    
    Parameters:
    
    selectionCriteria - Expression selecting the Objects to be returned
    
    theClass - Class to be considered
    
    translationRow - Record
    
    valueHolderPolicy - see InMemoryQueryIndirectionPolicy
    
    shouldReturnInvalidatedObjects - boolean - true if only invalid Objects should be returned
    
    Returns:
    
    Vector of Objects
    
    Throws:
    
    QueryException
  - getAllFromIdentityMap
```
public Vector getAllFromIdentityMap(Expression selectionCriteria,
                                    Class<?> theClass,
                                    DataRecord translationRow,
                                    int valueHolderPolicy,
                                    boolean shouldReturnInvalidatedObjects)
                             throws QueryException
```
    ADVANCED: Query the cache in-memory. If the expression is too complex an exception will be thrown. Only return objects that are invalid in the cache if specified.
    
    Specified by:
    
    getAllFromIdentityMap in interface IdentityMapAccessor
    
    Parameters:
    
    selectionCriteria - Expression selecting the Objects to be returned
    
    theClass - Class to be considered
    
    translationRow - Record
    
    valueHolderPolicy - see InMemoryQueryIndirectionPolicy
    
    shouldReturnInvalidatedObjects - boolean - true if only invalid Objects should be returned
    
    Returns:
    
    Vector of Objects
    
    Throws:
    
    QueryException
  - getAllFromIdentityMapWithEntityPK
```
public Map<Object,Object> getAllFromIdentityMapWithEntityPK(Object[] pkList,
                                                                  ClassDescriptor descriptor)
```
    ADVANCED: Using a list of Entity PK this method will attempt to bulk load the entire list from the cache. In certain circumstances this can have large performance improvements over loading each item individually.
    
    Parameters:
    
    pkList - List of Entity PKs to extract from the cache
    
    descriptor - Descriptor type to be retrieved.
    
    Returns:
    
    Map of Entity PKs associated to the Entities that were retrieved
  - getAllCacheKeysFromIdentityMapWithEntityPK
```
public Map<Object,CacheKey> getAllCacheKeysFromIdentityMapWithEntityPK(Object[] pkList,
                                                                             ClassDescriptor descriptor)
```
    ADVANCED: Using a list of Entity PK this method will attempt to bulk load the entire list from the cache. In certain circumstances this can have large performance improvements over loading each item individually.
    
    Parameters:
    
    pkList - List of Entity PKs to extract from the cache
    
    descriptor - Descriptor type to be retrieved.
    
    Returns:
    
    Map of Entity PKs associated to the Entities that were retrieved
  - getFromIdentityMap
```
public Object getFromIdentityMap(Object object)
```
    ADVANCED: Return the object from the identity with primary and class of the given object.
    
    Specified by:
    
    getFromIdentityMap in interface IdentityMapAccessor
    
    Parameters:
    
    object - Object
    
    Returns:
    
    Object from identity map, may be null.
  - getCacheKeyForObject
```
public CacheKey getCacheKeyForObject(Object object)
```
    INTERNAL: Retrieve the cache key for the given object.
    
    Returns:
    
    CacheKey
  - getCacheKeyForObjectForLock
```
public CacheKey getCacheKeyForObjectForLock(Object primaryKey,
                                            Class<?> myClass,
                                            ClassDescriptor descriptor)
```
    INTERNAL: Retrieve the cache key for the given identity information.
    
    Parameters:
    
    primaryKey - the primary key of the cache key to be retrieved.
    
    myClass - the class of the cache key to be retrieved.
  - getCacheKeyForObject
```
public CacheKey getCacheKeyForObject(Object primaryKey,
                                     Class<?> myClass,
                                     ClassDescriptor descriptor,
                                     boolean forMerge)
```
    INTERNAL: Retrieve the cache key for the given identity information.
    
    Parameters:
    
    primaryKey - the primary key of the cache key to be retrieved.
    
    myClass - the class of the cache key to be retrieved.
  - getFromIdentityMap
```
public Object getFromIdentityMap(Object primaryKey,
                                 Class<?> theClass)
```
    ADVANCED: Return the object from the identity with the primary and class.
    
    Specified by:
    
    getFromIdentityMap in interface IdentityMapAccessor
    
    Returns:
    
    Object from identity map, may be null.
  - getFromIdentityMap
```
public Object getFromIdentityMap(Object primaryKey,
                                 Class<?> theClass,
                                 ClassDescriptor descriptor)
```
    ADVANCED: Return the object from the identity with the primary and class.
  - getFromIdentityMap
```
public Object getFromIdentityMap(Object primaryKey,
                                 Class<?> theClass,
                                 boolean shouldReturnInvalidatedObjects)
```
    ADVANCED: Return the object from the identity with the primary and class. Only return invalidated objects if requested.
    
    Specified by:
    
    getFromIdentityMap in interface IdentityMapAccessor
    
    Returns:
    
    Object from identity map, may be null.
  - getFromIdentityMap
```
public Object getFromIdentityMap(Object primaryKey,
                                 Object object,
                                 Class<?> theClass,
                                 boolean shouldReturnInvalidatedObjects,
                                 ClassDescriptor descriptor)
```
    INTERNAL: Return the object from the identity with the primary and class. Only return invalidated objects if requested.
  - getFromLocalIdentityMap
```
public Object getFromLocalIdentityMap(Object primaryKey,
                                      Class<?> theClass,
                                      boolean shouldReturnInvalidatedObjects,
                                      ClassDescriptor descriptor)
```
    INTERNAL: Return the object from the local identity map with the primary and class. This avoids checking the parent cache for the unit of work.
  - getFromLocalIdentityMapWithDeferredLock
```
public Object getFromLocalIdentityMapWithDeferredLock(Object primaryKey,
                                                      Class<?> theClass,
                                                      boolean shouldReturnInvalidatedObjects,
                                                      ClassDescriptor descriptor)
```
    INTERNAL: Return the object from the local identity map with the primary and class. This avoids checking the parent cache for the unit of work.
  - getFromIdentityMap
```
public Object getFromIdentityMap(DataRecord rowContainingPrimaryKey,
                                 Class<?> theClass)
```
    ADVANCED: Return the object from the identity with the primary and class.
    
    Specified by:
    
    getFromIdentityMap in interface IdentityMapAccessor
    
    Parameters:
    
    rowContainingPrimaryKey - Record
    
    theClass - Class
    
    Returns:
    
    Object from identity map, may be null.
  - getFromIdentityMap
```
public Object getFromIdentityMap(DataRecord rowContainingPrimaryKey,
                                 Class<?> theClass,
                                 boolean shouldReturnInvalidatedObjects)
```
    ADVANCED: Return the object from the identity with the primary and class. Only return invalidated objects if requested.
    
    Specified by:
    
    getFromIdentityMap in interface IdentityMapAccessor
    
    Parameters:
    
    rowContainingPrimaryKey - Record
    
    theClass - Class
    
    shouldReturnInvalidatedObjects - boolean
    
    Returns:
    
    Object from identity map, may be null.
  - getFromIdentityMap
```
public Object getFromIdentityMap(Expression selectionCriteria,
                                 Class<?> theClass,
                                 DataRecord translationRow)
                          throws QueryException
```
    ADVANCED: Query the cache in-memory. If the object is not found null is returned. If the expression is too complex an exception will be thrown.
    
    Specified by:
    
    getFromIdentityMap in interface IdentityMapAccessor
    
    Parameters:
    
    selectionCriteria - Expression
    
    theClass - Class
    
    translationRow - Record
    
    Returns:
    
    Object from identity map, may be null
    
    Throws:
    
    QueryException
  - getFromIdentityMap
```
public Object getFromIdentityMap(Expression selectionCriteria,
                                 Class<?> theClass,
                                 DataRecord translationRow,
                                 InMemoryQueryIndirectionPolicy valueHolderPolicy)
                          throws QueryException
```
    ADVANCED: Query the cache in-memory. If the object is not found null is returned. If the expression is too complex an exception will be thrown.
    
    Specified by:
    
    getFromIdentityMap in interface IdentityMapAccessor
    
    Parameters:
    
    selectionCriteria - Expression
    
    theClass - Class
    
    translationRow - Record
    
    valueHolderPolicy - see InMemoryQueryIndirectionPolicy
    
    Returns:
    
    Object from identity map, may be null
    
    Throws:
    
    QueryException
  - getFromIdentityMap
```
public Object getFromIdentityMap(Expression selectionCriteria,
                                 Class<?> theClass,
                                 DataRecord translationRow,
                                 int valueHolderPolicy)
                          throws QueryException
```
    ADVANCED: Query the cache in-memory. If the object is not found null is returned. If the expression is too complex an exception will be thrown.
    
    Specified by:
    
    getFromIdentityMap in interface IdentityMapAccessor
    
    Parameters:
    
    selectionCriteria - Expression
    
    theClass - Class
    
    translationRow - Record
    
    valueHolderPolicy - see InMemoryQueryIndirectionPolicy
    
    Returns:
    
    Object from identity map, may be null
    
    Throws:
    
    QueryException
  - getFromIdentityMap
```
public Object getFromIdentityMap(Expression selectionCriteria,
                                 Class<?> theClass,
                                 DataRecord translationRow,
                                 int valueHolderPolicy,
                                 boolean conforming)
```
    INTERNAL: Query the cache in-memory. If the object is not found null is returned. If the expression is too complex an exception will be thrown.
  - getFromIdentityMap
```
public Object getFromIdentityMap(Expression selectionCriteria,
                                 Class<?> theClass,
                                 DataRecord translationRow,
                                 int valueHolderPolicy,
                                 boolean conforming,
                                 boolean shouldReturnInvalidatedObjects)
```
    INTERNAL: Query the cache in-memory. If the object is not found null is returned. If the expression is too complex an exception will be thrown.
  - getFromIdentityMap
```
public Object getFromIdentityMap(Expression selectionCriteria,
                                 Class<?> theClass,
                                 DataRecord translationRow,
                                 int valueHolderPolicy,
                                 boolean conforming,
                                 boolean shouldReturnInvalidatedObjects,
                                 ClassDescriptor descriptor)
```
    INTERNAL: Query the cache in-memory. If the object is not found null is returned. If the expression is too complex an exception will be thrown.
  - getFromIdentityMapWithDeferredLock
```
public Object getFromIdentityMapWithDeferredLock(Object primaryKey,
                                                 Class<?> theClass,
                                                 ClassDescriptor descriptor)
```
    INTERNAL: Return the object from the identity with the primary and class.
  - getFromIdentityMapWithDeferredLock
```
public Object getFromIdentityMapWithDeferredLock(Object primaryKey,
                                                 Class<?> theClass,
                                                 boolean shouldReturnInvalidatedObjects,
                                                 ClassDescriptor descriptor)
```
    INTERNAL: Return the object from the identity with the primary and class. Only return invalidated objects if requested
  - getIdentityMapManager
```
public IdentityMapManager getIdentityMapManager()
```
    INTERNAL: Get the IdentityMapManager for this IdentityMapAccessor This method should be used for all IdentityMapManager access since it may be overridden in sub classes.
  - getIdentityMap
```
public IdentityMap getIdentityMap(Class<?> theClass)
```
    INTERNAL: (public to allow test cases to check) Return the identity map for the class, if missing create a new one.
  - getIdentityMap
```
public IdentityMap getIdentityMap(ClassDescriptor descriptor)
```
    INTERNAL: Get the identity map for the given class from the IdentityMapManager
  - getIdentityMap
```
public IdentityMap getIdentityMap(ClassDescriptor descriptor,
                                  boolean returnNullIfMissing)
```
    INTERNAL: Get the identity map for the given class from the IdentityMapManager
  - getQueryResult
```
public Object getQueryResult(ReadQuery query,
                             List parameters,
                             boolean checkExpiry)
```
    INTERNAL: Get the cached results associated with a query. Results are cached by the values of the parameters to the query so different parameters will have different cached results.
  - getRemainingValidTime
```
public long getRemainingValidTime(Object object)
```
    ADVANCED: Return the remaining life of this object. This method is associated with use of cache invalidation and returns the difference between the next expiry time of the object and its read time. The method will return 0 for invalidated objects.
    
    Specified by:
    
    getRemainingValidTime in interface IdentityMapAccessor
    
    Parameters:
    
    object - Object under consideration
    
    Returns:
    
    long time in milliseconds
  - getSession
```
public AbstractSession getSession()
```
    INTERNAL: get the session associated with this IdentityMapAccessor
  - getWrapper
```
public Object getWrapper(Object primaryKey,
                         Class<?> theClass)
```
    INTERNAL: Get the wrapper object from the cache key associated with the given primary key, this is used for EJB.
  - getWriteLockManager
```
public WriteLockManager getWriteLockManager()
```
    INTERNAL: Returns the single write Lock manager for this session
  - getWriteLockValue
```
public Object getWriteLockValue(Object object)
```
    ADVANCED: Extract the write lock value from the identity map.
    
    Specified by:
    
    getWriteLockValue in interface IdentityMapAccessor
    
    Parameters:
    
    object - Object
    
    Returns:
    
    Object for versioning
  - getWriteLockValue
```
public Object getWriteLockValue(Object primaryKey,
                                Class<?> theClass)
```
    ADVANCED: Extract the write lock value from the identity map.
    
    Specified by:
    
    getWriteLockValue in interface IdentityMapAccessor
  - getWriteLockValue
```
public Object getWriteLockValue(Object primaryKey,
                                Class<?> theClass,
                                ClassDescriptor descriptor)
```
    ADVANCED: Extract the write lock value from the identity map.
  - initializeAllIdentityMaps
```
public void initializeAllIdentityMaps()
```
    PUBLIC: Reset the entire object cache.
    NOTE: be careful using this method. This method blows away both this session's and its parents caches, this includes the server cache or any other cache. This throws away any objects that have been read in. Extreme caution should be used before doing this because object identity will no longer be maintained for any objects currently read in. This should only be called if the application knows that it no longer has references to object held in the cache.
    
    Specified by:
    
    initializeAllIdentityMaps in interface IdentityMapAccessor
  - initializeIdentityMap
```
public void initializeIdentityMap(Class<?> theClass)
```
    PUBLIC: Reset the identity map for only the instances of the class. For inheritance the user must make sure that they only use the root class. Caution must be used in doing this to ensure that the objects within the identity map are not referenced from other objects of other classes or from the application.
    
    Specified by:
    
    initializeIdentityMap in interface IdentityMapAccessor
    
    Parameters:
    
    theClass - Class
  - initializeIdentityMaps
```
public void initializeIdentityMaps()
```
    PUBLIC: Reset the entire local object cache. This throws away any objects that have been read in. Extreme caution should be used before doing this because object identity will no longer be maintained for any objects currently read in. This should only be called if the application knows that it no longer has references to object held in the cache.
    
    Specified by:
    
    initializeIdentityMaps in interface IdentityMapAccessor
  - invalidateObject
```
public void invalidateObject(Object object)
```
    ADVANCED: Set an object to be invalid in the cache. If the object does not exist in the cache, this method will return without any action.
    
    Specified by:
    
    invalidateObject in interface IdentityMapAccessor
    
    Parameters:
    
    object - Object
  - invalidateObject
```
public void invalidateObject(Object object,
                             boolean invalidateCluster)
```
    ADVANCED: Set an object to be invalid in the cache.
    
    Specified by:
    
    invalidateObject in interface IdentityMapAccessor
    
    Parameters:
    
    invalidateCluster - if true the invalidation will be broadcast to each server in the cluster.
  - invalidateObject
```
public void invalidateObject(Object primaryKey,
                             Class<?> theClass)
```
    ADVANCED: Set an object to be invalid in the cache. If the object does not exist in the cache, this method will return without any action.
    
    Specified by:
    
    invalidateObject in interface IdentityMapAccessor
  - invalidateObject
```
public void invalidateObject(Object primaryKey,
                             Class<?> theClass,
                             boolean invalidateCluster)
```
    ADVANCED: Set an object to be invalid in the cache.
    
    Specified by:
    
    invalidateObject in interface IdentityMapAccessor
    
    Parameters:
    
    invalidateCluster - if true the invalidation will be broadcast to each server in the cluster.
  - invalidateObject
```
public void invalidateObject(DataRecord rowContainingPrimaryKey,
                             Class<?> theClass)
```
    ADVANCED: Set an object to be invalid in the cache. If the object does not exist in the cache, this method will return without any action.
    
    Specified by:
    
    invalidateObject in interface IdentityMapAccessor
  - invalidateObject
```
public void invalidateObject(DataRecord rowContainingPrimaryKey,
                             Class<?> theClass,
                             boolean invalidateCluster)
```
    ADVANCED: Set an object to be invalid in the cache.
    
    Specified by:
    
    invalidateObject in interface IdentityMapAccessor
    
    Parameters:
    
    invalidateCluster - if true the invalidation will be broadcast to each server in the cluster.
  - invalidateObjects
```
public void invalidateObjects(Expression selectionCriteria)
```
    ADVANCED: Set all of the objects from the given Expression to be invalid in the cache.
    
    Specified by:
    
    invalidateObjects in interface IdentityMapAccessor
    
    Parameters:
    
    selectionCriteria - Expression
  - invalidateObjects
```
public void invalidateObjects(Expression selectionCriteria,
                              Class<?> theClass,
                              DataRecord translationRow,
                              boolean shouldInvalidateOnException)
```
    ADVANCED: Queries the cache in-memory with the passed in criteria and invalidates matching Objects. If the expression is too complex either all or none object of theClass invalidated (depending on shouldInvalidateOnException value).
    
    Specified by:
    
    invalidateObjects in interface IdentityMapAccessor
    
    Parameters:
    
    selectionCriteria - Expression selecting the Objects to be returned
    
    theClass - Class to be considered
    
    translationRow - Record
    
    shouldInvalidateOnException - boolean indicates weather to invalidate the object if conform threw exception.
  - invalidateObjects
```
public void invalidateObjects(Collection collection)
```
    ADVANCED: Set all of the objects in the given collection to be invalid in the cache. This method will take no action for any objects in the collection that do not exist in the cache.
    
    Specified by:
    
    invalidateObjects in interface IdentityMapAccessor
    
    Parameters:
    
    collection - objects to be invalidated
  - invalidateObjects
```
public void invalidateObjects(Collection collection,
                              boolean invalidateCluster)
```
    ADVANCED: Set all of the objects in the given collection to be invalid in the cache.
    
    Specified by:
    
    invalidateObjects in interface IdentityMapAccessor
    
    Parameters:
    
    invalidateCluster - if true the invalidation will be broadcast to each server in the cluster.
  - invalidateClass
```
public void invalidateClass(Class<?> myClass)
```
    ADVANCED: Set all of the objects of a specific class to be invalid in the cache. Will set the recurseAndInvalidateToParentRoot flag on inheritance to true.
    
    Specified by:
    
    invalidateClass in interface IdentityMapAccessor
  - invalidateClass
```
public void invalidateClass(Class<?> myClass,
                            boolean recurseAndInvalidateToParentRoot)
```
    ADVANCED: Set all of the objects of a specific class to be invalid in the cache. User can set the recurse flag to false if they do not want to invalidate all the classes within an inheritance tree and instead invalidate the subtree rooted at myClass.
    
    Specified by:
    
    invalidateClass in interface IdentityMapAccessor
    
    Parameters:
    
    myClass - - the class where we start invalidation
    
    recurseAndInvalidateToParentRoot - - default is true where we invalidate up the inheritance tree to the root descriptor
  - invalidateQueryCache
```
public void invalidateQueryCache(Class<?> classThatChanged)
```
    Invalidate/remove any results for the class from the query cache. This is used to invalidate the query cache on any change.
    
    Specified by:
    
    invalidateQueryCache in interface IdentityMapAccessor
  - invalidateAll
```
public void invalidateAll()
```
    ADVANCED: Set all of the objects from all identity maps to be invalid in the cache.
    
    Specified by:
    
    invalidateAll in interface IdentityMapAccessor
  - isValid
```
public boolean isValid(Object object)
```
    ADVANCED: Return if this object is valid in the cache.
    
    Specified by:
    
    isValid in interface IdentityMapAccessor
  - isValid
```
public boolean isValid(Object primaryKey,
                       Class<?> theClass)
```
    ADVANCED: Return if this object is valid in the cache.
    
    Specified by:
    
    isValid in interface IdentityMapAccessor
  - isValid
```
public boolean isValid(DataRecord rowContainingPrimaryKey,
                       Class<?> theClass)
```
    ADVANCED: Return if this object is valid in the cache.
    
    Specified by:
    
    isValid in interface IdentityMapAccessor
  - printIdentityMap
```
public void printIdentityMap(Class<?> businessClass)
```
    PUBLIC: Used to print all the objects in the identity map of the passed in class. The output of this method will be logged to this session's SessionLog at SEVERE level.
    
    Specified by:
    
    printIdentityMap in interface IdentityMapAccessor
  - printIdentityMaps
```
public void printIdentityMaps()
```
    PUBLIC: Used to print all the objects in every identity map in this session. The output of this method will be logged to this session's SessionLog at SEVERE level.
    
    Specified by:
    
    printIdentityMaps in interface IdentityMapAccessor
  - printIdentityMapLocks
```
public void printIdentityMapLocks()
```
    PUBLIC: Used to print all the locks in every identity map in this session. The output of this method will be logged to this session's SessionLog at FINEST level.
    
    Specified by:
    
    printIdentityMapLocks in interface IdentityMapAccessor
  - putInIdentityMap
```
public Object putInIdentityMap(Object object)
```
    ADVANCED: Register the object with the cache. The object must always be registered with its version number if optimistic locking is used.
    
    Specified by:
    
    putInIdentityMap in interface IdentityMapAccessor
    
    Parameters:
    
    object - Object
    
    Returns:
    
    Object
  - putInIdentityMap
```
public Object putInIdentityMap(Object object,
                               Object key)
```
    ADVANCED: Register the object with the cache. The object must always be registered with its version number if optimistic locking is used.
    
    Specified by:
    
    putInIdentityMap in interface IdentityMapAccessor
  - putInIdentityMap
```
public Object putInIdentityMap(Object object,
                               Object key,
                               Object writeLockValue)
```
    ADVANCED: Register the object with the cache. The object must always be registered with its version number if optimistic locking is used.
    
    Specified by:
    
    putInIdentityMap in interface IdentityMapAccessor
  - putInIdentityMap
```
public Object putInIdentityMap(Object object,
                               Object key,
                               Object writeLockValue,
                               long readTime)
```
    ADVANCED: Register the object with the cache. The object must always be registered with its version number if optimistic locking is used. The readTime may also be included in the cache key as it is constructed.
    
    Specified by:
    
    putInIdentityMap in interface IdentityMapAccessor
    
    Parameters:
    
    object - Object
    
    key - Object
    
    writeLockValue - Object for versioning
    
    readTime - long, time in milliseconds
    
    Returns:
    
    Object the Object put into the identity map
  - putInIdentityMap
```
public Object putInIdentityMap(Object object,
                               Object key,
                               Object writeLockValue,
                               long readTime,
                               ClassDescriptor descriptor)
```
    ADVANCED: Register the object with the cache. The object must always be registered with its version number if optimistic locking is used. The readTime may also be included in the cache key as it is constructed.
  - putQueryResult
```
public void putQueryResult(ReadQuery query,
                           List parameters,
                           Object results)
```
    INTERNAL: Set the results for a query. Query results are cached based on the parameter values provided to the query different parameter values access different caches.
  - putCacheKeyByIndex
```
public void putCacheKeyByIndex(CacheIndex index,
                               CacheId indexValues,
                               CacheKey cacheKey,
                               ClassDescriptor descriptor)
```
    Index the cache key by the index values.
  - getCacheKeyByIndex
```
public CacheKey getCacheKeyByIndex(CacheIndex index,
                                   CacheId indexValues,
                                   boolean shouldCheckExpiry,
                                   ClassDescriptor descriptor)
```
    Return the cache key for the cache index or null if not found.
  - internalPutInIdentityMap
```
public CacheKey internalPutInIdentityMap(Object object,
                                         Object key,
                                         Object writeLockValue,
                                         long readTime,
                                         ClassDescriptor descriptor)
```
    INTERNAL: Register the object with the cache. The object must always be registered with its version number if optimistic locking is used. The readTime may also be included in the cache key as it is constructed. Return the cache-key.
  - releaseWriteLock
```
public void releaseWriteLock()
```
    INTERNAL: Lock the entire cache if the cache isolation requires. By default concurrent reads and writes are allowed. By write, unit of work merge is meant.
  - removeFromIdentityMap
```
public Object removeFromIdentityMap(Object object)
```
    ADVANCED: Remove the object from the object cache. Caution should be used when calling to avoid violating object identity. The application should only call this is it knows that no references to the object exist.
    
    Specified by:
    
    removeFromIdentityMap in interface IdentityMapAccessor
    
    Parameters:
    
    object - Object
    
    Returns:
    
    Object the Object removed from the identity map
  - removeFromIdentityMap
```
public Object removeFromIdentityMap(Object key,
                                    Class<?> theClass)
```
    ADVANCED: Remove the object from the object cache.
    
    Specified by:
    
    removeFromIdentityMap in interface IdentityMapAccessor
    
    Returns:
    
    Object the Object removed from the identity map
  - removeFromIdentityMap
```
public Object removeFromIdentityMap(Object key,
                                    Class<?> theClass,
                                    ClassDescriptor descriptor,
                                    Object object)
```
    INTERNAL: Remove the object from the object cache.
  - setIdentityMapManager
```
public void setIdentityMapManager(IdentityMapManager identityMapManager)
```
    INTERNAL: Set the IdentityMapManager for this IdentityMapAccessor
  - setWrapper
```
public void setWrapper(Object primaryKey,
                       Class<?> theClass,
                       Object wrapper)
```
    INTERNAL: Update the wrapper object the cache key associated with the given primary key, this is used for EJB.
  - updateWriteLockValue
```
public void updateWriteLockValue(Object object,
                                 Object writeLockValue)
```
    ADVANCED: Update the write lock value in the cache.
    
    Specified by:
    
    updateWriteLockValue in interface IdentityMapAccessor
    
    Parameters:
    
    object - Object
    
    writeLockValue - Object for versioning
  - updateWriteLockValue
```
public void updateWriteLockValue(Object primaryKey,
                                 Class<?> theClass,
                                 Object writeLockValue)
```
    ADVANCED: Update the write lock value in the cache.
    
    Specified by:
    
    updateWriteLockValue in interface IdentityMapAccessor
  - validateCache
```
public void validateCache()
```
    INTERNAL: This can be used to help debugging an object identity problem. An object identity problem is when an object in the cache references an object not in the cache. This method will validate that all cached objects are in a correct state.
    
    Specified by:
    
    validateCache in interface IdentityMapAccessor

Modifier and Type	Field	Description
`protected IdentityMapManager`	`identityMapManager`	This is the identity map manager for this accessor.
`protected AbstractSession`	`session`

Class IdentityMapAccessor

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

identityMapManager

session

Constructor Detail

IdentityMapAccessor

IdentityMapAccessor

IdentityMapAccessor

Method Detail

acquireDeferredLock

acquireLock

acquireLock

acquireLockNoWait

acquireLockWithWait

acquireReadLockOnCacheKey

acquireReadLockOnCacheKeyNoWait

acquireWriteLock

clearQueryCache

clearQueryCache

clearQueryCache

clearQueryCache

containsObjectInIdentityMap

containsObjectInIdentityMap

containsObjectInIdentityMap

containsObjectInIdentityMap

extractPrimaryKeyFromRow

getCacheKeyForObject

getClassesRegistered

getAllFromIdentityMap

getAllFromIdentityMap

getAllFromIdentityMap

getAllFromIdentityMap

getAllFromIdentityMap

getAllFromIdentityMapWithEntityPK

getAllCacheKeysFromIdentityMapWithEntityPK

getFromIdentityMap

getCacheKeyForObject

getCacheKeyForObjectForLock

getCacheKeyForObject

getFromIdentityMap

getFromIdentityMap

getFromIdentityMap

getFromIdentityMap

getFromLocalIdentityMap

getFromLocalIdentityMapWithDeferredLock

getFromIdentityMap

getFromIdentityMap

getFromIdentityMap

getFromIdentityMap

getFromIdentityMap

getFromIdentityMap

getFromIdentityMap

getFromIdentityMap

getFromIdentityMapWithDeferredLock

getFromIdentityMapWithDeferredLock

getIdentityMapManager

getIdentityMap

getIdentityMap

getIdentityMap

getQueryResult

getRemainingValidTime

getSession

getWrapper

getWriteLockManager

getWriteLockValue

getWriteLockValue

getWriteLockValue

initializeAllIdentityMaps

initializeIdentityMap

initializeIdentityMaps

invalidateObject

invalidateObject

invalidateObject

invalidateObject

invalidateObject

invalidateObject