## Uses of Class
org.hibernate.cache.CacheException

Packages that use CacheException
org.hibernate.action.internal
org.hibernate.cache: This package defines API of the Hibernate second level cache service.
org.hibernate.cache.ehcache
org.hibernate.cache.ehcache.internal.nonstop
org.hibernate.cache.ehcache.internal.regions
org.hibernate.cache.ehcache.internal.strategy
org.hibernate.cache.ehcache.internal.util
org.hibernate.cache.infinispan
org.hibernate.cache.infinispan.access
org.hibernate.cache.infinispan.collection
org.hibernate.cache.infinispan.entity
org.hibernate.cache.infinispan.impl
org.hibernate.cache.infinispan.naturalid
org.hibernate.cache.infinispan.query
org.hibernate.cache.infinispan.timestamp
org.hibernate.cache.infinispan.util
org.hibernate.cache.internal
org.hibernate.cache.spi: Defines the Hibernate second level caching SPI.
org.hibernate.cache.spi.access: Defines contracts for transactional and concurrent access to cached `entity` and `collection` data.
org.hibernate.ejb.internal
org.hibernate.envers.internal
org.hibernate.internal: An internal package containing mostly implementations of central Hibernate APIs.
org.hibernate.persister.collection: This package abstracts the persistence mechanism for collections.
org.hibernate.service.jdbc.connections.internal
org.hibernate.testing.cache

Uses of CacheException in org.hibernate.action.internal

Methods in org.hibernate.action.internal that throw CacheException
`void` `CollectionAction.beforeExecutions()`
`void` `EntityUpdateAction.doAfterTransactionCompletion(boolean success, SessionImplementor session)`
`protected void` `CollectionAction.evict()`

Constructors in org.hibernate.action.internal that throw CacheException
`CollectionRecreateAction(PersistentCollection collection, CollectionPersister persister, Serializable id, SessionImplementor session)`

Uses of CacheException in org.hibernate.cache

Subclasses of CacheException in org.hibernate.cache
`class` `NoCacheRegionFactoryAvailableException` Implementation of NoCacheRegionFactoryAvailableException.

Uses of CacheException in org.hibernate.cache.ehcache

Methods in org.hibernate.cache.ehcache with parameters of type CacheException
`void` `EhCacheMessageLogger_$logger.unableToReleaseCacheLock(CacheException arg0)`

Methods in org.hibernate.cache.ehcache that throw CacheException
`void` `SingletonEhCacheRegionFactory.start(Settings settings, Properties properties)` Lifecycle callback to perform any necessary initialization of the underlying cache implementation(s).
`void` `EhCacheRegionFactory.start(Settings settings, Properties properties)` Lifecycle callback to perform any necessary initialization of the underlying cache implementation(s).

Uses of CacheException in org.hibernate.cache.ehcache.internal.nonstop

