net.sf.ehcache.store
Class AbstractStore

java.lang.Object
  net.sf.ehcache.store.AbstractStore

All Implemented Interfaces:

Store

Direct Known Subclasses:

AbstractTransactionStore, DiskStore, LegacyStoreWrapper, LruMemoryStore, MemoryStore

public abstract class AbstractStore
extends Object
implements Store

Author:

gkeim

Field Summary

protected Map<String,AttributeExtractor>

attributeExtractors search attribute extractors

Fields inherited from interface net.sf.ehcache.store.Store

CLUSTER_COHERENT, NODE_COHERENT

Constructor Summary

protected	AbstractStore() Constructor for stores that do not support search
protected	AbstractStore(SearchManager searchManager) Constructor for stores that do support search

Method Summary

void	addStoreListener(StoreListener listener) Add a listener to the store.
Results	executeQuery(StoreQuery query) Execute the given query on this store
Map<Object,Element>	getAll(Collection<?> keys) Retries the elements associated with a set of keys and update the statistics Keys which are not present in the cache will have null values associated with them in the returned map
Map<Object,Element>	getAllQuiet(Collection<?> keys) Retries the elements associated with a set of keys without updating the statistics Keys which are not present in the cache will have null values associated with them in the returned map
protected List<StoreListener>	getEventListenerList() onLoad initializer
<T> Attribute<T>	getSearchAttribute(String attributeName) Retrieve the given named search attribute
boolean	hasAbortedSizeOf() Checks if the cache may contain elements for which the SizeOf engine gave up and only partially calculated the size.
boolean	isCacheCoherent() Indicates whether this store provides a coherent view of all the elements in a cache.
boolean	isClusterCoherent() Returns true if the cache is in coherent mode cluster-wide.
boolean	isNodeCoherent() Returns true if the cache is in coherent mode for the current node.
void	putAll(Collection<Element> elements) Puts a collection of elements into the store.
void	recalculateSize(Object key) Recalculate size of the element mapped to the key
void	removeAll(Collection<?> keys) Removes a collection of elements from the cache.
void	removeStoreListener(StoreListener listener) Remove listener from store.
void	setAttributeExtractors(Map<String,AttributeExtractor> extractors) Inform this store of the configured attribute extractors.
void	setNodeCoherent(boolean coherent) Sets the cache in coherent or incoherent mode for the current node depending on the parameter.
void	waitUntilClusterCoherent() This method waits until the cache is in coherent mode in all the connected nodes.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface net.sf.ehcache.store.Store

bufferFull, containsKey, containsKeyInMemory, containsKeyOffHeap, containsKeyOnDisk, dispose, expireElements, flush, get, getInMemoryEvictionPolicy, getInMemorySize, getInMemorySizeInBytes, getInternalContext, getKeys, getMBean, getOffHeapSize, getOffHeapSizeInBytes, getOnDiskSize, getOnDiskSizeInBytes, getQuiet, getSize, getStatus, getTerracottaClusteredSize, put, putIfAbsent, putWithWriter, remove, removeAll, removeElement, removeWithWriter, replace, replace, setInMemoryEvictionPolicy

Field Detail

attributeExtractors

protected final Map<String,AttributeExtractor> attributeExtractors

search attribute extractors

Constructor Detail

AbstractStore

protected AbstractStore()

Constructor for stores that do not support search

AbstractStore

protected AbstractStore(SearchManager searchManager)

Constructor for stores that do support search

Parameters:

searchManager - the search manager to use

Method Detail

getEventListenerList

protected List<StoreListener> getEventListenerList()

onLoad initializer

isCacheCoherent

public boolean isCacheCoherent()

Indicates whether this store provides a coherent view of all the elements in a cache. Note that this is same as calling Store.isClusterCoherent() (introduced since 2.0) Use Store.isNodeCoherent() to find out if the cache is coherent in the current node in the cluster

Specified by:

isCacheCoherent in interface Store

Returns:

true if the store is coherent; or false if the store potentially splits the cache storage with another store or isn't internally coherent

See Also:

Store.isCacheCoherent()

isClusterCoherent

public boolean isClusterCoherent()

Returns true if the cache is in coherent mode cluster-wide. Returns false otherwise.

It applies to coherent clustering mechanisms only e.g. Terracotta

Specified by:

isClusterCoherent in interface Store

Returns:

true if the cache is in coherent mode cluster-wide, false otherwise

