Uses of Class
org.hibernate.cache.CacheException

Packages that use CacheException
org.hibernate.action This package defines "actions" that are scheduled for asycnchronous execution by the event listeners. 
org.hibernate.cache This package defines APIs and implementations for the second-level cache and query cache. 
org.hibernate.persister.collection This package abstracts the persistence mechanism for collections. 
 

Uses of CacheException in org.hibernate.action
 

Methods in org.hibernate.action that throw CacheException
 void CollectionAction.afterTransactionCompletion(boolean success)
           
 void EntityUpdateAction.afterTransactionCompletion(boolean success)
           
 void CollectionAction.beforeExecutions()
           
protected  void CollectionAction.evict()
           
 

Constructors in org.hibernate.action that throw CacheException
CollectionAction(CollectionPersister persister, PersistentCollection collection, Serializable key, SessionImplementor session)
           
CollectionRecreateAction(PersistentCollection collection, CollectionPersister persister, Serializable id, SessionImplementor session)
           
CollectionRemoveAction(Object affectedOwner, CollectionPersister persister, Serializable id, boolean emptySnapshot, SessionImplementor session)
          Removes a persistent collection from a specified owner.
CollectionRemoveAction(PersistentCollection collection, CollectionPersister persister, Serializable id, boolean emptySnapshot, SessionImplementor session)
          Removes a persistent collection from its loaded owner.
CollectionUpdateAction(PersistentCollection collection, CollectionPersister persister, Serializable id, boolean emptySnapshot, SessionImplementor session)
           
 

Uses of CacheException in org.hibernate.cache
 

Subclasses of CacheException in org.hibernate.cache
 class NoCachingEnabledException
          Implementation of NoCachingEnabledException.
 

