## org.hibernate.cache.ehcache.internal.nonstop
Class NonstopAwareNaturalIdRegionAccessStrategy

    java.lang.Object
      org.hibernate.cache.ehcache.internal.nonstop.NonstopAwareNaturalIdRegionAccessStrategy

All Implemented Interfaces:
  NaturalIdRegionAccessStrategy, RegionAccessStrategy

    public class NonstopAwareNaturalIdRegionAccessStrategy

extends Object
implements NaturalIdRegionAccessStrategy

Implementation of `NaturalIdRegionAccessStrategy` that handles `NonStopCacheException` using `HibernateNonstopCacheExceptionHandler`

Constructor Summary
`NonstopAwareNaturalIdRegionAccessStrategy(NaturalIdRegionAccessStrategy actualStrategy, HibernateNonstopCacheExceptionHandler hibernateNonstopExceptionHandler)` Constructor accepting the actual `NaturalIdRegionAccessStrategy` and the `HibernateNonstopCacheExceptionHandler`

Method Summary
`boolean` `afterInsert(Object key, Object value)` Called after an item has been inserted (after the transaction completes), instead of calling release().
`boolean` `afterUpdate(Object key, Object value, SoftLock lock)` Called after an item has been updated (after the transaction completes), instead of calling release().
`void` `evict(Object key)` Forcibly evict an item from the cache immediately without regard for transaction isolation.
`void` `evictAll()` Forcibly evict all items from the cache immediately without regard for transaction isolation.
`Object` `get(Object key, long txTimestamp)` Attempt to retrieve an object from the cache.
`NaturalIdRegion` `getRegion()` Get the wrapped naturalId cache region
`boolean` `insert(Object key, Object value)` Called after an item has been inserted (before the transaction completes), instead of calling evict().
`SoftLock` `lockItem(Object key, Object version)` We are going to attempt to update/delete the keyed object.
`SoftLock` `lockRegion()` Lock the entire region
`boolean` `putFromLoad(Object key, Object value, long txTimestamp, Object version)` Attempt to cache an object, after loading from the database.
`boolean` `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` `remove(Object key)` Called after an item has become stale (before the transaction completes).
`void` `removeAll()` Called to evict data from the entire region
`void` `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` `unlockRegion(SoftLock lock)` Called after we have finished the attempted invalidation of the entire region
`boolean` `update(Object key, Object value)` Called after an item has been updated (before the transaction completes), instead of calling evict().

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### NonstopAwareNaturalIdRegionAccessStrategy

    public NonstopAwareNaturalIdRegionAccessStrategy(NaturalIdRegionAccessStrategy actualStrategy,
                                                     HibernateNonstopCacheExceptionHandler hibernateNonstopExceptionHandler)

  Constructor accepting the actual `NaturalIdRegionAccessStrategy` and the `HibernateNonstopCacheExceptionHandler`

  Parameters:
    `actualStrategy` -
    `hibernateNonstopExceptionHandler` -

Method Detail

### insert

    public boolean insert(Object key,
                          Object value)
                   throws CacheException

  Description copied from interface: `NaturalIdRegionAccessStrategy`
  Called after an item has been inserted (before the transaction completes), instead of calling evict(). This method is used by "synchronous" concurrency strategies.

  Specified by:
    `insert` in interface `NaturalIdRegionAccessStrategy`
  Parameters:
    `key` - The item key
    `value` - The item
  Returns:
    Were the contents of the cache actual changed by this operation?
  Throws:
    `CacheException` - Propogated from underlying `Region`

### afterInsert

    public boolean afterInsert(Object key,
                               Object value)
                        throws CacheException

  Description copied from interface: `NaturalIdRegionAccessStrategy`
  Called after an item has been inserted (after the transaction completes), instead of calling release(). This method is used by "asynchronous" concurrency strategies.

  Specified by:
    `afterInsert` in interface `NaturalIdRegionAccessStrategy`
  Parameters:
    `key` - The item key
    `value` - The item
  Returns:
    Were the contents of the cache actual changed by this operation?
  Throws:
    `CacheException` - Propogated from underlying `Region`

