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

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

All Implemented Interfaces:
  CollectionRegionAccessStrategy, RegionAccessStrategy

    public class ReadWriteEhcacheCollectionRegionAccessStrategy

extends Object
implements CollectionRegionAccessStrategy

Ehcache specific read/write collection 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
`ReadWriteEhcacheCollectionRegionAccessStrategy(EhcacheCollectionRegion region, Settings settings)` Create a read/write access strategy accessing the given collection region.

Method Summary
`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.
`CollectionRegion` `getRegion()` Get the wrapped collection 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
`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.

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

### ReadWriteEhcacheCollectionRegionAccessStrategy

    public ReadWriteEhcacheCollectionRegionAccessStrategy(EhcacheCollectionRegion region,
                                                          Settings settings)

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

Method Detail

### getRegion

    public CollectionRegion getRegion()

  Get the wrapped collection cache region

  Specified by:
    `getRegion` in interface `CollectionRegionAccessStrategy`
  Returns:
    The 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.