Open Source Repository

Home /hibernate/hibernate-3.2.4.ga | Repository Home


org/hibernate/cache/NonstrictReadWriteCache.java
//$Id: NonstrictReadWriteCache.java 9278 2006-02-13 16:57:22Z steveebersole $
package org.hibernate.cache;

import java.util.Comparator;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * Caches data that is sometimes updated without ever locking the cache.
 * If concurrent access to an item is possible, this concurrency strategy
 * makes no guarantee that the item returned from the cache is the latest
 * version available in the database. Configure your cache timeout accordingly!
 * This is an "asynchronous" concurrency strategy.
 *
 @author Gavin King
 @see ReadWriteCache for a much stricter algorithm
 */
public class NonstrictReadWriteCache implements CacheConcurrencyStrategy {

  private Cache cache;

  private static final Log log = LogFactory.getLogNonstrictReadWriteCache.class );

  public NonstrictReadWriteCache() {
  }

  public void setCache(Cache cache) {
    this.cache = cache;
  }

  public Cache getCache() {
    return cache;
  }

  /**
   * Get the most recent version, if available.
   */
  public Object get(Object key, long txTimestampthrows CacheException {
    if log.isDebugEnabled() ) {
      log.debug"Cache lookup: " + key );
    }

    Object result = cache.getkey );
    if result != null ) {
      log.debug"Cache hit" );
    }
    else {
      log.debug"Cache miss" );
    }
    return result;
  }

  /**
   * Add an item to the cache.
   */
  public boolean put(
      Object key,
          Object value,
          long txTimestamp,
          Object version,
          Comparator versionComparator,
          boolean minimalPutthrows CacheException {
    if minimalPut && cache.getkey != null ) {
      if log.isDebugEnabled() ) {
        log.debug"item already cached: " + key );
      }
      return false;
    }
    if log.isDebugEnabled() ) {
      log.debug"Caching: " + key );
    }

    cache.putkey, value );
    return true;

  }

  /**
   * Do nothing.
   *
   @return null, no lock
   */
  public SoftLock lock(Object key, Object versionthrows CacheException {
    return null;
  }

  public void remove(Object keythrows CacheException {
    if log.isDebugEnabled() ) {
      log.debug"Removing: " + key );
    }
    cache.removekey );
  }

  public void clear() throws CacheException {
    if log.isDebugEnabled() ) {
      log.debug"Clearing" );
    }
    cache.clear();
  }

  public void destroy() {
    try {
      cache.destroy();
    }
    catch Exception e ) {
      log.warn"could not destroy cache", e );
    }
  }

  /**
   * Invalidate the item
   */
  public void evict(Object keythrows CacheException {
    if log.isDebugEnabled() ) {
      log.debug"Invalidating: " + key );
    }

    cache.removekey );
  }

  /**
   * Invalidate the item
   */
  public boolean insert(Object key, Object value, Object currentVersion) {
    return false;
  }

  /**
   * Do nothing.
   */
  public boolean update(Object key, Object value, Object currentVersion, Object previousVersion) {
    evictkey );
    return false;
  }

  /**
   * Invalidate the item (again, for safety).
   */
  public void release(Object key, SoftLock lockthrows CacheException {
    if log.isDebugEnabled() ) {
      log.debug"Invalidating (again): " + key );
    }

    cache.removekey );
  }

  /**
   * Invalidate the item (again, for safety).
   */
  public boolean afterUpdate(Object key, Object value, Object version, SoftLock lockthrows CacheException {
    releasekey, lock );
    return false;
  }

  /**
   * Do nothing.
   */
  public boolean afterInsert(Object key, Object value, Object versionthrows CacheException {
    return false;
  }

  public String getRegionName() {
    return cache.getRegionName();
  }

  public String toString() {
    return cache + "(nonstrict-read-write)";
  }
}