Methods in org.hibernate.cache that throw CacheException
 boolean ReadWriteCache.afterInsert(Object key, Object value, Object version)
          Add the new item to the cache, checking that no other transaction has accessed the item.
 boolean CacheConcurrencyStrategy.afterInsert(Object key, Object value, Object version)
          Called after an item has been inserted (after the transaction completes), instead of calling release().
 boolean ReadOnlyCache.afterInsert(Object key, Object value, Object version)
          Do nothing.
 boolean NonstrictReadWriteCache.afterInsert(Object key, Object value, Object version)
          Do nothing.
 boolean TransactionalCache.afterInsert(Object key, Object value, Object version)
          Do nothing.
 boolean ReadWriteCache.afterUpdate(Object key, Object value, Object version, CacheConcurrencyStrategy.SoftLock clientLock)
          Re-cache the updated state, if and only if there there are no other concurrent soft locks.
 boolean CacheConcurrencyStrategy.afterUpdate(Object key, Object value, Object version, CacheConcurrencyStrategy.SoftLock lock)
          Called after an item has been updated (after the transaction completes), instead of calling release().
 boolean ReadOnlyCache.afterUpdate(Object key, Object value, Object version, CacheConcurrencyStrategy.SoftLock lock)
          Unsupported!
 boolean NonstrictReadWriteCache.afterUpdate(Object key, Object value, Object version, CacheConcurrencyStrategy.SoftLock lock)
          Invalidate the item (again, for safety).
 boolean TransactionalCache.afterUpdate(Object key, Object value, Object version, CacheConcurrencyStrategy.SoftLock clientLock)
          Do nothing.
 Cache TreeCacheProvider.buildCache(String regionName, Properties properties)
          Construct and configure the Cache representation of a named cache region.
 Cache HashtableCacheProvider.buildCache(String regionName, Properties properties)
           
 Cache CacheProvider.buildCache(String regionName, Properties properties)
          Configure the cache
 Cache NoCacheProvider.buildCache(String regionName, Properties properties)
          Configure the cache
 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.
 Cache SwarmCacheProvider.buildCache(String regionName, Properties properties)
           
 Cache EhCacheProvider.buildCache(String name, Properties properties)
          Builds a Cache.
 Cache JndiBoundTreeCacheProvider.buildCache(String regionName, Properties properties)
          Construct a Cache representing the "region" within in the underlying cache provider.
 Cache OptimisticTreeCacheProvider.buildCache(String regionName, Properties properties)
          Construct and configure the Cache representation of a named cache region.
 void ReadWriteCache.clear()
           
 void EhCache.clear()
          Remove all elements in the cache, but leave the cache in a useable state.
 void StandardQueryCache.clear()
           
 void SwarmCache.clear()
          Clear the cache
 void CacheConcurrencyStrategy.clear()
          Evict all items from the cache immediately.
 void ReadOnlyCache.clear()
           
 void TreeCache.clear()
           
 void NonstrictReadWriteCache.clear()
           
 void UpdateTimestampsCache.clear()
           
 void TransactionalCache.clear()
           
 void Cache.clear()
          Clear the cache
 void OSCache.clear()
           
 void OptimisticTreeCache.clear()
           
 void HashtableCache.clear()
           
 void QueryCache.clear()
           
 void EhCache.destroy()
          Remove the cache and make it unuseable.
 void SwarmCache.destroy()
          Clean up
 void TreeCache.destroy()
           
 void Cache.destroy()
          Clean up
 void OSCache.destroy()
           
 void OptimisticTreeCache.destroy()
           
 void HashtableCache.destroy()
           
 void ReadWriteCache.evict(Object key)
          Do nothing.
 void CacheConcurrencyStrategy.evict(Object key)
          Called after an item has become stale (before the transaction completes).
 void ReadOnlyCache.evict(Object key)
          Do nothing.
 void NonstrictReadWriteCache.evict(Object key)
          Invalidate the item
 void TransactionalCache.evict(Object key)
           
 Object EhCache.get(Object key)
          Gets a value of an element which matches the given key.
 Object SwarmCache.get(Object key)
          Get an item from the cache
 Object TreeCache.get(Object key)
           
 Object Cache.get(Object key)
          Get an item from the cache, nontransactionally
 Object OSCache.get(Object key)
           
 Object OptimisticTreeCache.get(Object key)
           
 Object HashtableCache.get(Object key)
           
 Object ReadWriteCache.get(Object key, long txTimestamp)
          Do not return an item whose timestamp is later than the current transaction timestamp.
 Object CacheConcurrencyStrategy.get(Object key, long txTimestamp)
          Attempt to retrieve an object from the cache.
 Object ReadOnlyCache.get(Object key, long timestamp)
           
 Object NonstrictReadWriteCache.get(Object key, long txTimestamp)
          Get the most recent version, if available.
 Object TransactionalCache.get(Object key, long txTimestamp)
           
 boolean CacheConcurrencyStrategy.insert(Object key, Object value, Object currentVersion)
          Called after an item has been inserted (before the transaction completes), instead of calling evict().
 boolean TransactionalCache.insert(Object key, Object value, Object currentVersion)
           
 void UpdateTimestampsCache.invalidate(Serializable[] spaces)
           
 void EhCache.lock(Object key)
          Calls to this method should perform there own synchronization.
 void SwarmCache.lock(Object key)
          If this is a clustered cache, lock the item
 void TreeCache.lock(Object key)
           
 void Cache.lock(Object key)
          If this is a clustered cache, lock the item
 void OSCache.lock(Object key)
           
 void OptimisticTreeCache.lock(Object key)
           
 void HashtableCache.lock(Object key)
           
 CacheConcurrencyStrategy.SoftLock ReadWriteCache.lock(Object key, Object version)
          Stop any other transactions reading or writing this item to/from the cache.
 CacheConcurrencyStrategy.SoftLock CacheConcurrencyStrategy.lock(Object key, Object version)
          We are going to attempt to update/delete the keyed object.
 CacheConcurrencyStrategy.SoftLock NonstrictReadWriteCache.lock(Object key, Object version)
          Do nothing.
 CacheConcurrencyStrategy.SoftLock TransactionalCache.lock(Object key, Object version)
          Do nothing, returning null.
 void UpdateTimestampsCache.preinvalidate(Serializable[] spaces)
           
 void JndiBoundTreeCacheProvider.prepare(Properties properties)
           
 void EhCache.put(Object key, Object value)
          Puts an object into the cache.
 void SwarmCache.put(Object key, Object value)
          Add an item to the cache
 void TreeCache.put(Object key, Object value)
           
 void Cache.put(Object key, Object value)
          Add an item to the cache, nontransactionally, with failfast semantics
 void OSCache.put(Object key, Object value)
           
 void OptimisticTreeCache.put(Object key, Object value)
           
 void HashtableCache.put(Object key, Object value)
           
 boolean ReadWriteCache.put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut)
          Do not add an item to the cache unless the current transaction timestamp is later than the timestamp at which the item was invalidated.
 boolean CacheConcurrencyStrategy.put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut)
          Attempt to cache an object, after loading from the database.
 boolean ReadOnlyCache.put(Object key, Object value, long timestamp, Object version, Comparator versionComparator, boolean minimalPut)
           
 boolean NonstrictReadWriteCache.put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut)
          Add an item to the cache.
 boolean TransactionalCache.put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut)
           
 Object EhCache.read(Object key)
           
 Object SwarmCache.read(Object key)
           
 Object TreeCache.read(Object key)
           
 Object Cache.read(Object key)
          Get an item from the cache
 Object OSCache.read(Object key)
           
 Object OptimisticTreeCache.read(Object key)
           
 Object HashtableCache.read(Object key)
           
 void ReadWriteCache.release(Object key, CacheConcurrencyStrategy.SoftLock clientLock)
          Release the soft lock on the item.
 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 NonstrictReadWriteCache.release(Object key, CacheConcurrencyStrategy.SoftLock lock)
          Invalidate the item (again, for safety).
 void TransactionalCache.release(Object key, CacheConcurrencyStrategy.SoftLock clientLock)
          Do nothing.
 void ReadWriteCache.remove(Object key)
           
 void EhCache.remove(Object key)
          Removes the element which matches the key.
 void SwarmCache.remove(Object key)
          Remove an item from the cache
 void CacheConcurrencyStrategy.remove(Object key)
          Evict an item from the cache immediately (without regard for transaction isolation).
 void ReadOnlyCache.remove(Object key)
           
 void TreeCache.remove(Object key)
           
 void NonstrictReadWriteCache.remove(Object key)
           
 void TransactionalCache.remove(Object key)
           
 void Cache.remove(Object key)
          Remove an item from the cache
 void OSCache.remove(Object key)
           
 void OptimisticTreeCache.remove(Object key)
           
 void HashtableCache.remove(Object key)
           
 void HashtableCacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
 void CacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
 void NoCacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
 void OSCacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
 void AbstractJndiBoundCacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
 void SwarmCacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
 void EhCacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
 void EhCache.unlock(Object key)
          Calls to this method should perform there own synchronization.
 void SwarmCache.unlock(Object key)
          If this is a clustered cache, unlock the item
 void TreeCache.unlock(Object key)
           
 void Cache.unlock(Object key)
          If this is a clustered cache, unlock the item
 void OSCache.unlock(Object key)
           
 void OptimisticTreeCache.unlock(Object key)
           
 void HashtableCache.unlock(Object key)
           
 void EhCache.update(Object key, Object value)
          Puts an object into the cache.
 void SwarmCache.update(Object key, Object value)
          Add an item to the cache
 void TreeCache.update(Object key, Object value)
           
 void Cache.update(Object key, Object value)
          Add an item to the cache
 void OSCache.update(Object key, Object value)
           
 void OptimisticTreeCache.update(Object key, Object value)
           
 void HashtableCache.update(Object key, Object value)
           
 boolean CacheConcurrencyStrategy.update(Object key, Object value, Object currentVersion, Object previousVersion)
          Called after an item has been updated (before the transaction completes), instead of calling evict().
 boolean TransactionalCache.update(Object key, Object value, Object currentVersion, Object previousVersion)
           
 

Constructors in org.hibernate.cache that throw CacheException
OptimisticTreeCache(org.jboss.cache.TreeCache cache, String regionName)
           
TreeCache(org.jboss.cache.TreeCache cache, String regionName, TransactionManager transactionManager)
           
 

Uses of CacheException in org.hibernate.persister.collection
 

Constructors in org.hibernate.persister.collection that throw CacheException
AbstractCollectionPersister(Collection collection, CacheConcurrencyStrategy cache, Configuration cfg, SessionFactoryImplementor factory)
           
BasicCollectionPersister(Collection collection, CacheConcurrencyStrategy cache, Configuration cfg, SessionFactoryImplementor factory)
           
OneToManyPersister(Collection collection, CacheConcurrencyStrategy cache, Configuration cfg, SessionFactoryImplementor factory)