Methods in org.hibernate.cache.ehcache.internal.nonstop that throw CacheException
`boolean` `NonstopAwareNaturalIdRegionAccessStrategy.afterInsert(Object key, Object value)`
`boolean` `NonstopAwareEntityRegionAccessStrategy.afterInsert(Object key, Object value, Object version)` Called after an item has been inserted (after the transaction completes), instead of calling release().
`boolean` `NonstopAwareEntityRegionAccessStrategy.afterUpdate(Object key, Object value, Object currentVersion, Object previousVersion, SoftLock lock)` Called after an item has been updated (after the transaction completes), instead of calling release().
`boolean` `NonstopAwareNaturalIdRegionAccessStrategy.afterUpdate(Object key, Object value, SoftLock lock)`
`void` `NonstopAwareEntityRegionAccessStrategy.evict(Object key)` Forcibly evict an item from the cache immediately without regard for transaction isolation.
`void` `NonstopAwareNaturalIdRegionAccessStrategy.evict(Object key)` Forcibly evict an item from the cache immediately without regard for transaction isolation.
`void` `NonstopAwareCollectionRegionAccessStrategy.evict(Object key)` Forcibly evict an item from the cache immediately without regard for transaction isolation.
`void` `NonstopAwareEntityRegionAccessStrategy.evictAll()` Forcibly evict all items from the cache immediately without regard for transaction isolation.
`void` `NonstopAwareNaturalIdRegionAccessStrategy.evictAll()` Forcibly evict all items from the cache immediately without regard for transaction isolation.
`void` `NonstopAwareCollectionRegionAccessStrategy.evictAll()` Forcibly evict all items from the cache immediately without regard for transaction isolation.
`Object` `NonstopAwareEntityRegionAccessStrategy.get(Object key, long txTimestamp)` Attempt to retrieve an object from the cache.
`Object` `NonstopAwareNaturalIdRegionAccessStrategy.get(Object key, long txTimestamp)` Attempt to retrieve an object from the cache.
`Object` `NonstopAwareCollectionRegionAccessStrategy.get(Object key, long txTimestamp)` Attempt to retrieve an object from the cache.
`boolean` `NonstopAwareNaturalIdRegionAccessStrategy.insert(Object key, Object value)`
`boolean` `NonstopAwareEntityRegionAccessStrategy.insert(Object key, Object value, Object version)` Called after an item has been inserted (before the transaction completes), instead of calling evict().
`SoftLock` `NonstopAwareEntityRegionAccessStrategy.lockItem(Object key, Object version)` We are going to attempt to update/delete the keyed object.
`SoftLock` `NonstopAwareNaturalIdRegionAccessStrategy.lockItem(Object key, Object version)` We are going to attempt to update/delete the keyed object.
`SoftLock` `NonstopAwareCollectionRegionAccessStrategy.lockItem(Object key, Object version)` We are going to attempt to update/delete the keyed object.
`SoftLock` `NonstopAwareEntityRegionAccessStrategy.lockRegion()` Lock the entire region
`SoftLock` `NonstopAwareNaturalIdRegionAccessStrategy.lockRegion()` Lock the entire region
`SoftLock` `NonstopAwareCollectionRegionAccessStrategy.lockRegion()` Lock the entire region
`boolean` `NonstopAwareEntityRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version)` Attempt to cache an object, after loading from the database.
`boolean` `NonstopAwareNaturalIdRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version)` Attempt to cache an object, after loading from the database.
`boolean` `NonstopAwareCollectionRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version)` Attempt to cache an object, after loading from the database.
`boolean` `NonstopAwareEntityRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)` Attempt to cache an object, after loading from the database, explicitly specifying the minimalPut behavior.
`boolean` `NonstopAwareNaturalIdRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)` Attempt to cache an object, after loading from the database, explicitly specifying the minimalPut behavior.
`boolean` `NonstopAwareCollectionRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)` Attempt to cache an object, after loading from the database, explicitly specifying the minimalPut behavior.
`void` `NonstopAwareEntityRegionAccessStrategy.remove(Object key)` Called after an item has become stale (before the transaction completes).
`void` `NonstopAwareNaturalIdRegionAccessStrategy.remove(Object key)` Called after an item has become stale (before the transaction completes).
`void` `NonstopAwareCollectionRegionAccessStrategy.remove(Object key)` Called after an item has become stale (before the transaction completes).
`void` `NonstopAwareEntityRegionAccessStrategy.removeAll()` Called to evict data from the entire region
`void` `NonstopAwareNaturalIdRegionAccessStrategy.removeAll()` Called to evict data from the entire region
`void` `NonstopAwareCollectionRegionAccessStrategy.removeAll()` Called to evict data from the entire region
`void` `NonstopAwareEntityRegionAccessStrategy.unlockItem(Object key, SoftLock lock)` Called when we have finished the attempted update/delete (which may or may not have been successful), after transaction completion.
`void` `NonstopAwareNaturalIdRegionAccessStrategy.unlockItem(Object key, SoftLock lock)` Called when we have finished the attempted update/delete (which may or may not have been successful), after transaction completion.
`void` `NonstopAwareCollectionRegionAccessStrategy.unlockItem(Object key, SoftLock lock)` Called when we have finished the attempted update/delete (which may or may not have been successful), after transaction completion.
`void` `NonstopAwareEntityRegionAccessStrategy.unlockRegion(SoftLock lock)` Called after we have finished the attempted invalidation of the entire region
`void` `NonstopAwareNaturalIdRegionAccessStrategy.unlockRegion(SoftLock lock)` Called after we have finished the attempted invalidation of the entire region
`void` `NonstopAwareCollectionRegionAccessStrategy.unlockRegion(SoftLock lock)` Called after we have finished the attempted invalidation of the entire region
`boolean` `NonstopAwareNaturalIdRegionAccessStrategy.update(Object key, Object value)`
`boolean` `NonstopAwareEntityRegionAccessStrategy.update(Object key, Object value, Object currentVersion, Object previousVersion)` Called after an item has been updated (before the transaction completes), instead of calling evict().