### update

    public boolean update(Object key,
                          Object value)
                   throws CacheException

  Description copied from interface: `NaturalIdRegionAccessStrategy`
  Called after an item has been updated (before the transaction completes), instead of calling evict(). This method is used by "synchronous" concurrency strategies.

  Specified by:
    `update` in interface `NaturalIdRegionAccessStrategy`
  Parameters:
    `key` - The item key
    `value` - The item
  Returns:
    Were the contents of the cache actual changed by this operation?
  Throws:
    `CacheException` - Propogated from underlying `Region`

### afterUpdate

    public boolean afterUpdate(Object key,
                               Object value,
                               SoftLock lock)
                        throws CacheException

  Description copied from interface: `NaturalIdRegionAccessStrategy`
  Called after an item has been updated (after the transaction completes), instead of calling release(). This method is used by "asynchronous" concurrency strategies.

  Specified by:
    `afterUpdate` in interface `NaturalIdRegionAccessStrategy`
  Parameters:
    `key` - The item key
    `value` - The item
    `lock` - The lock previously obtained from `RegionAccessStrategy.lockItem(java.lang.Object, java.lang.Object)`
  Returns:
    Were the contents of the cache actual changed by this operation?
  Throws:
    `CacheException` - Propogated from underlying `Region`

### getRegion

    public NaturalIdRegion getRegion()

  Get the wrapped naturalId cache region

  Specified by:
    `getRegion` in interface `NaturalIdRegionAccessStrategy`
  Returns:
    The underlying region
  See Also:
    `EntityRegionAccessStrategy.getRegion()`

### evict

    public void evict(Object key)
               throws CacheException

  Forcibly evict an item from the cache immediately without regard for transaction isolation.

  Specified by:
    `evict` in interface `RegionAccessStrategy`
  Parameters:
    `key` - The key of the item to remove
  Throws:
    `CacheException` - Propogated from underlying `Region`
  See Also:
    `RegionAccessStrategy.evict(java.lang.Object)`

### evictAll

    public void evictAll()
                  throws CacheException

  Forcibly evict all items from the cache immediately without regard for transaction isolation.

  Specified by:
    `evictAll` in interface `RegionAccessStrategy`
  Throws:
    `CacheException` - Propogated from underlying `Region`
  See Also:
    `RegionAccessStrategy.evictAll()`

### get

    public Object get(Object key,
                      long txTimestamp)
               throws CacheException

  Attempt to retrieve an object from the cache. Mainly used in attempting to resolve entities/collections from the second level cache.

  Specified by:
    `get` in interface `RegionAccessStrategy`
  Parameters:
    `key` - The key of the item to be retrieved.
    `txTimestamp` - a timestamp prior to the transaction start time
  Returns:
    the cached object or `null`
  Throws:
    `CacheException` - Propogated from underlying `Region`
  See Also:
    `RegionAccessStrategy.get(java.lang.Object, long)`

### lockItem

    public SoftLock lockItem(Object key,
                             Object version)
                      throws CacheException

  We are going to attempt to update/delete the keyed object. This method is used by "asynchronous" concurrency strategies.

  The returned object must be passed back to `RegionAccessStrategy.unlockItem(java.lang.Object, org.hibernate.cache.spi.access.SoftLock)`, to release the lock. Concurrency strategies which do not support client-visible locks may silently return null.

  Specified by:
    `lockItem` in interface `RegionAccessStrategy`
  Parameters:
    `key` - The key of the item to lock
    `version` - The item's current version value
  Returns:
    A representation of our lock on the item; or null.
  Throws:
    `CacheException` - Propogated from underlying `Region`
  See Also:
    `RegionAccessStrategy.lockItem(java.lang.Object, java.lang.Object)`

