CLUSTER_COHERENT, NODE_COHERENT
Constructor and Description |
---|
ElementIdAssigningStore(Store delegate)
Constructor
|
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.
|
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.
|
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.
|
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
|
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
|
void |
unpinAll()
unpin all pinned keys
|
void |
waitUntilClusterCoherent()
This method waits until the cache is in coherent mode in all the connected nodes.
|
public ElementIdAssigningStore(Store delegate)
delegate
- underlying Storepublic boolean isPinned(Object key)
public void setPinned(Object key, boolean pinned)
public void addStoreListener(StoreListener listener)
addStoreListener
in interface Store
public void removeStoreListener(StoreListener listener)
removeStoreListener
in interface Store
public boolean put(Element element) throws CacheException
put
in interface Store
CacheException
public void putAll(Collection<Element> elements) throws CacheException
putAll
in interface Store
elements
- Collection of elements to be put in the storeCacheException
public boolean putWithWriter(Element element, CacheWriterManager writerManager) throws CacheException
putWithWriter
in interface Store
CacheException
public Element getQuiet(Object key)
Element
from the Store, without updating statisticspublic List getKeys()
getKeys
in interface Store
Serializable
keyspublic void removeAll(Collection<?> keys)
public Element removeWithWriter(Object key, CacheWriterManager writerManager) throws CacheException
removeWithWriter
in interface Store
CacheException
public void removeAll() throws CacheException
CacheEventListener
s they are notified of the expiry or removal
of the Element
as each is removed.removeAll
in interface Store
CacheException
public Element putIfAbsent(Element element) throws NullPointerException
putIfAbsent
in interface Store
element
- element to be addedNullPointerException
- if the element is null, or has a null keypublic Element removeElement(Element element, ElementValueComparator comparator) throws NullPointerException
removeElement
in interface Store
element
- Element to be removedcomparator
- ElementValueComparator to use to compare elementsNullPointerException
- if the element is null, or has a null keypublic boolean replace(Element old, Element element, ElementValueComparator comparator) throws NullPointerException, IllegalArgumentException
replace
in interface Store
old
- 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 Element replace(Element element) throws NullPointerException
replace
in interface Store
element
- Element to be cachedNullPointerException
- if the Element is null or has a null keypublic int getSize()
public int getInMemorySize()
getInMemorySize
in interface Store
public int getOffHeapSize()
getOffHeapSize
in interface Store
public int getOnDiskSize()
getOnDiskSize
in interface Store
public int getTerracottaClusteredSize()
getTerracottaClusteredSize
in interface Store
public long getInMemorySizeInBytes()
getInMemorySizeInBytes
in interface Store
public long getOffHeapSizeInBytes()
getOffHeapSizeInBytes
in interface Store
public long getOnDiskSizeInBytes()
getOnDiskSizeInBytes
in interface Store
public boolean hasAbortedSizeOf()
hasAbortedSizeOf
in interface Store
public Status getStatus()
public boolean containsKey(Object key)
containsKey
in interface Store
key
- The Element keypublic boolean containsKeyOnDisk(Object key)
containsKeyOnDisk
in interface Store
key
- The Element keypublic boolean containsKeyOffHeap(Object key)
containsKeyOffHeap
in interface Store
key
- The Element keypublic boolean containsKeyInMemory(Object key)
containsKeyInMemory
in interface Store
key
- The Element keypublic void expireElements()
expireElements
in interface Store
public void flush() throws IOException
flush
in interface Store
IOException
- if any IO error occurspublic boolean bufferFull()
bufferFull
in interface Store
public Policy getInMemoryEvictionPolicy()
getInMemoryEvictionPolicy
in interface Store
Store.setInMemoryEvictionPolicy(Policy)
public void setInMemoryEvictionPolicy(Policy policy)
setInMemoryEvictionPolicy
in interface Store
policy
- the new policypublic Object getInternalContext()
getInternalContext
in interface Store
public 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 clusterisCacheCoherent
in interface Store
true
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 TerracottaNotRunningException
isClusterCoherent
in interface Store
TerracottaNotRunningException
public boolean isNodeCoherent() throws TerracottaNotRunningException
isNodeCoherent
in interface Store
TerracottaNotRunningException
public void setNodeCoherent(boolean coherent) throws UnsupportedOperationException, TerracottaNotRunningException
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. TerracottasetNodeCoherent
in interface Store
coherent
- true transitions to coherent mode, false to incoherent modeUnsupportedOperationException
- if this store does not support cache coherence, like RMI replicationTerracottaNotRunningException
public void waitUntilClusterCoherent() throws UnsupportedOperationException, TerracottaNotRunningException, InterruptedException
waitUntilClusterCoherent
in interface Store
UnsupportedOperationException
- if this store does not support cache coherence, like RMI replicationInterruptedException
TerracottaNotRunningException
public Object getMBean()
public void setAttributeExtractors(Map<String,AttributeExtractor> extractors)
setAttributeExtractors
in interface Store
public Results executeQuery(StoreQuery query) throws SearchException
executeQuery
in interface Store
query
- query to executeSearchException
public <T> Attribute<T> getSearchAttribute(String attributeName)
getSearchAttribute
in interface Store
T
- type of the attributeattributeName
- the name of the attribute to retrievepublic Map<Object,Element> getAllQuiet(Collection<?> keys)
getAllQuiet
in interface Store
keys
- a collection of keys to look forpublic Map<Object,Element> getAll(Collection<?> keys)
public void recalculateSize(Object key)
recalculateSize
in interface Store
key
- the keyCopyright © 2003-2013 Terracotta, Inc.. All Rights Reserved.