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

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)