Uses of CacheException in org.hibernate.cache.ehcache.internal.regions

Methods in org.hibernate.cache.ehcache.internal.regions that throw CacheException
`NaturalIdRegionAccessStrategy` `EhcacheNaturalIdRegion.buildAccessStrategy(AccessType accessType)`
`EntityRegionAccessStrategy` `EhcacheEntityRegion.buildAccessStrategy(AccessType accessType)` Build an access strategy for the requested access type.
`CollectionRegionAccessStrategy` `EhcacheCollectionRegion.buildAccessStrategy(AccessType accessType)` Build an access strategy for the requested access type.
`void` `EhcacheTransactionalDataRegion.clear()` Remove all mapping from this cache region.
`void` `EhcacheDataRegion.destroy()` The "end state" contract of the region's lifecycle.
`void` `EhcacheTransactionalDataRegion.put(Object key, Object value)` Map the given value to the given key, replacing any existing mapping for this key
`void` `EhcacheTransactionalDataRegion.remove(Object key)` Remove the mapping for this key (if any exists).

Uses of CacheException in org.hibernate.cache.ehcache.internal.strategy

Methods in org.hibernate.cache.ehcache.internal.strategy that throw CacheException
`boolean` `ReadWriteEhcacheNaturalIdRegionAccessStrategy.afterInsert(Object key, Object value)` Called after an item has been inserted (after the transaction completes), instead of calling release().
`boolean` `ReadOnlyEhcacheNaturalIdRegionAccessStrategy.afterInsert(Object key, Object value)` Called after an item has been inserted (after the transaction completes), instead of calling release().
`boolean` `NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategy.afterInsert(Object key, Object value)` Returns `false` since this is a non-strict read/write cache access strategy
`boolean` `ReadOnlyEhcacheEntityRegionAccessStrategy.afterInsert(Object key, Object value, Object version)` Called after an item has been inserted (after the transaction completes), instead of calling release().
`boolean` `ReadWriteEhcacheEntityRegionAccessStrategy.afterInsert(Object key, Object value, Object version)` Called after an item has been inserted (after the transaction completes), instead of calling release().
`boolean` `NonStrictReadWriteEhcacheEntityRegionAccessStrategy.afterInsert(Object key, Object value, Object version)` Returns `false` since this is a non-strict read/write cache access strategy
`boolean` `ReadWriteEhcacheEntityRegionAccessStrategy.afterUpdate(Object key, Object value, Object currentVersion, Object previousVersion, SoftLock lock)` Called after an item has been updated (after the transaction completes), instead of calling release().
`boolean` `NonStrictReadWriteEhcacheEntityRegionAccessStrategy.afterUpdate(Object key, Object value, Object currentVersion, Object previousVersion, SoftLock lock)` Called after an item has been updated (after the transaction completes), instead of calling release().
`boolean` `ReadWriteEhcacheNaturalIdRegionAccessStrategy.afterUpdate(Object key, Object value, SoftLock lock)` Called after an item has been updated (after the transaction completes), instead of calling release().
`boolean` `NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategy.afterUpdate(Object key, Object value, SoftLock lock)` Called after an item has been updated (after the transaction completes), instead of calling release().
`Object` `ReadOnlyEhcacheEntityRegionAccessStrategy.get(Object key, long txTimestamp)` Attempt to retrieve an object from the cache.
`Object` `TransactionalEhcacheEntityRegionAccessStrategy.get(Object key, long txTimestamp)` Attempt to retrieve an object from the cache.
`Object` `TransactionalEhcacheNaturalIdRegionAccessStrategy.get(Object key, long txTimestamp)` Attempt to retrieve an object from the cache.
`Object` `NonStrictReadWriteEhcacheCollectionRegionAccessStrategy.get(Object key, long txTimestamp)` Attempt to retrieve an object from the cache.
`Object` `ReadOnlyEhcacheCollectionRegionAccessStrategy.get(Object key, long txTimestamp)` Attempt to retrieve an object from the cache.
`Object` `TransactionalEhcacheCollectionRegionAccessStrategy.get(Object key, long txTimestamp)` Attempt to retrieve an object from the cache.
`Object` `NonStrictReadWriteEhcacheEntityRegionAccessStrategy.get(Object key, long txTimestamp)` Attempt to retrieve an object from the cache.
`Object` `ReadOnlyEhcacheNaturalIdRegionAccessStrategy.get(Object key, long txTimestamp)` Attempt to retrieve an object from the cache.
`Object` `NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategy.get(Object key, long txTimestamp)` Attempt to retrieve an object from the cache.
`boolean` `TransactionalEhcacheNaturalIdRegionAccessStrategy.insert(Object key, Object value)` Called after an item has been inserted (before the transaction completes), instead of calling evict().
`boolean` `ReadWriteEhcacheNaturalIdRegionAccessStrategy.insert(Object key, Object value)` A no-op since this is an asynchronous cache access strategy.
`boolean` `ReadOnlyEhcacheNaturalIdRegionAccessStrategy.insert(Object key, Object value)` This cache is asynchronous hence a no-op
`boolean` `NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategy.insert(Object key, Object value)` Returns `false` since this is an asynchronous cache access strategy.
`boolean` `ReadOnlyEhcacheEntityRegionAccessStrategy.insert(Object key, Object value, Object version)` This cache is asynchronous hence a no-op
`boolean` `TransactionalEhcacheEntityRegionAccessStrategy.insert(Object key, Object value, Object version)` Called after an item has been inserted (before the transaction completes), instead of calling evict().
`boolean` `ReadWriteEhcacheEntityRegionAccessStrategy.insert(Object key, Object value, Object version)` A no-op since this is an asynchronous cache access strategy.
`boolean` `NonStrictReadWriteEhcacheEntityRegionAccessStrategy.insert(Object key, Object value, Object version)` Returns `false` since this is an asynchronous cache access strategy.
`SoftLock` `TransactionalEhcacheEntityRegionAccessStrategy.lockItem(Object key, Object version)` We are going to attempt to update/delete the keyed object.
`SoftLock` `TransactionalEhcacheNaturalIdRegionAccessStrategy.lockItem(Object key, Object version)` We are going to attempt to update/delete the keyed object.
`SoftLock` `NonStrictReadWriteEhcacheCollectionRegionAccessStrategy.lockItem(Object key, Object version)` Since this is a non-strict read/write strategy item locking is not used.
`SoftLock` `TransactionalEhcacheCollectionRegionAccessStrategy.lockItem(Object key, Object version)` We are going to attempt to update/delete the keyed object.
`SoftLock` `NonStrictReadWriteEhcacheEntityRegionAccessStrategy.lockItem(Object key, Object version)` Since this is a non-strict read/write strategy item locking is not used.
`SoftLock` `NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategy.lockItem(Object key, Object version)` Since this is a non-strict read/write strategy item locking is not used.
`boolean` `ReadOnlyEhcacheEntityRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)` This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.
`boolean` `TransactionalEhcacheEntityRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)` This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.
`boolean` `TransactionalEhcacheNaturalIdRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)` This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.
`boolean` `NonStrictReadWriteEhcacheCollectionRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)` This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.
`boolean` `ReadOnlyEhcacheCollectionRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)` This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.
`boolean` `TransactionalEhcacheCollectionRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)` This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.
`boolean` `NonStrictReadWriteEhcacheEntityRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)` This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.
`boolean` `ReadOnlyEhcacheNaturalIdRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)` This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.
`boolean` `NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)` This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.
`void` `TransactionalEhcacheEntityRegionAccessStrategy.remove(Object key)` A no-op since this is an asynchronous cache access strategy.
`void` `TransactionalEhcacheNaturalIdRegionAccessStrategy.remove(Object key)` A no-op since this is an asynchronous cache access strategy.
`void` `NonStrictReadWriteEhcacheCollectionRegionAccessStrategy.remove(Object key)` A no-op since this is an asynchronous cache access strategy.
`void` `TransactionalEhcacheCollectionRegionAccessStrategy.remove(Object key)` A no-op since this is an asynchronous cache access strategy.
`void` `NonStrictReadWriteEhcacheEntityRegionAccessStrategy.remove(Object key)` A no-op since this is an asynchronous cache access strategy.
`void` `NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategy.remove(Object key)` A no-op since this is an asynchronous cache access strategy.
`void` `ReadOnlyEhcacheEntityRegionAccessStrategy.unlockItem(Object key, SoftLock lock)` A no-op since this cache is read-only
`void` `TransactionalEhcacheEntityRegionAccessStrategy.unlockItem(Object key, SoftLock lock)` Called when we have finished the attempted update/delete (which may or may not have been successful), after transaction completion.
`void` `TransactionalEhcacheNaturalIdRegionAccessStrategy.unlockItem(Object key, SoftLock lock)` Called when we have finished the attempted update/delete (which may or may not have been successful), after transaction completion.
`void` `NonStrictReadWriteEhcacheCollectionRegionAccessStrategy.unlockItem(Object key, SoftLock lock)` Since this is a non-strict read/write strategy item locking is not used.
`void` `ReadOnlyEhcacheCollectionRegionAccessStrategy.unlockItem(Object key, SoftLock lock)` A no-op since this cache is read-only
`void` `TransactionalEhcacheCollectionRegionAccessStrategy.unlockItem(Object key, SoftLock lock)` Called when we have finished the attempted update/delete (which may or may not have been successful), after transaction completion.
`void` `NonStrictReadWriteEhcacheEntityRegionAccessStrategy.unlockItem(Object key, SoftLock lock)` Since this is a non-strict read/write strategy item locking is not used.
`void` `ReadOnlyEhcacheNaturalIdRegionAccessStrategy.unlockItem(Object key, SoftLock lock)` A no-op since this cache is read-only
`void` `NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategy.unlockItem(Object key, SoftLock lock)` Since this is a non-strict read/write strategy item locking is not used.
`boolean` `TransactionalEhcacheNaturalIdRegionAccessStrategy.update(Object key, Object value)` Called after an item has been updated (before the transaction completes), instead of calling evict().
`boolean` `ReadWriteEhcacheNaturalIdRegionAccessStrategy.update(Object key, Object value)` A no-op since this is an asynchronous cache access strategy.
`boolean` `NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategy.update(Object key, Object value)` Removes the entry since this is a non-strict read/write cache strategy.
`boolean` `TransactionalEhcacheEntityRegionAccessStrategy.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` `ReadWriteEhcacheEntityRegionAccessStrategy.update(Object key, Object value, Object currentVersion, Object previousVersion)` A no-op since this is an asynchronous cache access strategy.
`boolean` `NonStrictReadWriteEhcacheEntityRegionAccessStrategy.update(Object key, Object value, Object currentVersion, Object previousVersion)` Removes the entry since this is a non-strict read/write cache strategy.

Uses of CacheException in org.hibernate.cache.ehcache.internal.util

Methods in org.hibernate.cache.ehcache.internal.util that throw CacheException
`static void` `HibernateUtil.validateEhcache(net.sf.ehcache.Ehcache cache)` Validates that the supplied Ehcache instance is valid for use as a Hibernate cache.

Uses of CacheException in org.hibernate.cache.infinispan

Methods in org.hibernate.cache.infinispan that throw CacheException
`CollectionRegion` `InfinispanRegionFactory.buildCollectionRegion(String regionName, Properties properties, CacheDataDescription metadata)` Build a cache region specialized for storing collection data.
`EntityRegion` `InfinispanRegionFactory.buildEntityRegion(String regionName, Properties properties, CacheDataDescription metadata)` Build a cache region specialized for storing entity data.
`NaturalIdRegion` `InfinispanRegionFactory.buildNaturalIdRegion(String regionName, Properties properties, CacheDataDescription metadata)`
`QueryResultsRegion` `InfinispanRegionFactory.buildQueryResultsRegion(String regionName, Properties properties)` Build a cache region specialized for storing query results
`TimestampsRegion` `InfinispanRegionFactory.buildTimestampsRegion(String regionName, Properties properties)` Build a cache region specialized for storing update-timestamps data.
`protected org.infinispan.manager.EmbeddedCacheManager` `JndiInfinispanRegionFactory.createCacheManager(Properties properties)`
`protected org.infinispan.manager.EmbeddedCacheManager` `InfinispanRegionFactory.createCacheManager(Properties properties)`
`void` `InfinispanRegionFactory.start(Settings settings, Properties properties)` Lifecycle callback to perform any necessary initialization of the underlying cache implementation(s).
`void` `TypeOverrides.validateInfinispanConfiguration(org.infinispan.config.Configuration configuration)`

