public final class ExceptionOnTimeoutStore extends Object implements NonstopStore
NonstopStore that throws NonStopCacheException for all operations.| Modifier and Type | Field and Description |
|---|---|
static NonstopTimeoutBehaviorFactory |
FACTORY
The
NonstopTimeoutBehaviorFactory to create ExceptionOnTimeoutStore stores |
CLUSTER_COHERENT, NODE_COHERENT| Modifier and Type | Method and Description |
|---|---|
void |
addStoreListener(StoreListener listener)
Add a listener to the store.
|
boolean |
bufferFull()
Some store types, such as the disk stores can fill their write buffers if puts
come in too fast.
|
boolean |
containsKey(Object key)
A check to see if a key is in the Store.
|
boolean |
containsKeyInMemory(Object key)
A check to see if a key is in the Store and is currently held in memory.
|
boolean |
containsKeyOffHeap(Object key)
A check to see if a key is in the Store and is currently held off-heap.
|
boolean |
containsKeyOnDisk(Object key)
A check to see if a key is in the Store and is currently held on disk.
|
void |
dispose()
Prepares for shutdown.
|
<V> V |
executeClusterOperation(ClusterOperation<V> operation)
Execute the
ClusterOperation within this NonstopStore context. |
Results |
executeQuery(StoreQuery query)
Execute the given query on this store
|
void |
expireElements()
Expire all elements.
|
void |
flush()
Flush elements to persistent store.
|
Element |
get(Object key)
Gets an item from the cache.
|
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
|
Policy |
getInMemoryEvictionPolicy()
.
|
int |
getInMemorySize()
Returns the current local in-memory store size
|
long |
getInMemorySizeInBytes()
Gets the size of the in-memory portion of the store, in bytes.
|
static ExceptionOnTimeoutStore |
getInstance()
returns the singleton instance
|
Object |
getInternalContext()
This should not be used, and will generally return null
|
List |
getKeys()
Gets an Array of the keys for all elements in the disk store.
|
Set |
getLocalKeys()
Returns set of keys from the cache which are present in the node locally.
|
Object |
getMBean()
Optional implementation specific MBean exposed by the store.
|
int |
getOffHeapSize()
Returns the current local off-heap store size
|
long |
getOffHeapSizeInBytes()
Gets the size of the off-heap portion of the store, in bytes.
|
int |
getOnDiskSize()
Returns the current local on-disk store size
|
long |
getOnDiskSizeInBytes()
Gets the size of the on-disk portion of the store, in bytes.
|
Element |
getQuiet(Object key)
Gets an
Element from the Store, without updating statistics |
<T> Attribute<T> |
getSearchAttribute(String attributeName)
Retrieve the given named search attribute
|
int |
getSize()
Returns the current local store size
|
Status |
getStatus()
Returns the cache status.
|
int |
getTerracottaClusteredSize()
Returns the current Terracotta clustered store size
|
CacheConfiguration.TransactionalMode |
getTransactionalMode()
Get the transactional mode of this store.
|
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.
|
boolean |
isPinned(Object key)
Check if the key is pinned
|
boolean |
put(Element element)
Puts an item into the store.
|
void |
putAll(Collection<Element> elements)
Puts a collection of elements into the store.
|
Element |
putIfAbsent(Element element)
Put an element in the store if no element is currently mapped to the elements key.
|
boolean |
putWithWriter(Element element,
CacheWriterManager writerManager)
Puts an item into the store and the cache writer manager in an atomic operation
|
void |
recalculateSize(Object key)
Recalculate size of the element mapped to the key
|
Element |
remove(Object key)
Removes an item from the cache.
|
void |
removeAll()
Remove all of the elements from the store.
|
void |
removeAll(Collection<?> keys)
Removes a collection of elements from the cache.
|
Element |
removeElement(Element element,
ElementValueComparator comparator)
Remove the Element mapped to the key for the supplied element if the value of the supplied Element
is equal to the value of the cached Element.
|
void |
removeStoreListener(StoreListener listener)
Remove listener from store.
|
Element |
removeWithWriter(Object key,
CacheWriterManager writerManager)
Removes an item from the store and the cache writer manager in an atomic operation.
|
Element |
replace(Element element)
Replace the cached element only if an Element is currently cached for this key
|
boolean |
replace(Element old,
Element element,
ElementValueComparator comparator)
Replace the cached element only if the value of the current Element is equal to the value of the
supplied old Element.
|
void |
setAttributeExtractors(Map<String,AttributeExtractor> extractors)
Inform this store of the configured attribute extractors.
|
void |
setInMemoryEvictionPolicy(Policy policy)
Sets the eviction policy strategy.
|
void |
setNodeCoherent(boolean coherent)
Sets the cache in coherent or incoherent mode for the current node depending on the parameter.
|
void |
setPinned(Object key,
boolean pinned)
Mark the key as pinned or not
|
Element |
unlockedGet(Object key)
Gets the value associated with the key without acquiring any locks.
|
Element |
unlockedGetQuiet(Object key)
Same as
TerracottaStore.unlockedGet(Object) but does not update statistics |
void |
unpinAll()
unpin all pinned keys
|
Element |
unsafeGet(Object key)
Returns the local value associated with the key.
|
Element |
unsafeGetQuiet(Object key)
Same as
TerracottaStore.unsafeGet(Object) but does not update last usage statistics |
void |
waitUntilClusterCoherent()
This method waits until the cache is in coherent mode in all the connected nodes.
|
public static final NonstopTimeoutBehaviorFactory FACTORY
NonstopTimeoutBehaviorFactory to create ExceptionOnTimeoutStore storespublic static ExceptionOnTimeoutStore getInstance()
public void unpinAll()
Throws NonStopCacheException
public boolean isPinned(Object key)
Throws NonStopCacheException
public void setPinned(Object key, boolean pinned)
Throws NonStopCacheException
public Element get(Object key) throws IllegalStateException, CacheException
Throws NonStopCacheException
get in interface StoreIllegalStateExceptionCacheExceptionpublic Element getQuiet(Object key) throws IllegalStateException, CacheException
Element from the Store, without updating statisticsgetQuiet in interface StoreIllegalStateExceptionCacheExceptionpublic Map<Object,Element> getAllQuiet(Collection<?> keys)
Throws NonStopCacheException
getAllQuiet in interface Storekeys - a collection of keys to look forpublic Map<Object,Element> getAll(Collection<?> keys)
Throws NonStopCacheException
public List getKeys() throws IllegalStateException, CacheException
Throws NonStopCacheException
getKeys in interface StoreSerializable keysIllegalStateExceptionCacheExceptionpublic boolean put(Element element) throws IllegalArgumentException, IllegalStateException, CacheException
Throws NonStopCacheException
put in interface StoreIllegalArgumentExceptionIllegalStateExceptionCacheExceptionpublic void putAll(Collection<Element> elements) throws CacheException
Throws NonStopCacheException
putAll in interface Storeelements - Collection of elements to be put in the storeCacheExceptionpublic Element remove(Object key) throws IllegalStateException
Throws NonStopCacheException
remove in interface StoreIllegalStateExceptionpublic void removeAll(Collection<?> keys) throws IllegalStateException
Throws NonStopCacheException
removeAll in interface StoreIllegalStateExceptionpublic void removeAll()
throws IllegalStateException,
CacheException
CacheEventListeners they are notified of the expiry or removal
of the Element as each is removed..
Throws NonStopCacheException
removeAll in interface StoreIllegalStateExceptionCacheExceptionpublic void flush()
throws IllegalStateException,
CacheException
Throws NonStopCacheException
flush in interface StoreIllegalStateExceptionCacheExceptionpublic Object getInternalContext()
Throws NonStopCacheException
getInternalContext in interface Storepublic int getSize()
throws IllegalStateException,
CacheException
Throws NonStopCacheException
getSize in interface StoreIllegalStateExceptionCacheExceptionpublic Element putIfAbsent(Element element) throws NullPointerException
Throws NonStopCacheException
putIfAbsent in interface Storeelement - element to be addedNullPointerException - if the element is null, or has a null keypublic Element replace(Element element) throws NullPointerException
Throws NonStopCacheException
replace in interface Storeelement - Element to be cachedNullPointerException - if the Element is null or has a null keypublic void addStoreListener(StoreListener listener)
Throws NonStopCacheException
addStoreListener in interface Storepublic boolean bufferFull()
Throws NonStopCacheException
bufferFull in interface Storepublic boolean containsKey(Object key)
Throws NonStopCacheException
containsKey in interface Storekey - The Element keypublic boolean containsKeyInMemory(Object key)
Throws NonStopCacheException
containsKeyInMemory in interface Storekey - The Element keypublic boolean containsKeyOffHeap(Object key)
Throws NonStopCacheException
containsKeyOffHeap in interface Storekey - The Element keypublic boolean containsKeyOnDisk(Object key)
Throws NonStopCacheException
containsKeyOnDisk in interface Storekey - The Element keypublic void dispose()
Throws NonStopCacheException
public Results executeQuery(StoreQuery query)
Throws NonStopCacheException
executeQuery in interface Storequery - query to executepublic void expireElements()
Throws NonStopCacheException
expireElements in interface Storepublic Policy getInMemoryEvictionPolicy()
Throws NonStopCacheException
getInMemoryEvictionPolicy in interface StoreStore.setInMemoryEvictionPolicy(Policy)public int getInMemorySize()
Throws NonStopCacheException
getInMemorySize in interface Storepublic long getInMemorySizeInBytes()
Throws NonStopCacheException
getInMemorySizeInBytes in interface Storepublic Object getMBean()
Throws NonStopCacheException
public int getOffHeapSize()
Throws NonStopCacheException
getOffHeapSize in interface Storepublic long getOffHeapSizeInBytes()
Throws NonStopCacheException
getOffHeapSizeInBytes in interface Storepublic int getOnDiskSize()
Throws NonStopCacheException
getOnDiskSize in interface Storepublic long getOnDiskSizeInBytes()
Throws NonStopCacheException
getOnDiskSizeInBytes in interface Storepublic boolean hasAbortedSizeOf()
Throws NonStopCacheException
hasAbortedSizeOf in interface Storepublic Status getStatus()
Throws NonStopCacheException
public int getTerracottaClusteredSize()
Throws NonStopCacheException
getTerracottaClusteredSize in interface Storepublic boolean isCacheCoherent()
Store.isClusterCoherent() (introduced since 2.0)
Use Store.isNodeCoherent() to find out if the cache is coherent in the current node in the cluster.
Throws NonStopCacheException
isCacheCoherent in interface Storetrue if the store is coherent; or false if the
store potentially splits the cache storage with another store or
isn't internally coherentpublic boolean isClusterCoherent()
Throws NonStopCacheException
isClusterCoherent in interface Storepublic boolean isNodeCoherent()
Throws NonStopCacheException
isNodeCoherent in interface Storepublic boolean putWithWriter(Element element, CacheWriterManager writerManager) throws CacheException
Throws NonStopCacheException
putWithWriter in interface StoreCacheExceptionpublic Element removeElement(Element element, ElementValueComparator comparator) throws NullPointerException
Throws NonStopCacheException
removeElement in interface Storeelement - Element to be removedcomparator - ElementValueComparator to use to compare elementsNullPointerException - if the element is null, or has a null keypublic void removeStoreListener(StoreListener listener)
Throws NonStopCacheException
removeStoreListener in interface Storepublic Element removeWithWriter(Object key, CacheWriterManager writerManager) throws CacheException
Throws NonStopCacheException
removeWithWriter in interface StoreCacheExceptionpublic boolean replace(Element old, Element element, ElementValueComparator comparator) throws NullPointerException, IllegalArgumentException
Throws NonStopCacheException
replace in interface Storeold - Element to be test againstelement - Element to be cachedcomparator - ElementValueComparator to use to compare elementsNullPointerException - if the either Element is null or has a null keyIllegalArgumentException - if the two Element keys are non-null but not equalpublic void setAttributeExtractors(Map<String,AttributeExtractor> extractors)
Throws NonStopCacheException
setAttributeExtractors in interface Storepublic void setInMemoryEvictionPolicy(Policy policy)
Throws NonStopCacheException
setInMemoryEvictionPolicy in interface Storepolicy - the new policypublic void setNodeCoherent(boolean coherent)
throws UnsupportedOperationException
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.
Throws NonStopCacheException
setNodeCoherent in interface Storecoherent - true transitions to coherent mode, false to incoherent modeUnsupportedOperationException - if this store does not support cache coherence, like RMI replicationpublic void waitUntilClusterCoherent()
throws UnsupportedOperationException
Throws NonStopCacheException
waitUntilClusterCoherent in interface StoreUnsupportedOperationException - if this store does not support cache coherence, like RMI replicationpublic <T> Attribute<T> getSearchAttribute(String attributeName)
Throws NonStopCacheException
getSearchAttribute in interface StoreT - type of the attributeattributeName - the name of the attribute to retrievepublic Set getLocalKeys()
getLocalKeys in interface TerracottaStorepublic CacheConfiguration.TransactionalMode getTransactionalMode()
getTransactionalMode in interface TerracottaStoreCacheConfiguration.TransactionalModepublic Element unlockedGet(Object key)
unlockedGet in interface TerracottaStorepublic Element unlockedGetQuiet(Object key)
TerracottaStore.unlockedGet(Object) but does not update statisticsunlockedGetQuiet in interface TerracottaStorepublic Element unsafeGet(Object key)
unsafeGet in interface TerracottaStorekey - the keypublic Element unsafeGetQuiet(Object key)
TerracottaStore.unsafeGet(Object) but does not update last usage statisticsunsafeGetQuiet in interface TerracottaStorekey - the keypublic <V> V executeClusterOperation(ClusterOperation<V> operation)
ClusterOperation within this NonstopStore context.executeClusterOperation in interface NonstopStoreV - Return type depending on the ClusterOperationClusterOperationpublic void recalculateSize(Object key)
recalculateSize in interface Storekey - the keyCopyright © 2003-2014 Terracotta, Inc.. All Rights Reserved.