### lockRegion

    public SoftLock lockRegion()
                        throws CacheException

  Lock the entire region

  Specified by:
    `lockRegion` in interface `RegionAccessStrategy`
  Returns:
    A representation of our lock on the item; or null.
  Throws:
    `CacheException` - Propogated from underlying `Region`
  See Also:
    `RegionAccessStrategy.lockRegion()`

### putFromLoad

    public boolean putFromLoad(Object key,
                               Object value,
                               long txTimestamp,
                               Object version,
                               boolean minimalPutOverride)
                        throws CacheException

  Attempt to cache an object, after loading from the database, explicitly specifying the minimalPut behavior.

  Specified by:
    `putFromLoad` in interface `RegionAccessStrategy`
  Parameters:
    `key` - The item key
    `value` - The item
    `txTimestamp` - a timestamp prior to the transaction start time
    `version` - the item version number
    `minimalPutOverride` - Explicit minimalPut flag
  Returns:
    `true` if the object was successfully cached
  Throws:
    `CacheException` - Propogated from underlying `Region`
  See Also:
    `RegionAccessStrategy.putFromLoad(java.lang.Object, java.lang.Object, long, java.lang.Object, boolean)`

### putFromLoad

    public boolean putFromLoad(Object key,
                               Object value,
                               long txTimestamp,
                               Object version)
                        throws CacheException

  Attempt to cache an object, after loading from the database.

  Specified by:
    `putFromLoad` in interface `RegionAccessStrategy`
  Parameters:
    `key` - The item key
    `value` - The item
    `txTimestamp` - a timestamp prior to the transaction start time
    `version` - the item version number
  Returns:
    `true` if the object was successfully cached
  Throws:
    `CacheException` - Propogated from underlying `Region`
  See Also:
    `RegionAccessStrategy.putFromLoad(java.lang.Object, java.lang.Object, long, java.lang.Object)`

### remove

    public void remove(Object key)
                throws CacheException

  Called after an item has become stale (before the transaction completes). This method is used by "synchronous" concurrency strategies.

  Specified by:
    `remove` in interface `RegionAccessStrategy`
  Parameters:
    `key` - The key of the item to remove
  Throws:
    `CacheException` - Propogated from underlying `Region`
  See Also:
    `RegionAccessStrategy.remove(java.lang.Object)`

### removeAll

    public void removeAll()
                   throws CacheException

  Called to evict data from the entire region

  Specified by:
    `removeAll` in interface `RegionAccessStrategy`
  Throws:
    `CacheException` - Propogated from underlying `Region`
  See Also:
    `RegionAccessStrategy.removeAll()`

### unlockItem

    public void unlockItem(Object key,
                           SoftLock lock)
                    throws CacheException

  Called when we have finished the attempted update/delete (which may or may not have been successful), after transaction completion. This method is used by "asynchronous" concurrency strategies.

  Specified by:
    `unlockItem` in interface `RegionAccessStrategy`
  Parameters:
    `key` - The item key
    `lock` - The lock previously obtained from `RegionAccessStrategy.lockItem(java.lang.Object, java.lang.Object)`
  Throws:
    `CacheException` - Propogated from underlying `Region`
  See Also:
    `RegionAccessStrategy.unlockItem(java.lang.Object, org.hibernate.cache.spi.access.SoftLock)`

### unlockRegion

    public void unlockRegion(SoftLock lock)
                      throws CacheException

  Called after we have finished the attempted invalidation of the entire region

  Specified by:
    `unlockRegion` in interface `RegionAccessStrategy`
  Parameters:
    `lock` - The lock previously obtained from `RegionAccessStrategy.lockRegion()`
  Throws:
    `CacheException` - Propogated from underlying `Region`
  See Also:
    `RegionAccessStrategy.unlockRegion(org.hibernate.cache.spi.access.SoftLock)`

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