Uses of CacheException in org.hibernate.cache.infinispan.access

Methods in org.hibernate.cache.infinispan.access that throw CacheException
`boolean` `TransactionalAccessDelegate.afterInsert(Object key, Object value, Object version)`
`boolean` `TransactionalAccessDelegate.afterUpdate(Object key, Object value, Object currentVersion, Object previousVersion, SoftLock lock)`
`void` `TransactionalAccessDelegate.evict(Object key)`
`void` `TransactionalAccessDelegate.evictAll()`
`Object` `TransactionalAccessDelegate.get(Object key, long txTimestamp)`
`boolean` `TransactionalAccessDelegate.insert(Object key, Object value, Object version)`
`SoftLock` `TransactionalAccessDelegate.lockItem(Object key, Object version)`
`SoftLock` `TransactionalAccessDelegate.lockRegion()`
`boolean` `TransactionalAccessDelegate.putFromLoad(Object key, Object value, long txTimestamp, Object version)`
`boolean` `TransactionalAccessDelegate.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)`
`void` `TransactionalAccessDelegate.remove(Object key)`
`void` `TransactionalAccessDelegate.removeAll()`
`void` `TransactionalAccessDelegate.unlockItem(Object key, SoftLock lock)`
`void` `TransactionalAccessDelegate.unlockRegion(SoftLock lock)`
`boolean` `TransactionalAccessDelegate.update(Object key, Object value, Object currentVersion, Object previousVersion)`

