|
ehcache | |||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object net.sf.ehcache.store.TxCopyingCacheStore<T>
T
- the store type it wrapspublic final class TxCopyingCacheStore<T extends Store>
Copies elements, either on read, write or both before using the underlying store to actually store things. When copying both ways, the store might not see the same types being stored. Also exposes a method to get the old value from an entry currently mutated in a transaction.
Field Summary |
---|
Fields inherited from interface net.sf.ehcache.store.Store |
---|
CLUSTER_COHERENT, NODE_COHERENT |
Constructor Summary | |
---|---|
TxCopyingCacheStore(T store,
boolean copyOnRead,
boolean copyOnWrite,
ReadWriteCopyStrategy<Element> copyStrategyInstance,
ClassLoader loader)
Creates a copying instance of store, that wraps the actual storage |
Method Summary | ||
---|---|---|
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 |
|
protected CopyStrategyHandler |
getCopyStrategyHandler()
Accessor to the CopyStrategyHandler |
|
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. |
|
Element |
getOldElement(Object key)
Gets an element from the store, choosing the old value in case the element is currently mutated inside a transaction. |
|
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 |
|
|
getSearchAttribute(String attributeName)
Retrieve the given named search attribute |
|
Set<Attribute> |
getSearchAttributes()
|
|
int |
getSize()
Returns the current local store size |
|
Status |
getStatus()
Returns the cache status. |
|
int |
getTerracottaClusteredSize()
Returns the current Terracotta clustered store size |
|
T |
getUnderlyingStore()
Accessor to the underlying 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 |
put(Element e)
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 |
waitUntilClusterCoherent()
This method waits until the cache is in coherent mode in all the connected nodes. |
|
static ElementValueComparator |
wrap(ElementValueComparator comparator,
CacheConfiguration cacheConfiguration)
Wraps the given ElementValueComparator if the configuration requires copy on read |
|
static Store |
wrapTxStore(AbstractTransactionStore cacheStore,
CacheConfiguration cacheConfiguration)
Wraps the Store instance passed in, should any copy occur |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Constructor Detail |
---|
public TxCopyingCacheStore(T store, boolean copyOnRead, boolean copyOnWrite, ReadWriteCopyStrategy<Element> copyStrategyInstance, ClassLoader loader)
store
- the real storecopyOnRead
- whether to copy on readscopyOnWrite
- whether to copy on writescopyStrategyInstance
- the copy strategy to use on every copy operationloader
- classloadaer of the containing cacheMethod Detail |
---|
public Element getOldElement(Object key)
key
- the key to look for
public static Store wrapTxStore(AbstractTransactionStore cacheStore, CacheConfiguration cacheConfiguration)
cacheStore
- the storecacheConfiguration
- the cache config for that store
public static ElementValueComparator wrap(ElementValueComparator comparator, CacheConfiguration cacheConfiguration)
ElementValueComparator
if the configuration requires copy on read
comparator
- the comparator to wrapcacheConfiguration
- the cache configuration
public void addStoreListener(StoreListener listener)
Store
addStoreListener
in interface Store
public void removeStoreListener(StoreListener listener)
Store
removeStoreListener
in interface Store
public boolean put(Element e) throws CacheException
Store
put
in interface Store
CacheException
public void putAll(Collection<Element> elements) throws CacheException
Store
putAll
in interface Store
elements
- Collection of elements to be put in the store
CacheException
public boolean putWithWriter(Element element, CacheWriterManager writerManager) throws CacheException
Store
putWithWriter
in interface Store
CacheException
public Element get(Object key)
Store
get
in interface Store
public Element getQuiet(Object key)
Store
Element
from the Store, without updating statistics
getQuiet
in interface Store
public List getKeys()
Store
getKeys
in interface Store
Serializable
keyspublic Element remove(Object key)
Store
remove
in interface Store
public void removeAll(Collection<?> keys)
Store
removeAll
in interface Store
public Element removeWithWriter(Object key, CacheWriterManager writerManager) throws CacheException
Store
removeWithWriter
in interface Store
CacheException
public void removeAll() throws CacheException
Store
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
Store
putIfAbsent
in interface Store
element
- element to be added
NullPointerException
- if the element is null, or has a null keypublic Element removeElement(Element element, ElementValueComparator comparator) throws NullPointerException
Store
removeElement
in interface Store
element
- Element to be removedcomparator
- ElementValueComparator to use to compare elements
NullPointerException
- if the element is null, or has a null keypublic boolean replace(Element old, Element element, ElementValueComparator comparator) throws NullPointerException, IllegalArgumentException
Store
replace
in interface Store
old
- Element to be test againstelement
- Element to be cachedcomparator
- ElementValueComparator to use to compare elements
NullPointerException
- if the either Element is null or has a null key
IllegalArgumentException
- if the two Element keys are non-null but not equalpublic Element replace(Element element) throws NullPointerException
Store
replace
in interface Store
element
- Element to be cached
NullPointerException
- if the Element is null or has a null keypublic void dispose()
Store
dispose
in interface Store
public int getSize()
Store
getSize
in interface Store
public int getInMemorySize()
Store
getInMemorySize
in interface Store
public int getOffHeapSize()
Store
getOffHeapSize
in interface Store
public int getOnDiskSize()
Store
getOnDiskSize
in interface Store
public int getTerracottaClusteredSize()
Store
getTerracottaClusteredSize
in interface Store
public long getInMemorySizeInBytes()
Store
getInMemorySizeInBytes
in interface Store
public long getOffHeapSizeInBytes()
Store
getOffHeapSizeInBytes
in interface Store
public long getOnDiskSizeInBytes()
Store
getOnDiskSizeInBytes
in interface Store
public boolean hasAbortedSizeOf()
Store
hasAbortedSizeOf
in interface Store
public Status getStatus()
Store
getStatus
in interface Store
public boolean containsKey(Object key)
Store
containsKey
in interface Store
key
- The Element key
public boolean containsKeyOnDisk(Object key)
Store
containsKeyOnDisk
in interface Store
key
- The Element key
public boolean containsKeyOffHeap(Object key)
Store
containsKeyOffHeap
in interface Store
key
- The Element key
public boolean containsKeyInMemory(Object key)
Store
containsKeyInMemory
in interface Store
key
- The Element key
public void expireElements()
Store
expireElements
in interface Store
public void flush() throws IOException
Store
flush
in interface Store
IOException
- if any IO error occurspublic boolean bufferFull()
Store
bufferFull
in interface Store
public Policy getInMemoryEvictionPolicy()
getInMemoryEvictionPolicy
in interface Store
Store.setInMemoryEvictionPolicy(Policy)
public void setInMemoryEvictionPolicy(Policy policy)
Store
setInMemoryEvictionPolicy
in interface Store
policy
- the new policypublic Object getInternalContext()
Store
getInternalContext
in interface Store
public boolean isCacheCoherent()
Store
Store.isClusterCoherent()
(introduced since 2.0)
Use Store.isNodeCoherent()
to find out if the cache is coherent in the current node in the cluster
isCacheCoherent
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
Store
isClusterCoherent
in interface Store
TerracottaNotRunningException
public boolean isNodeCoherent() throws TerracottaNotRunningException
Store
isNodeCoherent
in interface Store
TerracottaNotRunningException
public void setNodeCoherent(boolean coherent) throws UnsupportedOperationException, TerracottaNotRunningException
Store
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
setNodeCoherent
in interface Store
coherent
- true transitions to coherent mode, false to incoherent mode
UnsupportedOperationException
- if this store does not support cache coherence, like RMI replication
TerracottaNotRunningException
public void waitUntilClusterCoherent() throws UnsupportedOperationException, TerracottaNotRunningException, InterruptedException
Store
waitUntilClusterCoherent
in interface Store
UnsupportedOperationException
- if this store does not support cache coherence, like RMI replication
InterruptedException
TerracottaNotRunningException
public Object getMBean()
Store
getMBean
in interface Store
public void setAttributeExtractors(Map<String,AttributeExtractor> extractors)
Store
setAttributeExtractors
in interface Store
public Results executeQuery(StoreQuery query) throws SearchException
Store
executeQuery
in interface Store
query
- query to execute
SearchException
public <S> Attribute<S> getSearchAttribute(String attributeName)
Store
getSearchAttribute
in interface Store
S
- type of the attributeattributeName
- the name of the attribute to retrieve
public Set<Attribute> getSearchAttributes()
getSearchAttributes
in interface Store
public Map<Object,Element> getAllQuiet(Collection<?> keys)
Store
getAllQuiet
in interface Store
keys
- a collection of keys to look for
public Map<Object,Element> getAll(Collection<?> keys)
Store
getAll
in interface Store
keys
- a collection of keys to look for
public void recalculateSize(Object key)
Store
recalculateSize
in interface Store
key
- the keypublic T getUnderlyingStore()
protected CopyStrategyHandler getCopyStrategyHandler()
CopyStrategyHandler
|
ehcache | |||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |