|
|||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use CacheException | |
net.sf.hibernate.cache | |
net.sf.hibernate.collection |
Uses of CacheException in net.sf.hibernate.cache |
Methods in net.sf.hibernate.cache that throw CacheException | |
void |
UpdateTimestampsCache.clear()
|
void |
UpdateTimestampsCache.preinvalidate(Serializable[] spaces)
|
void |
UpdateTimestampsCache.invalidate(Serializable[] spaces)
|
Cache |
TreeCacheProvider.buildCache(String regionName,
Properties properties)
|
Object |
TreeCache.get(Object key)
|
void |
TreeCache.put(Object key,
Object value)
|
void |
TreeCache.remove(Object key)
|
void |
TreeCache.clear()
|
void |
TreeCache.destroy()
|
void |
TreeCache.lock(Object key)
|
void |
TreeCache.unlock(Object key)
|
Object |
TransactionalCache.get(Object key,
long txTimestamp)
|
boolean |
TransactionalCache.put(Object key,
Object value,
long txTimestamp)
|
CacheConcurrencyStrategy.SoftLock |
TransactionalCache.lock(Object key)
Do nothing, returning null. |
void |
TransactionalCache.release(Object key,
CacheConcurrencyStrategy.SoftLock clientLock)
Do nothing. |
void |
TransactionalCache.update(Object key,
Object value)
|
void |
TransactionalCache.insert(Object key,
Object value)
|
void |
TransactionalCache.evict(Object key)
|
void |
TransactionalCache.remove(Object key)
|
void |
TransactionalCache.clear()
|
void |
TransactionalCache.afterInsert(Object key,
Object value)
Do nothing. |
void |
TransactionalCache.afterUpdate(Object key,
Object value,
CacheConcurrencyStrategy.SoftLock clientLock)
Do nothing. |
Cache |
SwarmCacheProvider.buildCache(String s,
Properties properties)
|
Object |
SwarmCache.get(Object key)
Get an item from the cache |
void |
SwarmCache.put(Object key,
Object value)
Add an item to the cache |
void |
SwarmCache.remove(Object key)
Remove an item from the cache |
void |
SwarmCache.clear()
Clear the cache |
void |
SwarmCache.destroy()
Clean up |
void |
SwarmCache.lock(Object key)
If this is a clustered cache, lock the item |
void |
SwarmCache.unlock(Object key)
If this is a clustered cache, unlock the item |
void |
StandardQueryCache.clear()
|
Object |
ReadWriteCache.get(Object key,
long txTimestamp)
Do not return an item whose timestamp is later than the current transaction timestamp. |
CacheConcurrencyStrategy.SoftLock |
ReadWriteCache.lock(Object key)
Stop any other transactions reading or writing this item to/from the cache. |
boolean |
ReadWriteCache.put(Object key,
Object value,
long txTimestamp)
Do not add an item to the cache unless the current transaction timestamp is later than the timestamp at which the item was invalidated. |
void |
ReadWriteCache.release(Object key,
CacheConcurrencyStrategy.SoftLock clientLock)
Release the soft lock on the item. |
void |
ReadWriteCache.clear()
|
void |
ReadWriteCache.remove(Object key)
|
void |
ReadWriteCache.afterUpdate(Object key,
Object value,
CacheConcurrencyStrategy.SoftLock clientLock)
Re-cache the updated state, if and only if there there are no other concurrent soft locks. |
void |
ReadWriteCache.afterInsert(Object key,
Object value)
Add the new item to the cache, checking that no other transaction has accessed the item. |
void |
ReadWriteCache.evict(Object key)
Do nothing. |
void |
ReadWriteCache.insert(Object key,
Object value)
Do nothing. |
void |
ReadWriteCache.update(Object key,
Object value)
Do nothing. |
Object |
ReadOnlyCache.get(Object key,
long timestamp)
|
boolean |
ReadOnlyCache.put(Object key,
Object value,
long timestamp)
|
void |
ReadOnlyCache.clear()
|
void |
ReadOnlyCache.remove(Object key)
|
void |
ReadOnlyCache.afterUpdate(Object key,
Object value,
CacheConcurrencyStrategy.SoftLock lock)
Unsupported! |
void |
ReadOnlyCache.afterInsert(Object key,
Object value)
Do nothing. |
void |
ReadOnlyCache.evict(Object key)
Do nothing. |
void |
ReadOnlyCache.insert(Object key,
Object value)
Do nothing. |
void |
ReadOnlyCache.update(Object key,
Object value)
Unsupported! |
void |
QueryCache.clear()
|
Cache |
OSCacheProvider.buildCache(String region,
Properties properties)
Builds a new Cache instance, and gets it's properties from the OSCache Config
which reads the properties file (oscache.properties ) from the classpath. |
Object |
OSCache.get(Object key)
|
void |
OSCache.put(Object key,
Object value)
|
void |
OSCache.remove(Object key)
|
void |
OSCache.clear()
|
void |
OSCache.destroy()
|
void |
OSCache.lock(Object key)
|
void |
OSCache.unlock(Object key)
|
Object |
NonstrictReadWriteCache.get(Object key,
long txTimestamp)
Get the most recent version, if available. |
boolean |
NonstrictReadWriteCache.put(Object key,
Object value,
long txTimestamp)
Add an item to the cache. |
CacheConcurrencyStrategy.SoftLock |
NonstrictReadWriteCache.lock(Object key)
Do nothing. |
void |
NonstrictReadWriteCache.remove(Object key)
|
void |
NonstrictReadWriteCache.clear()
|
void |
NonstrictReadWriteCache.evict(Object key)
Invalidate the item |
void |
NonstrictReadWriteCache.update(Object key,
Object value)
Invalidate the item |
void |
NonstrictReadWriteCache.insert(Object key,
Object value)
Do nothing. |
void |
NonstrictReadWriteCache.release(Object key,
CacheConcurrencyStrategy.SoftLock lock)
Invalidate the item (again, for safety). |
void |
NonstrictReadWriteCache.afterUpdate(Object key,
Object value,
CacheConcurrencyStrategy.SoftLock lock)
Invalidate the item (again, for safety). |
void |
NonstrictReadWriteCache.afterInsert(Object key,
Object value)
Do nothing. |
Cache |
JCSCacheProvider.buildCache(String regionName,
Properties properties)
Deprecated. |
void |
JCSCache.put(Object key,
Object value)
Deprecated. |
void |
JCSCache.remove(Object key)
Deprecated. |
void |
JCSCache.clear()
Deprecated. |
void |
JCSCache.destroy()
Deprecated. |
void |
JCSCache.lock(Object key)
Deprecated. |
void |
JCSCache.unlock(Object key)
Deprecated. |
Cache |
HashtableCacheProvider.buildCache(String regionName,
Properties properties)
|
Object |
HashtableCache.get(Object key)
|
void |
HashtableCache.put(Object key,
Object value)
|
void |
HashtableCache.remove(Object key)
|
void |
HashtableCache.clear()
|
void |
HashtableCache.destroy()
|
void |
HashtableCache.lock(Object key)
|
void |
HashtableCache.unlock(Object key)
|
Cache |
EhCacheProvider.buildCache(String name,
Properties properties)
Builds a Cache. |
Object |
EhCache.get(Object key)
Gets a value of an element which matches the given key. |
void |
EhCache.put(Object key,
Object value)
Puts an object into the cache. |
void |
EhCache.remove(Object key)
Removes the element which matches the key. |
void |
EhCache.clear()
Remove all elements in the cache, but leave the cache in a useable state. |
void |
EhCache.destroy()
Remove the cache and make it unuseable. |
void |
EhCache.lock(Object key)
Calls to this method should perform there own synchronization. |
void |
EhCache.unlock(Object key)
Calls to this method should perform there own synchronization. |
Cache |
CacheProvider.buildCache(String regionName,
Properties properties)
Configure the cache |
Object |
CacheConcurrencyStrategy.get(Object key,
long txTimestamp)
Attempt to retrieve an object from the cache. |
boolean |
CacheConcurrencyStrategy.put(Object key,
Object value,
long txTimestamp)
Attempt to cache an object, after loading from the database. |
CacheConcurrencyStrategy.SoftLock |
CacheConcurrencyStrategy.lock(Object key)
We are going to attempt to update/delete the keyed object. |
void |
CacheConcurrencyStrategy.evict(Object key)
Called after an item has become stale (before the transaction completes). |
void |
CacheConcurrencyStrategy.update(Object key,
Object value)
Called after an item has been updated (before the transaction completes), instead of calling evict(). |
void |
CacheConcurrencyStrategy.insert(Object key,
Object value)
Called after an item has been inserted (before the transaction completes), instead of calling evict(). |
void |
CacheConcurrencyStrategy.release(Object key,
CacheConcurrencyStrategy.SoftLock lock)
Called when we have finished the attempted update/delete (which may or may not have been successful), after transaction completion. |
void |
CacheConcurrencyStrategy.afterUpdate(Object key,
Object value,
CacheConcurrencyStrategy.SoftLock lock)
Called after an item has been updated (after the transaction completes), instead of calling release(). |
void |
CacheConcurrencyStrategy.afterInsert(Object key,
Object value)
Called after an item has been inserted (after the transaction completes), instead of calling release(). |
void |
CacheConcurrencyStrategy.remove(Object key)
Evict an item from the cache immediately (without regard for transaction isolation). |
void |
CacheConcurrencyStrategy.clear()
Evict all items from the cache immediately. |
Object |
Cache.get(Object key)
Get an item from the cache |
void |
Cache.put(Object key,
Object value)
Add an item to the cache |
void |
Cache.remove(Object key)
Remove an item from the cache |
void |
Cache.clear()
Clear the cache |
void |
Cache.destroy()
Clean up |
void |
Cache.lock(Object key)
If this is a clustered cache, lock the item |
void |
Cache.unlock(Object key)
If this is a clustered cache, unlock the item |
Constructors in net.sf.hibernate.cache that throw CacheException | |
TreeCache(String regionName,
Properties props)
|
|
JCSCache(String regionName,
Properties properties)
Deprecated. |
|
EhCache(String name)
Creates a new Hibernate pluggable cache based on a cache name. |
Uses of CacheException in net.sf.hibernate.collection |
Constructors in net.sf.hibernate.collection that throw CacheException | |
OneToManyPersister(Collection collection,
Configuration cfg,
SessionFactoryImplementor factory)
|
|
BasicCollectionPersister(Collection collection,
Configuration cfg,
SessionFactoryImplementor factory)
|
|
AbstractCollectionPersister(Collection collection,
Configuration cfg,
SessionFactoryImplementor factory)
|
|
|||||||||||
PREV NEXT | FRAMES NO FRAMES |