Uses of CacheException in org.hibernate.cache.infinispan.collection

Methods in org.hibernate.cache.infinispan.collection that throw CacheException
`CollectionRegionAccessStrategy` `CollectionRegionImpl.buildAccessStrategy(AccessType accessType)`

Uses of CacheException in org.hibernate.cache.infinispan.entity

Methods in org.hibernate.cache.infinispan.entity that throw CacheException
`EntityRegionAccessStrategy` `EntityRegionImpl.buildAccessStrategy(AccessType accessType)`

Uses of CacheException in org.hibernate.cache.infinispan.impl

Methods in org.hibernate.cache.infinispan.impl that throw CacheException
`void` `BaseRegion.destroy()`
`void` `BaseGeneralDataRegion.evict(Object key)`
`void` `BaseGeneralDataRegion.evictAll()`
`Object` `BaseGeneralDataRegion.get(Object key)`
`protected Object` `BaseRegion.get(Object key, boolean suppressTimeout, FlagAdapter... flagAdapters)` Performs a Infinispan `get(Fqn, Object)`
`void` `BaseGeneralDataRegion.put(Object key, Object value)`

Uses of CacheException in org.hibernate.cache.infinispan.naturalid

Methods in org.hibernate.cache.infinispan.naturalid that throw CacheException
`NaturalIdRegionAccessStrategy` `NaturalIdRegionImpl.buildAccessStrategy(AccessType accessType)`

Uses of CacheException in org.hibernate.cache.infinispan.query

Methods in org.hibernate.cache.infinispan.query that throw CacheException
`void` `QueryResultsRegionImpl.evict(Object key)`
`void` `QueryResultsRegionImpl.evictAll()`
`Object` `QueryResultsRegionImpl.get(Object key)`
`void` `QueryResultsRegionImpl.put(Object key, Object value)`

Uses of CacheException in org.hibernate.cache.infinispan.timestamp

Methods in org.hibernate.cache.infinispan.timestamp that throw CacheException
`void` `TimestampsRegionImpl.destroy()`
`void` `TimestampsRegionImpl.evict(Object key)`
`void` `TimestampsRegionImpl.evictAll()`
`Object` `TimestampsRegionImpl.get(Object key)`
`void` `TimestampsRegionImpl.put(Object key, Object value)`
`void` `TimestampTypeOverrides.validateInfinispanConfiguration(org.infinispan.config.Configuration configuration)`

Uses of CacheException in org.hibernate.cache.infinispan.util

Methods in org.hibernate.cache.infinispan.util that throw CacheException
`void` `CacheAdapter.clear()` Clear the cache.
`void` `CacheAdapterImpl.clear()`
`void` `CacheAdapter.evict(Object key)` Evict the given key from memory.
`void` `CacheAdapterImpl.evict(Object key)`
`Object` `CacheAdapter.get(Object key)` Performs an `get(Object)` on the cache, wrapping any exception in a `CacheException`.
`Object` `CacheAdapterImpl.get(Object key)`
`Object` `CacheAdapter.getAllowingTimeout(Object key)` Performs an `get(Object)` on the cache ignoring any `TimeoutException` and wrapping any other exception in a `CacheException`.
`Object` `CacheAdapterImpl.getAllowingTimeout(Object key)`
`void` `CacheAdapter.put(Object key, Object value)` Performs a `put(Object, Object)` on the cache, wrapping any exception in a `CacheException`.
`void` `CacheAdapterImpl.put(Object key, Object value)`
`void` `CacheAdapter.putAllowingTimeout(Object key, Object value)` Performs a `put(Object, Object)` on the cache ignoring any `TimeoutException` and wrapping any exception in a `CacheException`.
`void` `CacheAdapterImpl.putAllowingTimeout(Object key, Object value)`
`void` `CacheAdapter.putForExternalRead(Object key, Object value)` See `Cache.putForExternalRead(Object, Object)` for detailed documentation.
`void` `CacheAdapterImpl.putForExternalRead(Object key, Object value)`
`void` `CacheAdapter.remove(Object key)` Performs a `remove(Object)`, wrapping any exception in a `CacheException`.
`void` `CacheAdapterImpl.remove(Object key)`

