Uses of Class
org.hibernate.cache.CacheException

Packages that use CacheException
org.hibernate.action   
org.hibernate.cache   
org.hibernate.persister.collection   
 

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 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 ReadOnlyCache.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 TransactionalCache.afterInsert(Object key, Object value, Object version)
          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 ReadOnlyCache.afterUpdate(Object key, Object value, Object version, CacheConcurrencyStrategy.SoftLock lock)
          Unsupported!
 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 TransactionalCache.afterUpdate(Object key, Object value, Object version, CacheConcurrencyStrategy.SoftLock clientLock)
          Do nothing.
 Cache CacheProvider.buildCache(String regionName, Properties properties)
          Configure the cache
 Cache EhCacheProvider.buildCache(String name, Properties properties)
          Builds a Cache.
 Cache HashtableCacheProvider.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 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 OptimisticTreeCacheProvider.buildCache(String regionName, Properties properties)
          Construct and configure the Cache representation of a named cache region.
 Cache SwarmCacheProvider.buildCache(String regionName, Properties properties)
           
 Cache TreeCacheProvider.buildCache(String regionName, Properties properties)
          Construct and configure the Cache representation of a named cache region.
 void Cache.clear()
          Clear the cache
 void CacheConcurrencyStrategy.clear()
          Evict all items from the cache immediately.
 void HashtableCache.clear()
           
 void NonstrictReadWriteCache.clear()
           
 void OSCache.clear()
           
 void OptimisticTreeCache.clear()
           
 void QueryCache.clear()
           
 void ReadOnlyCache.clear()
           
 void ReadWriteCache.clear()
           
 void StandardQueryCache.clear()
           
 void SwarmCache.clear()
          Clear the cache
 void TransactionalCache.clear()
           
 void TreeCache.clear()
           
 void UpdateTimestampsCache.clear()
           
 void EhCache.clear()
          Remove all elements in the cache, but leave the cache in a useable state.
 void Cache.destroy()
          Clean up
 void HashtableCache.destroy()
           
 void OSCache.destroy()
           
 void OptimisticTreeCache.destroy()
           
 void SwarmCache.destroy()
          Clean up
 void TreeCache.destroy()
           
 void EhCache.destroy()
          Remove the cache and make it unuseable.
 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 ReadOnlyCache.evict(Object key)
          Do nothing.
 void ReadWriteCache.evict(Object key)
          Do nothing.
 void TransactionalCache.evict(Object key)
           
 Object Cache.get(Object key)
          Get an item from the cache, nontransactionally
 Object HashtableCache.get(Object key)
           
 Object OSCache.get(Object key)
           
 Object OptimisticTreeCache.get(Object key)
           
 Object SwarmCache.get(Object key)
          Get an item from the cache
 Object TreeCache.get(Object key)
           
 Object EhCache.get(Object key)
          Gets a value of an element which matches the given key.
 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 ReadOnlyCache.get(Object key, long timestamp)
           
 Object ReadWriteCache.get(Object key, long txTimestamp)
          Do not return an item whose timestamp is later than the current transaction timestamp.
 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 Cache.lock(Object key)
          If this is a clustered cache, lock the item
 void HashtableCache.lock(Object key)
           
 void OSCache.lock(Object key)
           
 void OptimisticTreeCache.lock(Object key)
           
 void SwarmCache.lock(Object key)
          If this is a clustered cache, lock the item
 void TreeCache.lock(Object key)
           
 void EhCache.lock(Object key)
          Calls to this method should perform there own synchronization.
 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.
 CacheConcurrencyStrategy.SoftLock TransactionalCache.lock(Object key, Object version)
          Do nothing, returning null.
 void UpdateTimestampsCache.preinvalidate(Serializable[] spaces)
           
 void JndiBoundTreeCacheProvider.prepare(Properties properties)
           
 void Cache.put(Object key, Object value)
          Add an item to the cache, nontransactionally, with failfast semantics
 void HashtableCache.put(Object key, Object value)
           
 void OSCache.put(Object key, Object value)
           
 void OptimisticTreeCache.put(Object key, Object value)
           
 void SwarmCache.put(Object key, Object value)
          Add an item to the cache
 void TreeCache.put(Object key, Object value)
           
 void EhCache.put(Object key, Object value)
          Puts an object into the cache.
 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 ReadOnlyCache.put(Object key, Object value, long timestamp, Object version, Comparator versionComparator, boolean minimalPut)
           
 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 TransactionalCache.put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut)
           
 Object Cache.read(Object key)
          Get an item from the cache
 Object HashtableCache.read(Object key)
           
 Object OSCache.read(Object key)
           
 Object OptimisticTreeCache.read(Object key)
           
 Object SwarmCache.read(Object key)
           
 Object TreeCache.read(Object key)
           
 Object EhCache.read(Object key)
           
 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 TransactionalCache.release(Object key, CacheConcurrencyStrategy.SoftLock clientLock)
          Do nothing.
 void Cache.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 HashtableCache.remove(Object key)
           
 void NonstrictReadWriteCache.remove(Object key)
           
 void OSCache.remove(Object key)
           
 void OptimisticTreeCache.remove(Object key)
           
 void ReadOnlyCache.remove(Object key)
           
 void ReadWriteCache.remove(Object key)
           
 void SwarmCache.remove(Object key)
          Remove an item from the cache
 void TransactionalCache.remove(Object key)
           
 void TreeCache.remove(Object key)
           
 void EhCache.remove(Object key)
          Removes the element which matches the key.
 void AbstractJndiBoundCacheProvider.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 EhCacheProvider.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 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 SwarmCacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
 void Cache.unlock(Object key)
          If this is a clustered cache, unlock the item
 void HashtableCache.unlock(Object key)
           
 void OSCache.unlock(Object key)
           
 void OptimisticTreeCache.unlock(Object key)
           
 void SwarmCache.unlock(Object key)
          If this is a clustered cache, unlock the item
 void TreeCache.unlock(Object key)
           
 void EhCache.unlock(Object key)
          Calls to this method should perform there own synchronization.
 void Cache.update(Object key, Object value)
          Add an item to the cache
 void HashtableCache.update(Object key, Object value)
           
 void OSCache.update(Object key, Object value)
           
 void OptimisticTreeCache.update(Object key, Object value)
           
 void SwarmCache.update(Object key, Object value)
          Add an item to the cache
 void TreeCache.update(Object key, Object value)
           
 void EhCache.update(Object key, Object value)
          Puts an object into the cache.
 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)