See Also:

Store.isClusterCoherent()

isNodeCoherent

public boolean isNodeCoherent()

Returns true if the cache is in coherent mode for the current node. Returns false otherwise.

It applies to coherent clustering mechanisms only e.g. Terracotta

Specified by:

isNodeCoherent in interface Store

Returns:

true if the cache is in coherent mode cluster-wide, false otherwise

See Also:

Store.isNodeCoherent()

setNodeCoherent

public void setNodeCoherent(boolean coherent)
                     throws UnsupportedOperationException

Sets the cache in coherent or incoherent mode for the current node depending on the parameter. Calling setNodeCoherent(true) when the cache is already in coherent mode or calling setNodeCoherent(false) when already in incoherent mode will be a no-op.

It applies to coherent clustering mechanisms only e.g. Terracotta

Specified by:

setNodeCoherent in interface Store

Parameters:

coherent - true transitions to coherent mode, false to incoherent mode

Throws:

UnsupportedOperationException - if this store does not support cache coherence, like RMI replication

See Also:

Store.setNodeCoherent(boolean)

waitUntilClusterCoherent

public void waitUntilClusterCoherent()
                              throws UnsupportedOperationException,
                                     TerracottaNotRunningException,
                                     InterruptedException

This method waits until the cache is in coherent mode in all the connected nodes. If the cache is already in coherent mode it returns immediately

It applies to coherent clustering mechanisms only e.g. Terracotta

Specified by:

waitUntilClusterCoherent in interface Store

Throws:

InterruptedException

TerracottaNotRunningException

UnsupportedOperationException - if this store does not support cache coherence, like RMI replication

See Also:

Store.waitUntilClusterCoherent()

addStoreListener

public void addStoreListener(StoreListener listener)

Add a listener to the store.

Specified by:

addStoreListener in interface Store

See Also:

Store.addStoreListener(net.sf.ehcache.store.StoreListener)

removeStoreListener

public void removeStoreListener(StoreListener listener)

Remove listener from store.

Specified by:

removeStoreListener in interface Store

See Also:

Store.removeStoreListener(net.sf.ehcache.store.StoreListener)

setAttributeExtractors

public void setAttributeExtractors(Map<String,AttributeExtractor> extractors)

Inform this store of the configured attribute extractors. Stores that will not invoke extractors are free to ignore this call

Specified by:

setAttributeExtractors in interface Store

executeQuery

public Results executeQuery(StoreQuery query)

Execute the given query on this store

Specified by:

executeQuery in interface Store

Parameters:

query - query to execute

Returns:

query results

getSearchAttribute

public <T> Attribute<T> getSearchAttribute(String attributeName)
                                throws CacheException

Retrieve the given named search attribute

Specified by:

getSearchAttribute in interface Store

Type Parameters:

T - type of the attribute

Parameters:

attributeName - the name of the attribute to retrieve

Returns:

the search attribute or null if non-existent

Throws:

CacheException

putAll

public void putAll(Collection<Element> elements)
            throws CacheException

Puts a collection of elements into the store.

Specified by:

putAll in interface Store

Parameters:

elements - Collection of elements to be put in the store

Throws:

CacheException

removeAll

public void removeAll(Collection<?> keys)

Removes a collection of elements from the cache.

Specified by:

removeAll in interface Store

getAllQuiet

public Map<Object,Element> getAllQuiet(Collection<?> keys)

Retries the elements associated with a set of keys without updating the statistics Keys which are not present in the cache will have null values associated with them in the returned map

Specified by:

getAllQuiet in interface Store

Parameters:

keys - a collection of keys to look for

Returns:

a map of keys and their corresponding values

getAll

public Map<Object,Element> getAll(Collection<?> keys)

Retries the elements associated with a set of keys and update the statistics Keys which are not present in the cache will have null values associated with them in the returned map

Specified by:

getAll in interface Store

Parameters:

keys - a collection of keys to look for

Returns:

a map of keys and their corresponding values

hasAbortedSizeOf

public boolean hasAbortedSizeOf()

Checks if the cache may contain elements for which the SizeOf engine gave up and only partially calculated the size.

Specified by:

hasAbortedSizeOf in interface Store

Returns:

true if at least one partially sized element may be in the cache

recalculateSize

public void recalculateSize(Object key)

Recalculate size of the element mapped to the key

Specified by:

recalculateSize in interface Store

Parameters:

key - the key