ehcache

net.sf.ehcache.store
Class AbstractStore

java.lang.Object
  extended by 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

ehcache

Copyright 2001-2014, Terracotta, Inc.