Open Source Repository

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


org/hibernate/cache/SwarmCache.java
//$Id: SwarmCache.java 6478 2005-04-21 07:57:19Z oneovthafew $
package org.hibernate.cache;

import net.sf.swarmcache.ObjectCache;

import java.io.Serializable;
import java.util.Map;

/**
 @author Jason Carreira, Gavin King
 */
public class SwarmCache implements Cache {
  
    private final ObjectCache cache;
    private final String regionName;
    
    public SwarmCache(ObjectCache cache, String regionName) {
        this.cache = cache;
        this.regionName = regionName;
    }

    /**
     * Get an item from the cache
     @param key
     @return the cached object or <tt>null</tt>
     @throws CacheException
     */
    public Object get(Object keythrows CacheException {
        if (key instanceof Serializable) {
            return cache.get( (Serializablekey );
        
        else {
            throw new CacheException("Keys must implement Serializable");
        }
    }

    public Object read(Object keythrows CacheException {
    return get(key);
    }
  
    /**
     * Add an item to the cache
     @param key
     @param value
     @throws CacheException
     */
    public void update(Object key, Object valuethrows CacheException {
    put(key, value);
  }
  
    /**
     * Add an item to the cache
     @param key
     @param value
     @throws CacheException
     */
  public void put(Object key, Object valuethrows CacheException {
        if (key instanceof Serializable) {
            cache.put( (Serializablekey, value );
        
        else {
            throw new CacheException("Keys must implement Serializable");
        }
    }

    /**
     * Remove an item from the cache
     */
    public void remove(Object keythrows CacheException {
        if (key instanceof Serializable) {
            cache.clear( (Serializablekey );
        
        else {
            throw new CacheException("Keys must implement Serializable");
        }
    }

    /**
     * Clear the cache
     */
    public void clear() throws CacheException {
        cache.clearAll();
    }

    /**
     * Clean up
     */
    public void destroy() throws CacheException {
        cache.clearAll();
    }

    /**
     * If this is a clustered cache, lock the item
     */
    public void lock(Object keythrows CacheException {
        throw new UnsupportedOperationException("SwarmCache does not support locking (use nonstrict-read-write)");
    }

    /**
     * If this is a clustered cache, unlock the item
     */
    public void unlock(Object keythrows CacheException {
    throw new UnsupportedOperationException("SwarmCache does not support locking (use nonstrict-read-write)");
    }

    /**
     * Generate a (coarse) timestamp
     */
    public long nextTimestamp() {
      return System.currentTimeMillis() 100;
    }

    /**
     * Get a reasonable "lock timeout"
     */
    public int getTimeout() {
    return 600;
    }

  public String getRegionName() {
    return regionName;
  }

  public long getSizeInMemory() {
    return -1;
  }

  public long getElementCountInMemory() {
    return -1;
  }

  public long getElementCountOnDisk() {
    return -1;
  }
  
  public Map toMap() {
    throw new UnsupportedOperationException();
  }

  public String toString() {
    return "SwarmCache(" + regionName + ')';
  }

}