|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectorg.apache.openjpa.datacache.DelegatingDataCache
public class DelegatingDataCache
Delegating data cache that can also perform exception translation for use in facades. This cache allows its delegate to be null, in which case it returns default values for all operations.
| Field Summary |
|---|
| Fields inherited from interface org.apache.openjpa.datacache.DataCache |
|---|
NAME_DEFAULT |
| Constructor Summary | |
|---|---|
DelegatingDataCache(DataCache cache)
Constructor. |
|
DelegatingDataCache(DataCache cache,
RuntimeExceptionTranslator trans)
|
|
| Method Summary | |
|---|---|
void |
addExpirationListener(ExpirationListener listen)
Add a new expiration event listener to this cache. |
void |
clear()
Remove all data from this cache. |
void |
close()
Free the resources used by this cache. |
void |
commit(Collection<DataCachePCData> additions,
Collection<DataCachePCData> newUpdates,
Collection<DataCachePCData> existingUpdates,
Collection<Object> deletes)
Perform a batch update of the cache. |
boolean |
contains(Object oid)
Returns true if this cache contains data
corresponding to oid; otherwise returns
false. |
BitSet |
containsAll(Collection<Object> oids)
Returns the indexes of the oids in this cache. |
boolean |
equals(Object other)
|
DataCachePCData |
get(Object oid)
Return the cached object for the given oid. |
Map<Object,DataCachePCData> |
getAll(List<Object> keys)
Gets objects from the caches for a given list of keys. |
DataCache |
getDelegate()
Return the direct delegate. |
boolean |
getEvictOnBulkUpdate()
Returns whether the the cache needs to be updated when bulk updates as executed. |
DataCache |
getInnermostDelegate()
Return the native delegate. |
String |
getName()
Returns a string name that can be used by end-user-visible code to identify this cache. |
DataCache |
getPartition(String name,
boolean create)
Gets the named partition. |
Set<String> |
getPartitionNames()
Gets the name of the known partitions. |
CacheStatistics |
getStatistics()
Returns number of read/write request and cache hit ratio data. |
int |
hashCode()
|
void |
initialize(DataCacheManager manager)
Initialize any resources associated with the given DataCacheManager. |
boolean |
isPartitioned()
Affirms if this cache maintains partitions. |
boolean |
pin(Object oid)
Pin the value stored under oid into the cache. |
void |
pinAll(Class<?> cls,
boolean subs)
Pin all oids for the given type. |
BitSet |
pinAll(Collection<Object> oids)
Pin all oids to the cache. |
DataCachePCData |
put(DataCachePCData value)
Set the cached value for the given instance. |
DataCachePCData |
remove(Object oid)
Remove the value stored under the given oid. |
void |
removeAll(Class<?> cls,
boolean subclasses)
Evict all values of a specified type. |
BitSet |
removeAll(Collection<Object> oids)
Remove the values stored under the given oids. |
boolean |
removeExpirationListener(ExpirationListener listen)
Remove an expiration event listener from this cache. |
void |
setName(String name)
Sets a string name to be used to identify this cache to end-user needs. |
protected RuntimeException |
translate(RuntimeException re)
Translate the OpenJPA exception. |
boolean |
unpin(Object oid)
Unpin the value stored under oid from the cache. |
void |
unpinAll(Class<?> cls,
boolean subs)
Unpin all oids associaed with the given type from the cache. |
BitSet |
unpinAll(Collection<Object> oids)
Unpin all oids from the cache. |
void |
update(DataCachePCData value)
Update the cached value for the given instance. |
void |
writeLock()
Obtain a write lock on the cache. |
void |
writeUnlock()
Release the write lock on the cache. |
| Methods inherited from class java.lang.Object |
|---|
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public DelegatingDataCache(DataCache cache)
public DelegatingDataCache(DataCache cache,
RuntimeExceptionTranslator trans)
| Method Detail |
|---|
public DataCache getDelegate()
public DataCache getInnermostDelegate()
public int hashCode()
hashCode in class Objectpublic boolean equals(Object other)
equals in class Objectprotected RuntimeException translate(RuntimeException re)
public String getName()
DataCache
getName in interface DataCachepublic void setName(String name)
DataCache
setName in interface DataCachepublic void initialize(DataCacheManager manager)
DataCacheDataCacheManager.
initialize in interface DataCache
public void commit(Collection<DataCachePCData> additions,
Collection<DataCachePCData> newUpdates,
Collection<DataCachePCData> existingUpdates,
Collection<Object> deletes)
DataCacheDataCachePCData
objects in additions and in
newUpdates, make the appropriate modifications to
all DataCachePCDatas in existingUpdates, and delete all
OIDs in deletes.
All changes made to cached data must be made via this
method. It is this method that is responsible for performing
any side-effects that should happen on meaningful cache changes.
Implementations should bear in mind that the
deletes collection may contain oids that are also
in the additions map. This is possible because it
is valid for a user to delete an object with a particular oid
and then add that object in the same batch.
commit in interface DataCacheadditions - A collection of DataCachePCData objects.
These represent data that have been newly created,
and thus must be added to the cache.newUpdates - A collection of DataCachePCData objects.
These represent data that have been modified but
were not originally in the cache, and thus must be added to the cache.existingUpdates - A collection of DataCachePCData objects.
These represent data that have been modified and
were originally loaded from the cache. It is
up to the cache implementation to decide if
these values must be re-enlisted in the cache.
Some caches may return live data from DataCache.get(java.lang.Object)
invocations, in which case these values need not be re-enlisted.deletes - A collection of object IDs that have been deleted
and must therefore be dropped from the cache.public boolean contains(Object oid)
DataCachetrue if this cache contains data
corresponding to oid; otherwise returns
false.
contains in interface DataCachepublic BitSet containsAll(Collection<Object> oids)
DataCache
containsAll in interface DataCachepublic DataCachePCData get(Object oid)
DataCacheDataCache.update(org.apache.openjpa.datacache.DataCachePCData)
method should be used to re-cache any changed objects.
get in interface DataCachepublic DataCachePCData put(DataCachePCData value)
DataCacheDataCache.commit(java.util.Collection, java.util.Collection, java.util.Collection, java.util.Collection) method.
put in interface DataCachenull if
the value was not previously cached. See Map.put(K, V)
for more information.public void update(DataCachePCData value)
DataCacheDataCache.commit(java.util.Collection, java.util.Collection, java.util.Collection, java.util.Collection) method.
A cache implementation may or may not return a live object
from DataCache.get(java.lang.Object) invocations. If an object retrieved from a
DataCache.get(java.lang.Object) operation needs to be updated, this method can be
invoked instead of invoking DataCache.put(org.apache.openjpa.datacache.DataCachePCData). The DataCache implementation
can then make optimizations based on how its DataCache.get(java.lang.Object) method works.
update in interface DataCachepublic DataCachePCData remove(Object oid)
DataCacheDataCache.commit(java.util.Collection, java.util.Collection, java.util.Collection, java.util.Collection) method.
remove in interface DataCachenull if
the oid was not previously cached. See Map.remove(java.lang.Object)
for more information.public BitSet removeAll(Collection<Object> oids)
DataCache
removeAll in interface DataCacheDataCache.remove(java.lang.Object)
public void removeAll(Class<?> cls,
boolean subclasses)
DataCache
removeAll in interface DataCachepublic void clear()
DataCacheDataCache.commit(java.util.Collection, java.util.Collection, java.util.Collection, java.util.Collection) method.
clear in interface DataCacheclear in interface Clearablepublic boolean pin(Object oid)
DataCacheoid into the cache.
This method guarantees that oid's value will not
be dropped by the caching algorithm. This method does not
affect the behavior of DataCache.remove(java.lang.Object).
pin in interface DataCachetrue if oid's value was
pinned into the cache; false if the oid is not in the cache.public BitSet pinAll(Collection<Object> oids)
DataCache
pinAll in interface DataCacheDataCache.pin(java.lang.Object)
public void pinAll(Class<?> cls,
boolean subs)
DataCache
pinAll in interface DataCachesubs - Whether to include subclasses.public boolean unpin(Object oid)
DataCacheoid from the cache.
This method reverses a previous invocation of DataCache.pin(java.lang.Object).
This method does not remove anything from the cache; it merely
makes oid's value a candidate for flushing from the cache.
unpin in interface DataCachetrue if oid's value was
unpinned from the cache; false if the
oid is not in the cache.public BitSet unpinAll(Collection<Object> oids)
DataCache
unpinAll in interface DataCacheDataCache.unpin(java.lang.Object)
public void unpinAll(Class<?> cls,
boolean subs)
DataCache
unpinAll in interface DataCachesubs - Whether to include subclasses.public void writeLock()
DataCache
writeLock in interface DataCachepublic void writeUnlock()
DataCache
writeUnlock in interface DataCachepublic void addExpirationListener(ExpirationListener listen)
DataCache
addExpirationListener in interface DataCachepublic boolean removeExpirationListener(ExpirationListener listen)
DataCache
removeExpirationListener in interface DataCachepublic void close()
DataCache
close in interface DataCacheclose in interface Closeablepublic Map<Object,DataCachePCData> getAll(List<Object> keys)
DataCache
getAll in interface DataCachepublic CacheStatistics getStatistics()
DataCache
getStatistics in interface DataCache
public DataCache getPartition(String name,
boolean create)
DataCache
getPartition in interface DataCachename - name of the given partition.create - if true optionally create a new partition.
public Set<String> getPartitionNames()
DataCache
getPartitionNames in interface DataCachepublic boolean isPartitioned()
DataCache
isPartitioned in interface DataCachepublic boolean getEvictOnBulkUpdate()
DataCache
getEvictOnBulkUpdate in interface DataCache
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||