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

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

All Implemented Interfaces:
  EntityRegionAccessStrategy, RegionAccessStrategy

    public class ReadWriteEhcacheEntityRegionAccessStrategy

extends Object
implements EntityRegionAccessStrategy

Ehcache specific read/write entity region access strategy

Nested Class Summary
`protected static class` `org.hibernate.cache.ehcache.internal.strategy.AbstractReadWriteEhcacheAccessStrategy.Item` Wrapper type representing unlocked items.
`protected static class` `org.hibernate.cache.ehcache.internal.strategy.AbstractReadWriteEhcacheAccessStrategy.Lock` Wrapper type representing locked items.
`protected static interface` `org.hibernate.cache.ehcache.internal.strategy.AbstractReadWriteEhcacheAccessStrategy.Lockable` Interface type implemented by all wrapper objects in the cache.

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

Constructor Summary
`ReadWriteEhcacheEntityRegionAccessStrategy(EhcacheEntityRegion region, Settings settings)` Create a read/write access strategy accessing the given entity region.

Method Summary
`boolean` `afterInsert(Object key, Object value, Object version)` Called after an item has been inserted (after the transaction completes), instead of calling release().
`boolean` `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().
`protected void` `decrementLock(Object key, org.hibernate.cache.ehcache.internal.strategy.AbstractReadWriteEhcacheAccessStrategy.Lock lock)` Unlock and re-put the given key, lock combination.
`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)` Returns `null` if the item is not readable.
`EntityRegion` `getRegion()` Get the wrapped entity cache region
`protected void` `handleLockExpiry(Object key, org.hibernate.cache.ehcache.internal.strategy.AbstractReadWriteEhcacheAccessStrategy.Lockable lock)` Handle the timeout of a previous lock mapped to this key
`boolean` `insert(Object key, Object value, Object version)` A no-op since this is an asynchronous cache access strategy.
`SoftLock` `lockItem(Object key, Object version)` Soft-lock a cache item.
`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)` Returns `false` and fails to put the value if there is an existing un-writeable item mapped to this key.
`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)` Soft-unlock a cache item.
`void` `unlockRegion(SoftLock lock)` Region locks are not supported - perform a cache clear as a precaution.
`boolean` `update(Object key, Object value, Object currentVersion, Object previousVersion)` A no-op since this is an asynchronous cache access 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, get, lockItem, lockRegion, putFromLoad, putFromLoad, remove, removeAll, unlockItem, 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

### ReadWriteEhcacheEntityRegionAccessStrategy

    public ReadWriteEhcacheEntityRegionAccessStrategy(EhcacheEntityRegion region,
                                                      Settings settings)

  Create a read/write access strategy accessing the given entity region.

Method Detail

### getRegion

    public EntityRegion getRegion()

  Get the wrapped entity cache region

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

### insert

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

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

  Specified by:
    `insert` in interface `EntityRegionAccessStrategy`
  Parameters:
    `key` - The item key
    `value` - The item
    `version` - The item's version value
  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,
                               Object version)
                        throws CacheException

  Called after an item has been inserted (after the transaction completes), instead of calling release(). This method is used by "asynchronous" concurrency strategies.

  Inserts will only succeed if there is no existing value mapped to this key.

  Specified by:
    `afterInsert` in interface `EntityRegionAccessStrategy`
  Parameters:
    `key` - The item key
    `value` - The item
    `version` - The item's version value
  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,
                          Object currentVersion,
                          Object previousVersion)
                   throws CacheException

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

  Specified by:
    `update` in interface `EntityRegionAccessStrategy`
  Parameters:
    `key` - The item key
    `value` - The item
    `currentVersion` - The item's current version value
    `previousVersion` - The item's previous version value
  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,
                               Object currentVersion,
                               Object previousVersion,
                               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.

  Updates will only succeed if this entry was locked by this transaction and exclusively this transaction for the duration of this transaction. It is important to also note that updates will fail if the soft-lock expired during the course of this transaction.

  Specified by:
    `afterUpdate` in interface `EntityRegionAccessStrategy`
  Parameters:
    `key` - The item key
    `value` - The item
    `currentVersion` - The item's current version value
    `previousVersion` - The item's previous version value
    `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`

### get

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

  Returns `null` if the item is not readable. Locked items are not readable, nor are items created after the start of this transaction.

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

### putFromLoad

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

  Returns `false` and fails to put the value if there is an existing un-writeable item mapped to this key.

  Throws:
    `CacheException`
  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 final SoftLock lockItem(Object key,
                                   Object version)
                            throws CacheException

  Soft-lock a cache item.

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

### unlockItem

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

  Soft-unlock a cache item.

  Throws:
    `CacheException`
  See Also:
    `RegionAccessStrategy.unlockItem(java.lang.Object, org.hibernate.cache.spi.access.SoftLock)`, `RegionAccessStrategy.unlockItem(java.lang.Object, org.hibernate.cache.spi.access.SoftLock)`

### decrementLock

    protected void decrementLock(Object key,
                                 org.hibernate.cache.ehcache.internal.strategy.AbstractReadWriteEhcacheAccessStrategy.Lock lock)

  Unlock and re-put the given key, lock combination.

### handleLockExpiry

    protected void handleLockExpiry(Object key,
                                    org.hibernate.cache.ehcache.internal.strategy.AbstractReadWriteEhcacheAccessStrategy.Lockable lock)

  Handle the timeout of a previous lock mapped to this key

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

### remove

    public void remove(Object key)
                throws CacheException

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

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

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