Uses of CacheException in org.hibernate.cache.internal

Methods in org.hibernate.cache.internal that throw CacheException
`CollectionRegion` `NoCachingRegionFactory.buildCollectionRegion(String regionName, Properties properties, CacheDataDescription metadata)`
`EntityRegion` `NoCachingRegionFactory.buildEntityRegion(String regionName, Properties properties, CacheDataDescription metadata)`
`NaturalIdRegion` `NoCachingRegionFactory.buildNaturalIdRegion(String regionName, Properties properties, CacheDataDescription metadata)`
`QueryResultsRegion` `NoCachingRegionFactory.buildQueryResultsRegion(String regionName, Properties properties)`
`TimestampsRegion` `NoCachingRegionFactory.buildTimestampsRegion(String regionName, Properties properties)`
`void` `StandardQueryCache.clear()`
`void` `NoCachingRegionFactory.start(Settings settings, Properties properties)`

Uses of CacheException in org.hibernate.cache.spi

Methods in org.hibernate.cache.spi that throw CacheException
`NaturalIdRegionAccessStrategy` `NaturalIdRegion.buildAccessStrategy(AccessType accessType)` Build an access strategy for the requested access type.
`CollectionRegionAccessStrategy` `CollectionRegion.buildAccessStrategy(AccessType accessType)` Build an access strategy for the requested access type.
`EntityRegionAccessStrategy` `EntityRegion.buildAccessStrategy(AccessType accessType)` Build an access strategy for the requested access type.
`CollectionRegion` `RegionFactory.buildCollectionRegion(String regionName, Properties properties, CacheDataDescription metadata)` Build a cache region specialized for storing collection data.
`EntityRegion` `RegionFactory.buildEntityRegion(String regionName, Properties properties, CacheDataDescription metadata)` Build a cache region specialized for storing entity data.
`NaturalIdRegion` `RegionFactory.buildNaturalIdRegion(String regionName, Properties properties, CacheDataDescription metadata)` Build a cache region specialized for storing NaturalId to Primary Key mappings.
`QueryResultsRegion` `RegionFactory.buildQueryResultsRegion(String regionName, Properties properties)` Build a cache region specialized for storing query results
`TimestampsRegion` `RegionFactory.buildTimestampsRegion(String regionName, Properties properties)` Build a cache region specialized for storing update-timestamps data.
`void` `QueryCache.clear()`
`void` `UpdateTimestampsCache.clear()`
`void` `Region.destroy()` The "end state" contract of the region's lifecycle.
`void` `GeneralDataRegion.evict(Object key)` Evict an item from the cache immediately (without regard for transaction isolation).
`void` `GeneralDataRegion.evictAll()` Evict all contents of this particular cache region (without regard for transaction isolation).
`Object` `GeneralDataRegion.get(Object key)` Get an item from the cache.
`void` `UpdateTimestampsCache.invalidate(Serializable[] spaces)`
`void` `UpdateTimestampsCache.preinvalidate(Serializable[] spaces)`
`void` `GeneralDataRegion.put(Object key, Object value)` Put an item into the cache.
`void` `RegionFactory.start(Settings settings, Properties properties)` Lifecycle callback to perform any necessary initialization of the underlying cache implementation(s).

Uses of CacheException in org.hibernate.cache.spi.access

