com.tangosol.net.cache.AbstractCacheStore Maven / Gradle / Ivy
Show all versions of coherence Show documentation
/*
* Copyright (c) 2000, 2020, Oracle and/or its affiliates.
*
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*/
package com.tangosol.net.cache;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
/**
* An abstract base class for the JCache CacheLoader.
*
* @author cp 2003.05.29
* @author jh 2005.09.01
*/
public abstract class AbstractCacheStore
extends AbstractCacheLoader
implements CacheStore
{
// ----- CacheStore interface -------------------------------------------
/**
* Store the specified value under the specified key in the underlying
* store. This method is intended to support both key/value creation
* and value update for a specific key.
*
* @param key key to store the value under
* @param value value to be stored
*
* @throws UnsupportedOperationException if this implementation or the
* underlying store is read-only
*/
public void store(K key, V value)
{
throw new UnsupportedOperationException();
}
/**
* Store the specified values under the specified keys in the underlying
* store. This method is intended to support both key/value creation
* and value update for the specified keys.
*
* The implementation of this method calls {@link #store} for each entry in
* the supplied Map. Once stored successfully, an entry is removed from
* the Map (if possible).
*
* Note:
* For many types of persistent stores, a single store operation is as
* expensive as a bulk store operation; therefore, subclasses should
* override this method if possible.
*
* @param mapEntries a Map of any number of keys and values to store
*
* @throws UnsupportedOperationException if this implementation or the
* underlying store is read-only
*/
public void storeAll(Map mapEntries)
{
boolean fRemove = true;
for (Iterator> iter = mapEntries.entrySet().iterator(); iter.hasNext(); )
{
Map.Entry entry = iter.next();
store(entry.getKey(), entry.getValue());
if (fRemove)
{
try
{
iter.remove();
}
catch (UnsupportedOperationException e)
{
fRemove = false;
}
}
}
}
/**
* Remove the specified key from the underlying store if present.
*
* @param key key whose mapping is being removed from the cache
*
* @throws UnsupportedOperationException if this implementation or the
* underlying store is read-only
*/
public void erase(K key)
{
throw new UnsupportedOperationException();
}
/**
* Remove the specified keys from the underlying store if present.
*
* The implementation of this method calls {@link #erase} for each key in
* the supplied Collection. Once erased successfully, a key is removed from
* the Collection (if possible).
*
* Note:
* For many types of persistent stores, a single erase operation is as
* expensive as a bulk erase operation; therefore, subclasses should
* override this method if possible.
*
* @param colKeys keys whose mappings are being removed from the cache
*
* @throws UnsupportedOperationException if this implementation or the
* underlying store is read-only
*/
public void eraseAll(Collection colKeys)
{
boolean fRemove = true;
for (Iterator iter = colKeys.iterator(); iter.hasNext(); )
{
erase(iter.next());
if (fRemove)
{
try
{
iter.remove();
}
catch (UnsupportedOperationException e)
{
fRemove = false;
}
}
}
}
}