## org.hibernate.cache.ehcache.internal.strategy
Class NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategy

    java.lang.Object
      org.hibernate.cache.ehcache.internal.strategy.NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategy

All Implemented Interfaces:
  NaturalIdRegionAccessStrategy, RegionAccessStrategy

    public class NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategy

extends Object
implements NaturalIdRegionAccessStrategy

Ehcache specific non-strict read/write NaturalId region access strategy

Field Summary
`protected T` `region` The wrapped Hibernate cache region.
`protected Settings` `settings` The settings for this persistence unit.

Constructor Summary
`NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategy(EhcacheNaturalIdRegion region, Settings settings)` Create a non-strict read/write access strategy accessing the given NaturalId region.

Method Summary
`boolean` `afterInsert(Object key, Object value)` Returns `false` since this is a non-strict read/write cache access strategy
`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)` Remove the given mapping without regard to transactional safety
`void` `evictAll()` Remove all mappings without regard to transactional safety
`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)` Returns `false` since this is an asynchronous cache access strategy.
`SoftLock` `lockItem(Object key, Object version)` Since this is a non-strict read/write strategy item locking is not used.
`SoftLock` `lockRegion()` Region locks are not supported.
`boolean` `putFromLoad(Object key, Object value, long txTimestamp, Object version)` This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.
`boolean` `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` `remove(Object key)` A no-op since this is an asynchronous cache access strategy.
`void` `removeAll()` Called to evict data from the entire region
`void` `unlockItem(Object key, SoftLock lock)` Since this is a non-strict read/write strategy item locking is not used.
`void` `unlockRegion(SoftLock lock)` Region locks are not supported - perform a cache clear as a precaution.
`boolean` `update(Object key, Object value)` Removes the entry since this is a non-strict read/write cache strategy.

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

Methods inherited from interface org.hibernate.cache.spi.access.RegionAccessStrategy
`evict, evictAll, lockRegion, putFromLoad, removeAll, unlockRegion`

Field Detail

### region

    protected final T extends EhcacheTransactionalDataRegion region

  The wrapped Hibernate cache region.

### settings

    protected final Settings settings

  The settings for this persistence unit.

Constructor Detail

### NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategy

    public NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategy(EhcacheNaturalIdRegion region,
                                                                  Settings settings)

  Create a non-strict read/write access strategy accessing the given NaturalId region.

Method Detail

### getRegion

    public NaturalIdRegion getRegion()

  Get the wrapped naturalId cache region

  Specified by:
    `getRegion` in interface `NaturalIdRegionAccessStrategy`
  Returns:
    The underlying region

### 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`

### putFromLoad

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

  This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.

  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)`, `RegionAccessStrategy.putFromLoad(java.lang.Object, java.lang.Object, long, java.lang.Object, boolean)`

### lockItem

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

  Since this is a non-strict read/write strategy item locking is not used.

  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`

### unlockItem

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

  Since this is a non-strict read/write strategy item locking is not used.

  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`

### insert

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

  Returns `false` since this is an asynchronous cache access strategy.

  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

  Returns `false` since this is a non-strict read/write cache access strategy

  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

  Removes the entry since this is a non-strict read/write cache strategy.

  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

  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`

### remove

    public void remove(Object key)
                throws CacheException

  A no-op since this is an asynchronous cache access strategy.

  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)`, `RegionAccessStrategy.remove(java.lang.Object)`

### putFromLoad

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

  This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.

  Throws:
    `CacheException`
  See Also:
    `RegionAccessStrategy.putFromLoad(java.lang.Object, java.lang.Object, long, java.lang.Object)`, `RegionAccessStrategy.putFromLoad(java.lang.Object, java.lang.Object, long, java.lang.Object)`

### lockRegion

    public final SoftLock lockRegion()

  Region locks are not supported.

  Returns:
    `null`
  See Also:
    `RegionAccessStrategy.lockRegion()`, `RegionAccessStrategy.lockRegion()`

### unlockRegion

    public final void unlockRegion(SoftLock lock)
                            throws CacheException

  Region locks are not supported - perform a cache clear as a precaution.

  Throws:
    `CacheException`
  See Also:
    `RegionAccessStrategy.unlockRegion(org.hibernate.cache.spi.access.SoftLock)`, `RegionAccessStrategy.unlockRegion(org.hibernate.cache.spi.access.SoftLock)`

### removeAll

    public final void removeAll()
                         throws CacheException

  Called to evict data from the entire region

  Throws:
    `CacheException` - Propogated from underlying `Region`
  See Also:
    `RegionAccessStrategy.removeAll()`, `RegionAccessStrategy.removeAll()`

### evict

    public final void evict(Object key)
                     throws CacheException

  Remove the given mapping without regard to transactional safety

  Throws:
    `CacheException`
  See Also:
    `RegionAccessStrategy.evict(java.lang.Object)`, `RegionAccessStrategy.evict(java.lang.Object)`

### evictAll

    public final void evictAll()
                        throws CacheException

  Remove all mappings without regard to transactional safety

  Throws:
    `CacheException`
  See Also:
    `RegionAccessStrategy.evictAll()`, `RegionAccessStrategy.evictAll()`

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