Methods in org.hibernate.cache.spi.access that throw CacheException
`boolean` `NaturalIdRegionAccessStrategy.afterInsert(Object key, Object value)` Called after an item has been inserted (after the transaction completes), instead of calling release().
`boolean` `EntityRegionAccessStrategy.afterInsert(Object key, Object value, Object version)` Called after an item has been inserted (after the transaction completes), instead of calling release().
`boolean` `EntityRegionAccessStrategy.afterUpdate(Object key, Object value, Object currentVersion, Object previousVersion, SoftLock lock)` Called after an item has been updated (after the transaction completes), instead of calling release().
`boolean` `NaturalIdRegionAccessStrategy.afterUpdate(Object key, Object value, SoftLock lock)` Called after an item has been updated (after the transaction completes), instead of calling release().
`void` `RegionAccessStrategy.evict(Object key)` Forcibly evict an item from the cache immediately without regard for transaction isolation.
`void` `RegionAccessStrategy.evictAll()` Forcibly evict all items from the cache immediately without regard for transaction isolation.
`Object` `RegionAccessStrategy.get(Object key, long txTimestamp)` Attempt to retrieve an object from the cache.
`boolean` `NaturalIdRegionAccessStrategy.insert(Object key, Object value)` Called after an item has been inserted (before the transaction completes), instead of calling evict().
`boolean` `EntityRegionAccessStrategy.insert(Object key, Object value, Object version)` Called after an item has been inserted (before the transaction completes), instead of calling evict().
`SoftLock` `RegionAccessStrategy.lockItem(Object key, Object version)` We are going to attempt to update/delete the keyed object.
`SoftLock` `RegionAccessStrategy.lockRegion()` Lock the entire region
`boolean` `RegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version)` Attempt to cache an object, after loading from the database.
`boolean` `RegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)` Attempt to cache an object, after loading from the database, explicitly specifying the minimalPut behavior.
`void` `RegionAccessStrategy.remove(Object key)` Called after an item has become stale (before the transaction completes).
`void` `RegionAccessStrategy.removeAll()` Called to evict data from the entire region
`void` `RegionAccessStrategy.unlockItem(Object key, SoftLock lock)` Called when we have finished the attempted update/delete (which may or may not have been successful), after transaction completion.
`void` `RegionAccessStrategy.unlockRegion(SoftLock lock)` Called after we have finished the attempted invalidation of the entire region
`boolean` `NaturalIdRegionAccessStrategy.update(Object key, Object value)` Called after an item has been updated (before the transaction completes), instead of calling evict().
`boolean` `EntityRegionAccessStrategy.update(Object key, Object value, Object currentVersion, Object previousVersion)` Called after an item has been updated (before the transaction completes), instead of calling evict().

Uses of CacheException in org.hibernate.ejb.internal

Methods in org.hibernate.ejb.internal with parameters of type CacheException
`void` `EntityManagerMessageLogger_$logger.unableToReleaseCacheLock(CacheException arg0)`

Uses of CacheException in org.hibernate.envers.internal

Methods in org.hibernate.envers.internal with parameters of type CacheException
`void` `EnversMessageLogger_$logger.unableToReleaseCacheLock(CacheException arg0)`

Uses of CacheException in org.hibernate.internal

Methods in org.hibernate.internal with parameters of type CacheException
`void` `CoreMessageLogger.unableToReleaseCacheLock(CacheException ce)`
`void` `CoreMessageLogger_$logger.unableToReleaseCacheLock(CacheException ce)`

Uses of CacheException in org.hibernate.persister.collection

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

Uses of CacheException in org.hibernate.service.jdbc.connections.internal

Methods in org.hibernate.service.jdbc.connections.internal with parameters of type CacheException
`void` `C3P0MessageLogger_$logger.unableToReleaseCacheLock(CacheException arg0)`
`void` `ProxoolMessageLogger_$logger.unableToReleaseCacheLock(CacheException arg0)`

Uses of CacheException in org.hibernate.testing.cache

Methods in org.hibernate.testing.cache that throw CacheException
`CollectionRegion` `CachingRegionFactory.buildCollectionRegion(String regionName, Properties properties, CacheDataDescription metadata)`
`EntityRegion` `CachingRegionFactory.buildEntityRegion(String regionName, Properties properties, CacheDataDescription metadata)`
`NaturalIdRegion` `CachingRegionFactory.buildNaturalIdRegion(String regionName, Properties properties, CacheDataDescription metadata)`
`QueryResultsRegion` `CachingRegionFactory.buildQueryResultsRegion(String regionName, Properties properties)`
`TimestampsRegion` `CachingRegionFactory.buildTimestampsRegion(String regionName, Properties properties)`
`void` `CachingRegionFactory.start(Settings settings, Properties properties)`

Copyright © 2001-2012 Red Hat, Inc. All Rights Reserved.