Uses of Class
net.sf.ehcache.Element

Packages that use Element

net.sf.ehcache	This package contains the public API for using ehcache.
net.sf.ehcache.config	This package contains the cache configuration code.
net.sf.ehcache.constructs	The constructs package builds on top of the core ehcache classes to create implementations for common caching patterns.
net.sf.ehcache.constructs.blocking	Doug Lea in his book Concurrent Programming in Java talks about concurrency support constructs.
net.sf.ehcache.constructs.classloader	ClassLoader contstructs package
net.sf.ehcache.constructs.eventual	Construct related to eventual operations
net.sf.ehcache.constructs.readthrough	Ehcache simple read through cache decorator package
net.sf.ehcache.constructs.refreshahead	Ehcache simple refresh-ahead cache decorator package
net.sf.ehcache.distribution	This package is for cache replication.
net.sf.ehcache.event	This package contains interfaces and classes for listening to events.
net.sf.ehcache.search.attribute	This package contains classes for ehcache search attributes
net.sf.ehcache.search.expression	This package contains classes for search expression types (ie.
net.sf.ehcache.search.impl	This package contains an implementation for Results.
net.sf.ehcache.store	Store package.
net.sf.ehcache.store.cachingtier	Contains the caching tier implementations
net.sf.ehcache.store.chm	CHM package.
net.sf.ehcache.store.compound	This package contains the main classes and interfaces for the new fully coherent combination disk and memory store for unclustered Ehcache.
net.sf.ehcache.store.disk	This package contains the disk store.
net.sf.ehcache.terracotta	This package contains the Terracotta integration functionalities.
net.sf.ehcache.transaction	This package contains classes for controlling cache operations for transactional use.
net.sf.ehcache.transaction.local	This package contains the local transactions subsystem.
net.sf.ehcache.transaction.xa	This package contains the functionality to provide XA support to a transactional Cache.
net.sf.ehcache.transaction.xa.commands	This package contains a representation of the queued commands which can be executed against a XA store.
net.sf.ehcache.writer	This package contains the cache writer functionalities.
net.sf.ehcache.writer.writebehind	This package contains the write behind functionalities.
net.sf.ehcache.writer.writebehind.operations	This package contains the operations for the write behind functionalities.
net.sf.ehcache.writer.writethrough	This package contains the write through functionalities.

Uses of Element in net.sf.ehcache

Methods in net.sf.ehcache that return Element

Element	Ehcache.get(Object key) Gets an element from the cache.
Element	Cache.get(Object key) Gets an element from the cache.
Element	Ehcache.get(Serializable key) Gets an element from the cache.
Element	Cache.get(Serializable key) Gets an element from the cache.
Element	CacheEntry.getElement() Retrieves the element of this cache entry.
Element	Ehcache.getQuiet(Object key) Gets an element from the cache, without updating Element statistics.
Element	Cache.getQuiet(Object key) Gets an element from the cache, without updating Element statistics.
Element	Ehcache.getQuiet(Serializable key) Gets an element from the cache, without updating Element statistics.
Element	Cache.getQuiet(Serializable key) Gets an element from the cache, without updating Element statistics.
Element	Ehcache.getWithLoader(Object key, CacheLoader loader, Object loaderArgument) This method will return, from the cache, the object associated with the argument "key".
Element	Cache.getWithLoader(Object key, CacheLoader loader, Object loaderArgument) This method will return, from the cache, the Element associated with the argument "key".
Element	Ehcache.putIfAbsent(Element element) Put an element in the cache if no element is currently mapped to the elements key.
Element	Cache.putIfAbsent(Element element) Put an element in the cache if no element is currently mapped to the elements key.
Element	Ehcache.putIfAbsent(Element element, boolean doNotNotifyCacheReplicators) Put an element in the cache if no element is currently mapped to the elements key.
Element	Cache.putIfAbsent(Element element, boolean doNotNotifyCacheReplicators) Put an element in the cache if no element is currently mapped to the elements key.
Element	Cache.removeAndReturnElement(Object key) Removes an Element from the Cache and returns it.
Element	Ehcache.replace(Element element) Replace the cached element only if an Element is currently cached for this key
Element	Cache.replace(Element element) Replace the cached element only if an Element is currently cached for this key

Methods in net.sf.ehcache that return types with arguments of type Element

Map<Object,Element>	Ehcache.getAll(Collection<?> keys) Gets all the elements from the cache for the keys provided.
Map<Object,Element>	Cache.getAll(Collection<?> keys) Gets all the elements from the cache for the keys provided.

Methods in net.sf.ehcache with parameters of type Element

static long	ElementIdHelper.getId(Element e) Get the element id
static boolean	ElementIdHelper.hasId(Element e) Is element id set?
boolean	Ehcache.isExpired(Element element) Checks whether this cache element has expired.
boolean	Cache.isExpired(Element element) Checks whether this cache element has expired.
void	Ehcache.put(Element element) Put an element in the cache.
void	Cache.put(Element element) Put an element in the cache.
void	Ehcache.put(Element element, boolean doNotNotifyCacheReplicators) Put an element in the cache.
void	Cache.put(Element element, boolean doNotNotifyCacheReplicators) Put an element in the cache.
Element	Ehcache.putIfAbsent(Element element) Put an element in the cache if no element is currently mapped to the elements key.
Element	Cache.putIfAbsent(Element element) Put an element in the cache if no element is currently mapped to the elements key.
Element	Ehcache.putIfAbsent(Element element, boolean doNotNotifyCacheReplicators) Put an element in the cache if no element is currently mapped to the elements key.
Element	Cache.putIfAbsent(Element element, boolean doNotNotifyCacheReplicators) Put an element in the cache if no element is currently mapped to the elements key.
void	Ehcache.putQuiet(Element element) Put an element in the cache, without updating statistics, or updating listeners.
void	Cache.putQuiet(Element element) Put an element in the cache, without updating statistics, or updating listeners.
void	Ehcache.putWithWriter(Element element) Put an element in the cache writing through a CacheWriter.
void	Cache.putWithWriter(Element element) Put an element in the cache writing through a CacheWriter.
boolean	Ehcache.removeElement(Element element) Remove the Element mapped to the key for the supplied element if the value of the supplied Element compares equal to the value of the cached Element.
boolean	Cache.removeElement(Element element) Remove the Element mapped to the key for the supplied element if the value of the supplied Element compares equal to the value of the cached Element.
Element	Ehcache.replace(Element element) Replace the cached element only if an Element is currently cached for this key
Element	Cache.replace(Element element) Replace the cached element only if an Element is currently cached for this key
boolean	Ehcache.replace(Element old, Element element) Replace the cached element only if the current Element is equal to the supplied old Element.
boolean	Cache.replace(Element old, Element element) Replace the cached element only if the current Element is equal to the supplied old Element.
static void	ElementIdHelper.setId(Element e, long id) Set the element id

Method parameters in net.sf.ehcache with type arguments of type Element

void	Ehcache.putAll(Collection<Element> elements) Puts a collection of elements in to the cache.
void	Cache.putAll(Collection<Element> elements) Puts a collection of elements in to the cache.

Constructors in net.sf.ehcache with parameters of type Element

CacheEntry(Object key, Element element)
Creates a new cache entry.

Uses of Element in net.sf.ehcache.config

Methods in net.sf.ehcache.config that return types with arguments of type Element

ReadWriteCopyStrategy<Element>	CacheConfiguration.getCopyStrategy() Getter to the configured ReadWriteCopyStrategy.
ReadWriteCopyStrategy<Element>	CopyStrategyConfiguration.getCopyStrategyInstance(ClassLoader loader) Get (and potentially) instantiate the instance

Method parameters in net.sf.ehcache.config with type arguments of type Element

void	CopyStrategyConfiguration.setCopyStrategyInstance(ReadWriteCopyStrategy<Element> copyStrategy) Sets the CopyStrategy instance to use

Uses of Element in net.sf.ehcache.constructs

Methods in net.sf.ehcache.constructs that return Element

Element	EhcacheDecoratorAdapter.get(Object key) Gets an element from the cache.
Element	EhcacheDecoratorAdapter.get(Serializable key) Gets an element from the cache.
Element	EhcacheDecoratorAdapter.getQuiet(Object key) Gets an element from the cache, without updating Element statistics.
Element	EhcacheDecoratorAdapter.getQuiet(Serializable key) Gets an element from the cache, without updating Element statistics.
Element	EhcacheDecoratorAdapter.getWithLoader(Object key, CacheLoader loader, Object loaderArgument) This method will return, from the cache, the object associated with the argument "key".
Element	EhcacheDecoratorAdapter.putIfAbsent(Element element) Put an element in the cache if no element is currently mapped to the elements key.
Element	EhcacheDecoratorAdapter.putIfAbsent(Element element, boolean doNotNotifyCacheReplicators)
Element	EhcacheDecoratorAdapter.removeAndReturnElement(Object key) Removes and returns the element associated with the key
Element	EhcacheDecoratorAdapter.replace(Element element) Replace the cached element only if an Element is currently cached for this key

Methods in net.sf.ehcache.constructs that return types with arguments of type Element

Map<Object,Element>

EhcacheDecoratorAdapter.getAll(Collection<?> keys) Gets all the elements from the cache for the keys provided.

Methods in net.sf.ehcache.constructs with parameters of type Element

boolean	EhcacheDecoratorAdapter.isExpired(Element element) Checks whether this cache element has expired.
void	EhcacheDecoratorAdapter.put(Element element) Put an element in the cache.
void	EhcacheDecoratorAdapter.put(Element element, boolean doNotNotifyCacheReplicators) Put an element in the cache.
Element	EhcacheDecoratorAdapter.putIfAbsent(Element element) Put an element in the cache if no element is currently mapped to the elements key.
Element	EhcacheDecoratorAdapter.putIfAbsent(Element element, boolean doNotNotifyCacheReplicators)
void	EhcacheDecoratorAdapter.putQuiet(Element element) Put an element in the cache, without updating statistics, or updating listeners.
void	EhcacheDecoratorAdapter.putWithWriter(Element element) Put an element in the cache writing through a CacheWriter.
boolean	EhcacheDecoratorAdapter.removeElement(Element element) Remove the Element mapped to the key for the supplied element if the value of the supplied Element compares equal to the value of the cached Element.
Element	EhcacheDecoratorAdapter.replace(Element element) Replace the cached element only if an Element is currently cached for this key
boolean	EhcacheDecoratorAdapter.replace(Element old, Element element) Replace the cached element only if the current Element is equal to the supplied old Element.

Method parameters in net.sf.ehcache.constructs with type arguments of type Element

void	EhcacheDecoratorAdapter.putAll(Collection<Element> elements) Puts a collection of elements in to the cache.

Uses of Element in net.sf.ehcache.constructs.blocking

Methods in net.sf.ehcache.constructs.blocking that return Element

Element	UpdatingSelfPopulatingCache.get(Object key) Looks up an object.
Element	SelfPopulatingCache.get(Object key) Looks up an entry.
Element	BlockingCache.get(Object key) Looks up an entry.
Element	BlockingCache.get(Serializable key) Gets an element from the cache.
Element	BlockingCache.getWithLoader(Object key, CacheLoader loader, Object loaderArgument) This method is not appropriate to use with BlockingCache.
protected static Element	SelfPopulatingCache.makeAndCheckElement(Object key, Object value) Both CacheEntryFactory can return an Element rather than just a regular value this method test this, making a fresh Element otherwise.
Element	BlockingCache.putIfAbsent(Element element)
Element	BlockingCache.putIfAbsent(Element element, boolean doNotNotifyCacheReplicators)
Element	SelfPopulatingCache.refresh(Object key) Refresh a single element.
Element	SelfPopulatingCache.refresh(Object key, boolean quiet) Refresh a single element.
protected Element	SelfPopulatingCache.refreshElement(Element element, Ehcache backingCache, boolean quiet) Refresh a single element.

Methods in net.sf.ehcache.constructs.blocking with parameters of type Element

void	BlockingCache.put(Element element) Adds an entry and unlocks it
void	BlockingCache.put(Element element, boolean doNotNotifyCacheReplicators)
Element	BlockingCache.putIfAbsent(Element element)
Element	BlockingCache.putIfAbsent(Element element, boolean doNotNotifyCacheReplicators)
void	BlockingCache.putQuiet(Element element)
void	BlockingCache.putWithWriter(Element element)
protected void	SelfPopulatingCache.refreshElement(Element element, Ehcache backingCache) Refresh a single element.
protected Element	SelfPopulatingCache.refreshElement(Element element, Ehcache backingCache, boolean quiet) Refresh a single element.

Uses of Element in net.sf.ehcache.constructs.classloader

Methods in net.sf.ehcache.constructs.classloader that return Element

Element	ClassLoaderAwareCache.get(Object arg0) Gets an element from the cache.
Element	ClassLoaderAwareCache.get(Serializable arg0) Gets an element from the cache.
Element	ClassLoaderAwareCache.getQuiet(Object arg0) Gets an element from the cache, without updating Element statistics.
Element	ClassLoaderAwareCache.getQuiet(Serializable arg0) Gets an element from the cache, without updating Element statistics.
Element	ClassLoaderAwareCache.getWithLoader(Object arg0, CacheLoader arg1, Object arg2) This method will return, from the cache, the object associated with the argument "key".
Element	ClassLoaderAwareCache.putIfAbsent(Element arg0) Put an element in the cache if no element is currently mapped to the elements key.
Element	ClassLoaderAwareCache.putIfAbsent(Element arg0, boolean arg1) Put an element in the cache if no element is currently mapped to the elements key.
Element	InternalClassLoaderAwareCache.removeAndReturnElement(Object arg0) Removes and returns the element associated with the key
Element	ClassLoaderAwareCache.replace(Element arg0) Replace the cached element only if an Element is currently cached for this key

Methods in net.sf.ehcache.constructs.classloader with parameters of type Element

boolean	ClassLoaderAwareCache.isExpired(Element arg0) Checks whether this cache element has expired.
void	ClassLoaderAwareCache.put(Element arg0) Put an element in the cache.
void	ClassLoaderAwareCache.put(Element arg0, boolean arg1) Put an element in the cache.
Element	ClassLoaderAwareCache.putIfAbsent(Element arg0) Put an element in the cache if no element is currently mapped to the elements key.
Element	ClassLoaderAwareCache.putIfAbsent(Element arg0, boolean arg1) Put an element in the cache if no element is currently mapped to the elements key.
void	ClassLoaderAwareCache.putQuiet(Element arg0) Put an element in the cache, without updating statistics, or updating listeners.
void	ClassLoaderAwareCache.putWithWriter(Element arg0) Put an element in the cache writing through a CacheWriter.
boolean	ClassLoaderAwareCache.removeElement(Element arg0) Remove the Element mapped to the key for the supplied element if the value of the supplied Element compares equal to the value of the cached Element.
Element	ClassLoaderAwareCache.replace(Element arg0) Replace the cached element only if an Element is currently cached for this key
boolean	ClassLoaderAwareCache.replace(Element arg0, Element arg1) Replace the cached element only if the current Element is equal to the supplied old Element.

Uses of Element in net.sf.ehcache.constructs.eventual

Methods in net.sf.ehcache.constructs.eventual that return Element

Element	StronglyConsistentCacheAccessor.get(Object key)
Element	StronglyConsistentCacheAccessor.get(Serializable key)
Element	StronglyConsistentCacheAccessor.getQuiet(Object key)
Element	StronglyConsistentCacheAccessor.getQuiet(Serializable key)
Element	StronglyConsistentCacheAccessor.getWithLoader(Object key, CacheLoader loader, Object loaderArgument)
Element	StronglyConsistentCacheAccessor.putIfAbsent(Element element)
Element	StronglyConsistentCacheAccessor.putIfAbsent(Element element, boolean doNotNotifyCacheReplicators)
Element	StronglyConsistentCacheAccessor.removeAndReturnElement(Object key)
Element	StronglyConsistentCacheAccessor.replace(Element element)

Methods in net.sf.ehcache.constructs.eventual that return types with arguments of type Element

Map<Object,Element>

StronglyConsistentCacheAccessor.getAll(Collection<?> keys)

Methods in net.sf.ehcache.constructs.eventual with parameters of type Element

void	StronglyConsistentCacheAccessor.put(Element element)
void	StronglyConsistentCacheAccessor.put(Element element, boolean doNotNotifyCacheReplicators)
Element	StronglyConsistentCacheAccessor.putIfAbsent(Element element)
Element	StronglyConsistentCacheAccessor.putIfAbsent(Element element, boolean doNotNotifyCacheReplicators)
void	StronglyConsistentCacheAccessor.putQuiet(Element element)
void	StronglyConsistentCacheAccessor.putWithWriter(Element element)
boolean	StronglyConsistentCacheAccessor.removeElement(Element element)
Element	StronglyConsistentCacheAccessor.replace(Element element)
boolean	StronglyConsistentCacheAccessor.replace(Element old, Element element)

Method parameters in net.sf.ehcache.constructs.eventual with type arguments of type Element

void	StronglyConsistentCacheAccessor.putAll(Collection<Element> elements)

Uses of Element in net.sf.ehcache.constructs.readthrough

Methods in net.sf.ehcache.constructs.readthrough that return Element

Element	ReadThroughCache.get(Object key)
Element	ReadThroughCache.get(Serializable key)

Uses of Element in net.sf.ehcache.constructs.refreshahead

Methods in net.sf.ehcache.constructs.refreshahead that return Element

Element	RefreshAheadCache.get(Object key)
Element	RefreshAheadCache.get(Serializable key)

Uses of Element in net.sf.ehcache.distribution

Methods in net.sf.ehcache.distribution that return Element

Element	RmiEventMessage.getElement()
Element	LegacyEventMessage.getElement()
Element	TransactionalRMICachePeer.getQuiet(Serializable key)
Element	RMICachePeer.getQuiet(Serializable key) Gets an element from the cache, without updating Element statistics.
Element	CachePeer.getQuiet(Serializable key) Gets an element from the cache, without updating Element statistics.

Methods in net.sf.ehcache.distribution with parameters of type Element

void	RMISynchronousCacheReplicator.notifyElementEvicted(Ehcache cache, Element element) Called immediately after an element is evicted from the cache.
void	RMISynchronousCacheReplicator.notifyElementExpired(Ehcache cache, Element element) Called immediately after an element is found to be expired.
void	RMISynchronousCacheReplicator.notifyElementPut(Ehcache cache, Element element) Called immediately after an element has been put into the cache.
void	RMIAsynchronousCacheReplicator.notifyElementPut(Ehcache cache, Element element) Called immediately after an element has been put into the cache.
void	RMISynchronousCacheReplicator.notifyElementRemoved(Ehcache cache, Element element) Called immediately after an attempt to remove an element.
void	RMIAsynchronousCacheReplicator.notifyElementRemoved(Ehcache cache, Element element) Called immediately after an attempt to remove an element.
void	RMISynchronousCacheReplicator.notifyElementUpdated(Ehcache cache, Element element) Called immediately after an element has been put into the cache and the element already existed in the cache.
void	RMIAsynchronousCacheReplicator.notifyElementUpdated(Ehcache cache, Element element) Called immediately after an element has been put into the cache and the element already existed in the cache.
void	TransactionalRMICachePeer.put(Element element)
void	RMICachePeer.put(Element element) Puts an Element into the underlying cache without notifying listeners or updating statistics.
void	CachePeer.put(Element element) Put an element in the cache.
protected static void	RMISynchronousCacheReplicator.replicatePutNotification(Ehcache cache, Element element) Does the actual RMI remote call.

Constructors in net.sf.ehcache.distribution with parameters of type Element

LegacyEventMessage(int event, Serializable key, Element element)
Full constructor.

RmiEventMessage(Ehcache cache, RmiEventMessage.RmiEventType type, Serializable key, Element element)
Full constructor.

Uses of Element in net.sf.ehcache.event

Methods in net.sf.ehcache.event that return Element

Element

RegisteredEventListeners.ElementCreationCallback.createElement(ClassLoader loader) Materialize the relevant element in the given classloader

Methods in net.sf.ehcache.event with parameters of type Element

void	TerracottaCacheEventReplication.notifyElementEvicted(Ehcache cache, Element element) Called immediately after an element is evicted from the cache.
void	CacheEventListenerAdapter.notifyElementEvicted(Ehcache cache, Element element) Called immediately after an element is evicted from the cache.
void	CacheEventListener.notifyElementEvicted(Ehcache cache, Element element) Called immediately after an element is evicted from the cache.
void	RegisteredEventListeners.notifyElementEvicted(Element element, boolean remoteEvent) Notifies all registered listeners, in no guaranteed order, that an element has been evicted from the cache
void	TerracottaCacheEventReplication.notifyElementExpired(Ehcache cache, Element element) Called immediately after an element is found to be expired.
void	CacheEventListenerAdapter.notifyElementExpired(Ehcache cache, Element element) Called immediately after an element is found to be expired.
void	CacheEventListener.notifyElementExpired(Ehcache cache, Element element) Called immediately after an element is found to be expired.
void	RegisteredEventListeners.notifyElementExpiry(Element element, boolean remoteEvent) Notifies all registered listeners, in no guaranteed order, that an element has expired
void	TerracottaCacheEventReplication.notifyElementPut(Ehcache cache, Element element) Called immediately after an element has been put into the cache.
void	CacheEventListenerAdapter.notifyElementPut(Ehcache cache, Element element) Called immediately after an element has been put into the cache.
void	CacheEventListener.notifyElementPut(Ehcache cache, Element element) Called immediately after an element has been put into the cache.
void	RegisteredEventListeners.notifyElementPut(Element element, boolean remoteEvent) Notifies all registered listeners, in no guaranteed order, that an element was put into the cache
void	RegisteredEventListeners.notifyElementPutOrdered(Element element) Notifies InternalCacheEventListeners, when a put happens
void	TerracottaCacheEventReplication.notifyElementRemoved(Ehcache cache, Element element) Called immediately after an attempt to remove an element.
void	CacheEventListenerAdapter.notifyElementRemoved(Ehcache cache, Element element) Called immediately after an attempt to remove an element.
void	CacheEventListener.notifyElementRemoved(Ehcache cache, Element element) Called immediately after an attempt to remove an element.
void	RegisteredEventListeners.notifyElementRemoved(Element element, boolean remoteEvent) Notifies all registered listeners, in no guaranteed order, that an element was removed
void	RegisteredEventListeners.notifyElementRemovedOrdered(Element element) Notifies InternalCacheEventListeners, when a remove happens
void	TerracottaCacheEventReplication.notifyElementUpdated(Ehcache cache, Element element) Called immediately after an element has been put into the cache and the element already existed in the cache.
void	CacheEventListenerAdapter.notifyElementUpdated(Ehcache cache, Element element) Called immediately after an element has been put into the cache and the element already existed in the cache.
void	CacheEventListener.notifyElementUpdated(Ehcache cache, Element element) Called immediately after an element has been put into the cache and the element already existed in the cache.
void	RegisteredEventListeners.notifyElementUpdated(Element element, boolean remoteEvent) Notifies all registered listeners, in no guaranteed order, that an element in the cache was updated
void	RegisteredEventListeners.notifyElementUpdatedOrdered(Element oldElement, Element newElement) Notifies InternalCacheEventListeners, when an update happens

Uses of Element in net.sf.ehcache.search.attribute

Methods in net.sf.ehcache.search.attribute with parameters of type Element

Object	ValueObjectAttributeExtractor.attributeFor(Element element, String attributeName) Extract the attribute value.
Object	ReflectionAttributeExtractor.attributeFor(Element e, String attributeName) Evaluate the expression for the given element
Object	KeyObjectAttributeExtractor.attributeFor(Element element, String attributeName) Extract the attribute value.
Object	JavaBeanAttributeExtractor.attributeFor(Element element, String attributeName) Extract the attribute value.
Object	AttributeExtractor.attributeFor(Element element, String attributeName) Extract the attribute value.
<T> Map<String,T>	DynamicAttributesExtractor.attributesFor(Element element) Given a particular cache element, returns a map from attribute names, to their respective values to use for indexing.

Uses of Element in net.sf.ehcache.search.expression

Methods in net.sf.ehcache.search.expression with parameters of type Element

boolean	Or.execute(Element e, Map<String,AttributeExtractor> attributeExtractors) Test this criteria against a cache element
boolean	NotNull.execute(Element e, Map<String,AttributeExtractor> attributeExtractors)
boolean	NotILike.execute(Element e, Map<String,AttributeExtractor> attributeExtractors)
boolean	NotEqualTo.execute(Element e, Map<String,AttributeExtractor> attributeExtractors) Test this criteria against a cache element
boolean	Not.execute(Element e, Map<String,AttributeExtractor> attributeExtractors) Test this criteria against a cache element
boolean	IsNull.execute(Element e, Map<String,AttributeExtractor> attributeExtractors)
boolean	InCollection.execute(Element e, Map<String,AttributeExtractor> attributeExtractors) Test this criteria against a cache element
boolean	ILike.execute(Element e, Map<String,AttributeExtractor> attributeExtractors) Test this criteria against a cache element
boolean	EqualTo.execute(Element e, Map<String,AttributeExtractor> attributeExtractors) Test this criteria against a cache element
boolean	Criteria.execute(Element element, Map<String,AttributeExtractor> attributeExtractors) Test this criteria against a cache element
boolean	ComparableValue.execute(Element e, Map<String,AttributeExtractor> attributeExtractors) Test this criteria against a cache element
boolean	And.execute(Element e, Map<String,AttributeExtractor> attributeExtractors) Test this criteria against a cache element
boolean	AlwaysMatch.execute(Element e, Map<String,AttributeExtractor> attributeExtractors) Test this criteria against a cache element

Uses of Element in net.sf.ehcache.search.impl

Methods in net.sf.ehcache.search.impl with parameters of type Element

static Map<String,? extends Object>	DynamicSearchChecker.getSearchAttributes(Element e, Set<String> reservedAttrs, DynamicAttributesExtractor extractor) Extracts dynamically indexed search attributes from cache element using provided extractor, validating against reserved set of attribute names (provided by Ehcache search config)
void	SearchManager.put(String cacheName, int segmentId, Element element, byte[] serializedKey, Map<String,AttributeExtractor> extractors, DynamicAttributesExtractor dynamicIndexer) Notify an element added to a segment of a given cache

Uses of Element in net.sf.ehcache.store

Methods in net.sf.ehcache.store that return Element

Element	TxCopyStrategyHandler.copyElementForReadIfNeeded(Element element)
Element	CopyStrategyHandler.copyElementForReadIfNeeded(Element element) Perform copy on read on an element if configured
protected Element	MemoryStore.expireElement(Object key) Evicts the element for the given key, if it exists and is expired
Element	AuthoritativeTier.fault(Object key, boolean updateStats) Marks the entry as not evictable and returns it atomically
Element	Store.get(Object key) Gets an item from the cache.
Element	MemoryStore.get(Object key) Gets an item from the cache.
Element	LruMemoryStore.get(Object key) Gets an item from the cache.
Element	LegacyStoreWrapper.get(Object key) Gets an item from the cache.
Element	ElementIdAssigningStore.get(Object key) Gets an item from the cache.
Element	CacheStore.get(Object key)
Element	TxCopyingCacheStore.getOldElement(Object key) Gets an element from the store, choosing the old value in case the element is currently mutated inside a transaction.
Element	Store.getQuiet(Object key) Gets an Element from the Store, without updating statistics
Element	MemoryStore.getQuiet(Object key) Gets an item from the cache, without updating statistics.
Element	LruMemoryStore.getQuiet(Object key) Gets an item from the cache, without updating statistics.
Element	LegacyStoreWrapper.getQuiet(Object key) Gets an Element from the Store, without updating statistics
Element	ElementIdAssigningStore.getQuiet(Object key) Gets an Element from the Store, without updating statistics
Element	CacheStore.getQuiet(Object key)
Element	Store.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
Element	MemoryStore.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
Element	LruMemoryStore.putIfAbsent(Element element) Unsupported in LruMemoryStore
Element	LegacyStoreWrapper.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
Element	ElementIdAssigningStore.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
Element	CacheStore.putIfAbsent(Element element)
Element	Store.remove(Object key) Removes an item from the cache.
Element	MemoryStore.remove(Object key) Removes an Element from the store.
Element	LruMemoryStore.remove(Object key) Removes an Element from the store.
Element	LegacyStoreWrapper.remove(Object key) Removes an item from the cache.
Element	ElementIdAssigningStore.remove(Object key) Removes an item from the cache.
Element	CacheStore.remove(Object key)
Element	Store.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.
Element	MemoryStore.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.
Element	LruMemoryStore.removeElement(Element element, ElementValueComparator comparator) Unsupported in LruMemoryStore
Element	LegacyStoreWrapper.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.
Element	ElementIdAssigningStore.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.
Element	CacheStore.removeElement(Element element, ElementValueComparator comparator)
Element	Store.removeWithWriter(Object key, CacheWriterManager writerManager) Removes an item from the store and the cache writer manager in an atomic operation.
Element	MemoryStore.removeWithWriter(Object key, CacheWriterManager writerManager) Removes an item from the store and the cache writer manager in an atomic operation.
Element	LruMemoryStore.removeWithWriter(Object key, CacheWriterManager writerManager) Removes an item from the store and the cache writer manager in an atomic operation.
Element	LegacyStoreWrapper.removeWithWriter(Object key, CacheWriterManager writerManager) Removes an item from the store and the cache writer manager in an atomic operation.
Element	ElementIdAssigningStore.removeWithWriter(Object key, CacheWriterManager writerManager) Removes an item from the store and the cache writer manager in an atomic operation.
Element	CacheStore.removeWithWriter(Object key, CacheWriterManager writerManager)
Element	Store.replace(Element element) Replace the cached element only if an Element is currently cached for this key
Element	MemoryStore.replace(Element element) Replace the cached element only if an Element is currently cached for this key
Element	LruMemoryStore.replace(Element element) Unsupported in LruMemoryStore
Element	LegacyStoreWrapper.replace(Element element) Replace the cached element only if an Element is currently cached for this key
Element	ElementIdAssigningStore.replace(Element element) Replace the cached element only if an Element is currently cached for this key
Element	CacheStore.replace(Element element)
Element	Policy.selectedBasedOnPolicy(Element[] sampledElements, Element justAdded) Finds the best eviction candidate based on the sampled elements.
Element	AbstractPolicy.selectedBasedOnPolicy(Element[] sampledElements, Element justAdded) Finds the best eviction candidate based on the sampled elements.
Element	TerracottaTransactionalCopyingCacheStore.unsafeGet(Object key)
Element	TerracottaStore.unsafeGet(Object key) Returns the local value associated with the key.

Methods in net.sf.ehcache.store that return types with arguments of type Element

Collection<Element>	MemoryStore.elementSet() Get a collection of the elements in this store
Map<Object,Element>	Store.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>	ElementIdAssigningStore.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>	CacheStore.getAll(Collection<?> keys)
Map<Object,Element>	AbstractStore.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>	Store.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
Map<Object,Element>	ElementIdAssigningStore.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
Map<Object,Element>	CacheStore.getAllQuiet(Collection<?> keys)
Map<Object,Element>	AbstractStore.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

Methods in net.sf.ehcache.store with parameters of type Element

boolean	MemoryStore.canPutWithoutEvicting(Element element) Check if adding an element won't provoke an eviction.
boolean	Policy.compare(Element element1, Element element2) Compares the desirableness for eviction of two elements
boolean	LruPolicy.compare(Element element1, Element element2) Compares the desirableness for eviction of two elements Compares hit counts.
boolean	LfuPolicy.compare(Element element1, Element element2) Compares the desirableness for eviction of two elements Compares hit counts.
boolean	FifoPolicy.compare(Element element1, Element element2) Compares the desirableness for eviction of two elements Compares hit counts.
Element	TxCopyStrategyHandler.copyElementForReadIfNeeded(Element element)
Element	CopyStrategyHandler.copyElementForReadIfNeeded(Element element) Perform copy on read on an element if configured
protected void	LruMemoryStore.doPut(Element element) Allow specialised actions over adding the element to the map.
boolean	ElementValueComparator.equals(Element e1, Element e2) Compare the two elements.
boolean	DefaultElementValueComparator.equals(Element e1, Element e2) Compare the two elements.
protected boolean	MemoryStore.evict(Element element) Evicts the element from the store
protected void	LruMemoryStore.evict(Element element) Evict the Element.
boolean	AuthoritativeTier.flush(Element element) This marks the entry as evictable again and updates relevant access stats
protected void	MemoryStore.notifyDirectEviction(Element element) Called when an element is evicted even before it could be installed inside the store
protected void	LruMemoryStore.notifyExpiry(Element element) Before eviction elements are checked.
boolean	Store.put(Element element) Puts an item into the store.
boolean	MemoryStore.put(Element element) Puts an item in the store.
boolean	LruMemoryStore.put(Element element) Puts an item in the cache.
boolean	LegacyStoreWrapper.put(Element element) Puts an item into the store.
boolean	ElementIdAssigningStore.put(Element element) Puts an item into the store.
boolean	CacheStore.put(Element element)
void	BruteForceSearchManager.put(String cacheName, int segmentId, Element element, byte[] key, Map<String,AttributeExtractor> extractors, DynamicAttributesExtractor dynamicIndexer)
boolean	AuthoritativeTier.putFaulted(Element element) Deprecated.
Element	Store.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
Element	MemoryStore.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
Element	LruMemoryStore.putIfAbsent(Element element) Unsupported in LruMemoryStore
Element	LegacyStoreWrapper.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
Element	ElementIdAssigningStore.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
Element	CacheStore.putIfAbsent(Element element)
boolean	Store.putWithWriter(Element element, CacheWriterManager writerManager) Puts an item into the store and the cache writer manager in an atomic operation
boolean	MemoryStore.putWithWriter(Element element, CacheWriterManager writerManager) Puts an item into the store and the cache writer manager in an atomic operation
boolean	LruMemoryStore.putWithWriter(Element element, CacheWriterManager writerManager) Puts an item into the store and the cache writer manager in an atomic operation
boolean	LegacyStoreWrapper.putWithWriter(Element element, CacheWriterManager writerManager) Puts an item into the store and the cache writer manager in an atomic operation
boolean	ElementIdAssigningStore.putWithWriter(Element element, CacheWriterManager writerManager) Puts an item into the store and the cache writer manager in an atomic operation
boolean	CacheStore.putWithWriter(Element element, CacheWriterManager writerManager)
Element	Store.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.
Element	MemoryStore.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.
Element	LruMemoryStore.removeElement(Element element, ElementValueComparator comparator) Unsupported in LruMemoryStore
Element	LegacyStoreWrapper.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.
Element	ElementIdAssigningStore.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.
Element	CacheStore.removeElement(Element element, ElementValueComparator comparator)
Element	Store.replace(Element element) Replace the cached element only if an Element is currently cached for this key
Element	MemoryStore.replace(Element element) Replace the cached element only if an Element is currently cached for this key
Element	LruMemoryStore.replace(Element element) Unsupported in LruMemoryStore
Element	LegacyStoreWrapper.replace(Element element) Replace the cached element only if an Element is currently cached for this key
Element	ElementIdAssigningStore.replace(Element element) Replace the cached element only if an Element is currently cached for this key
Element	CacheStore.replace(Element element)
boolean	Store.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.
boolean	MemoryStore.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.
boolean	LruMemoryStore.replace(Element old, Element element, ElementValueComparator comparator) Unsupported in LruMemoryStore
boolean	LegacyStoreWrapper.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.
boolean	ElementIdAssigningStore.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.
boolean	CacheStore.replace(Element old, Element element, ElementValueComparator comparator)
Element	Policy.selectedBasedOnPolicy(Element[] sampledElements, Element justAdded) Finds the best eviction candidate based on the sampled elements.
Element	Policy.selectedBasedOnPolicy(Element[] sampledElements, Element justAdded) Finds the best eviction candidate based on the sampled elements.
Element	AbstractPolicy.selectedBasedOnPolicy(Element[] sampledElements, Element justAdded) Finds the best eviction candidate based on the sampled elements.
Element	AbstractPolicy.selectedBasedOnPolicy(Element[] sampledElements, Element justAdded) Finds the best eviction candidate based on the sampled elements.
protected void	LruMemoryStore.spoolToDisk(Element element) Puts the element in the DiskStore.

Method parameters in net.sf.ehcache.store with type arguments of type Element

void	Store.putAll(Collection<Element> elements) Puts a collection of elements into the store.
void	ElementIdAssigningStore.putAll(Collection<Element> elements) Puts a collection of elements into the store.
void	CacheStore.putAll(Collection<Element> elements)
void	AbstractStore.putAll(Collection<Element> elements) Puts a collection of elements into the store.

Constructor parameters in net.sf.ehcache.store with type arguments of type Element

CacheStore(CachingTier<Object,Element> cache, AuthoritativeTier authority)
Constructor :P

CacheStore(CachingTier<Object,Element> cache, AuthoritativeTier authority, CacheConfiguration cacheConfiguration)
Deprecated.

CopyingCacheStore(T store, boolean copyOnRead, boolean copyOnWrite, ReadWriteCopyStrategy<Element> copyStrategyInstance, ClassLoader loader)
Creates a copying instance of store, that wraps the actual storage

CopyStrategyHandler(boolean copyOnRead, boolean copyOnWrite, ReadWriteCopyStrategy<Element> copyStrategy, ClassLoader loader)
Creates a CopyStrategyHandler based on the copy configuration

TerracottaTransactionalCopyingCacheStore(TerracottaStore store, ReadWriteCopyStrategy<Element> copyStrategyInstance, ClassLoader loader)
Creates a terracotta copying instance of store, that wraps the actual storage

TxCopyingCacheStore(T store, boolean copyOnRead, boolean copyOnWrite, ReadWriteCopyStrategy<Element> copyStrategyInstance, ClassLoader loader)
Creates a copying instance of store, that wraps the actual storage

TxCopyStrategyHandler(boolean copyOnRead, boolean copyOnWrite, ReadWriteCopyStrategy<Element> copyStrategy, ClassLoader loader)
Creates a TxCopyStrategyHandler based on the copy configuration

Uses of Element in net.sf.ehcache.store.cachingtier

Methods in net.sf.ehcache.store.cachingtier that return types with arguments of type Element

static OnHeapCachingTier<Object,Element>

OnHeapCachingTier.createOnHeapCache(Ehcache cache, Pool onHeapPool) Factory method

Uses of Element in net.sf.ehcache.store.chm

Fields in net.sf.ehcache.store.chm declared as Element

Element

SelectableConcurrentHashMap.HashEntry.value

Methods in net.sf.ehcache.store.chm that return Element

Element	SelectableConcurrentHashMap.get(Object key)
Element[]	SelectableConcurrentHashMap.getRandomValues(int size, Object keyHint)
Element	SelectableConcurrentHashMap.put(Object key, Element element, long sizeOf)
protected Element	SelectableConcurrentHashMap.Segment.put(Object key, int hash, Element value, long sizeOf, boolean onlyIfAbsent, boolean fire)
Element	SelectableConcurrentHashMap.putIfAbsent(Object key, Element element, long sizeOf)
Element	SelectableConcurrentHashMap.remove(Object key)

Methods in net.sf.ehcache.store.chm that return types with arguments of type Element

Set<Map.Entry<Object,Element>>	SelectableConcurrentHashMap.entrySet()
Collection<Element>	SelectableConcurrentHashMap.values()

Methods in net.sf.ehcache.store.chm with parameters of type Element

protected SelectableConcurrentHashMap.HashEntry	SelectableConcurrentHashMap.Segment.createHashEntry(Object key, int hash, SelectableConcurrentHashMap.HashEntry next, Element value, long sizeOf)
protected void	SelectableConcurrentHashMap.Segment.postInstall(Object key, Element value)
Element	SelectableConcurrentHashMap.put(Object key, Element element, long sizeOf)
protected Element	SelectableConcurrentHashMap.Segment.put(Object key, int hash, Element value, long sizeOf, boolean onlyIfAbsent, boolean fire)
Element	SelectableConcurrentHashMap.putIfAbsent(Object key, Element element, long sizeOf)
Object	SelectableConcurrentHashMap.storedObject(Element e) Return an object of the kind which will be stored when the element is going to be inserted

Constructors in net.sf.ehcache.store.chm with parameters of type Element

SelectableConcurrentHashMap.HashEntry(Object key, int hash, SelectableConcurrentHashMap.HashEntry next, Element value, long sizeOf)

Uses of Element in net.sf.ehcache.store.compound

Methods in net.sf.ehcache.store.compound that return Element

Element	SerializationCopyStrategy.copyForRead(Element storedValue, ClassLoader loader)
Element	ReadWriteSerializationCopyStrategy.copyForRead(Element storedValue, ClassLoader loader)
Element	NullReadWriteCopyStrategy.copyForRead(Element storedValue, ClassLoader loader) Reconstruct an object from its storage-ready copy.
Element	LegacyCopyStrategyAdapter.copyForRead(Element storedValue, ClassLoader loader) Reconstruct an object from its storage-ready copy.
Element	ImmutableValueElementCopyStrategy.copyForRead(Element storedValue, ClassLoader loader)
Element	SerializationCopyStrategy.copyForWrite(Element value, ClassLoader loader)
Element	ReadWriteSerializationCopyStrategy.copyForWrite(Element value, ClassLoader loader)
Element	NullReadWriteCopyStrategy.copyForWrite(Element value, ClassLoader loader) Deep copies some object and returns an internal storage-ready copy
Element	LegacyCopyStrategyAdapter.copyForWrite(Element value, ClassLoader loader) Deep copies some object and returns an internal storage-ready copy
Element	ImmutableValueElementCopyStrategy.copyForWrite(Element value, ClassLoader loader)
Element	ReadWriteSerializationCopyStrategy.duplicateElementWithNewValue(Element element, Object newValue) Make a duplicate of an element but using the specified value

Methods in net.sf.ehcache.store.compound with parameters of type Element

Element	SerializationCopyStrategy.copyForRead(Element storedValue, ClassLoader loader)
Element	ReadWriteSerializationCopyStrategy.copyForRead(Element storedValue, ClassLoader loader)
Element	NullReadWriteCopyStrategy.copyForRead(Element storedValue, ClassLoader loader) Reconstruct an object from its storage-ready copy.
Element	LegacyCopyStrategyAdapter.copyForRead(Element storedValue, ClassLoader loader) Reconstruct an object from its storage-ready copy.
Element	ImmutableValueElementCopyStrategy.copyForRead(Element storedValue, ClassLoader loader)
Element	SerializationCopyStrategy.copyForWrite(Element value, ClassLoader loader)
Element	ReadWriteSerializationCopyStrategy.copyForWrite(Element value, ClassLoader loader)
Element	NullReadWriteCopyStrategy.copyForWrite(Element value, ClassLoader loader) Deep copies some object and returns an internal storage-ready copy
Element	LegacyCopyStrategyAdapter.copyForWrite(Element value, ClassLoader loader) Deep copies some object and returns an internal storage-ready copy
Element	ImmutableValueElementCopyStrategy.copyForWrite(Element value, ClassLoader loader)
Element	ReadWriteSerializationCopyStrategy.duplicateElementWithNewValue(Element element, Object newValue) Make a duplicate of an element but using the specified value

Uses of Element in net.sf.ehcache.store.disk

Methods in net.sf.ehcache.store.disk that return Element

Element	DiskStore.evictElement(Object key, DiskStorageFactory.DiskSubstitute substitute) Remove the matching mapping.
Element	DiskStore.fault(Object key, boolean updateStats)
Element	DiskStore.get(Object key) Gets an item from the cache.
Element	DiskStore.getQuiet(Object key) Gets an Element from the Store, without updating statistics
Element	DiskStore.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
protected Element	DiskStorageFactory.read(DiskStorageFactory.DiskMarker marker) Read the data at the given marker, and return the associated deserialized Element.
Element	DiskStore.remove(Object key) Removes an item from the cache.
Element	DiskStore.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.
Element	DiskStore.removeWithWriter(Object key, CacheWriterManager writerManager) Removes an item from the store and the cache writer manager in an atomic operation.
Element	DiskStore.replace(Element element) Replace the cached element only if an Element is currently cached for this key
Element	DiskStorageFactory.retrieve(DiskStorageFactory.DiskSubstitute object) Decodes the supplied DiskStorageFactory.DiskSubstitute.
Element	DiskStorageFactory.retrieve(DiskStorageFactory.DiskSubstitute object, Segment segment) Decodes the supplied DiskStorageFactory.DiskSubstitute, updating statistics.

Methods in net.sf.ehcache.store.disk with parameters of type Element

DiskStorageFactory.DiskSubstitute	DiskStorageFactory.create(Element element) Create a disk substitute for an element
boolean	DiskStore.flush(Element element)
boolean	DiskStore.put(Element element) Puts an item into the store.
boolean	DiskStore.putFaulted(Element element)
Element	DiskStore.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
boolean	DiskStore.putWithWriter(Element element, CacheWriterManager writerManager) Puts an item into the store and the cache writer manager in an atomic operation
Element	DiskStore.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.
Element	DiskStore.replace(Element element) Replace the cached element only if an Element is currently cached for this key
boolean	DiskStore.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.
protected DiskStorageFactory.DiskMarker	DiskStorageFactory.write(Element element) Write the given element to disk, and return the associated marker.

Uses of Element in net.sf.ehcache.terracotta

Methods in net.sf.ehcache.terracotta that return Element

Element

InternalEhcache.removeAndReturnElement(Object key) Removes and returns the element associated with the key

Uses of Element in net.sf.ehcache.transaction

Methods in net.sf.ehcache.transaction that return Element

Element	SoftLock.getElement(TransactionID currentTransactionId, SoftLockID softLockId) Get the element the current transaction is supposed to see.
Element	ReadCommittedSoftLockImpl.getElement(TransactionID currentTransactionId, SoftLockID softLockId) Get the element the current transaction is supposed to see.
Element	SoftLockID.getNewElement() Get the Element with which this soft lock should be replaced by on commit.
Element	SoftLockID.getOldElement() Get the Element with which this soft lock should be replaced by on rollback.
Element	AbstractTransactionStore.getOldElement(Object key) Method to get to the Element matching the key, oblivious of any in-flight transaction.
Element	AbstractTransactionStore.unsafeGet(Object key) Returns the local value associated with the key.

Methods in net.sf.ehcache.transaction with parameters of type Element

SoftLockID	SoftLockManager.createSoftLockID(TransactionID transactionID, Object key, Element newElement, Element oldElement) Create a new soft lock ID and associated soft lock if necessary.
SoftLockID	AbstractSoftLockManager.createSoftLockID(TransactionID transactionID, Object key, Element newElement, Element oldElement) Create a new soft lock ID and associated soft lock if necessary.

Constructors in net.sf.ehcache.transaction with parameters of type Element

SoftLockID(TransactionID transactionID, Object key, Element newElement, Element oldElement)
Create a new SoftLockID instance

Uses of Element in net.sf.ehcache.transaction.local

Methods in net.sf.ehcache.transaction.local that return Element

Element	LocalTransactionStore.get(Object key) Gets an item from the cache.
Element	JtaLocalTransactionStore.get(Object key) Gets an item from the cache.
Element	JtaLocalTransactionStore.getOldElement(Object key)
Element	LocalTransactionStore.getQuiet(Object key) Gets an Element from the Store, without updating statistics
Element	JtaLocalTransactionStore.getQuiet(Object key) Gets an Element from the Store, without updating statistics
Element	LocalTransactionStore.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
Element	JtaLocalTransactionStore.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
Element	LocalTransactionStore.remove(Object key) Removes an item from the cache.
Element	JtaLocalTransactionStore.remove(Object key) Removes an item from the cache.
Element	LocalTransactionStore.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.
Element	JtaLocalTransactionStore.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.
Element	LocalTransactionStore.removeWithWriter(Object key, CacheWriterManager writerManager) Removes an item from the store and the cache writer manager in an atomic operation.
Element	JtaLocalTransactionStore.removeWithWriter(Object key, CacheWriterManager writerManager) Removes an item from the store and the cache writer manager in an atomic operation.
Element	LocalTransactionStore.replace(Element element) Replace the cached element only if an Element is currently cached for this key
Element	JtaLocalTransactionStore.replace(Element element) Replace the cached element only if an Element is currently cached for this key

Methods in net.sf.ehcache.transaction.local with parameters of type Element

boolean	LocalTransactionStore.put(Element element) Puts an item into the store.
boolean	JtaLocalTransactionStore.put(Element element) Puts an item into the store.
Element	LocalTransactionStore.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
Element	JtaLocalTransactionStore.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
boolean	LocalTransactionStore.putWithWriter(Element element, CacheWriterManager writerManager) Puts an item into the store and the cache writer manager in an atomic operation
boolean	JtaLocalTransactionStore.putWithWriter(Element element, CacheWriterManager writerManager) Puts an item into the store and the cache writer manager in an atomic operation
Element	LocalTransactionStore.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.
Element	JtaLocalTransactionStore.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.
Element	LocalTransactionStore.replace(Element element) Replace the cached element only if an Element is currently cached for this key
Element	JtaLocalTransactionStore.replace(Element element) Replace the cached element only if an Element is currently cached for this key
boolean	LocalTransactionStore.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.
boolean	JtaLocalTransactionStore.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.

Method parameters in net.sf.ehcache.transaction.local with type arguments of type Element

void	JtaLocalTransactionStore.putAll(Collection<Element> elements) Puts a collection of elements into the store.

Uses of Element in net.sf.ehcache.transaction.xa

Methods in net.sf.ehcache.transaction.xa that return Element

Element	XATransactionStore.get(Object key) Gets an item from the cache.
Element	XATransactionContext.get(Object key) Filter to get operations on underlying Store.
Element	XATransactionStore.getQuiet(Object key) Gets an Element from the Store, without updating statistics
Element	XATransactionStore.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
Element	XATransactionStore.remove(Object key) Removes an item from the cache.
Element	XATransactionStore.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.
Element	XATransactionStore.removeWithWriter(Object key, CacheWriterManager writerManager) Removes an item from the store and the cache writer manager in an atomic operation.
Element	XATransactionStore.replace(Element element) Replace the cached element only if an Element is currently cached for this key

Methods in net.sf.ehcache.transaction.xa with parameters of type Element

void	XATransactionContext.addCommand(Command command, Element element) Add a command to the current LocalTransactionContext
boolean	XATransactionStore.put(Element element) Puts an item into the store.
Element	XATransactionStore.putIfAbsent(Element element) Put an element in the store if no element is currently mapped to the elements key.
boolean	XATransactionStore.putWithWriter(Element element, CacheWriterManager writerManager) Puts an item into the store and the cache writer manager in an atomic operation
Element	XATransactionStore.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.
Element	XATransactionStore.replace(Element element) Replace the cached element only if an Element is currently cached for this key
boolean	XATransactionStore.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.

Uses of Element in net.sf.ehcache.transaction.xa.commands

Methods in net.sf.ehcache.transaction.xa.commands that return Element

Element	StorePutCommand.getElement() Getter to the Element instance to be put in the Store
protected Element	AbstractStoreCommand.getNewElement() Get the new element to put in the underlying store
protected Element	AbstractStoreCommand.getOldElement() Get the element in the underlying store at the time this command is created

Constructors in net.sf.ehcache.transaction.xa.commands with parameters of type Element

AbstractStoreCommand(Element oldElement, Element newElement)
Create a Store Command

StorePutCommand(Element oldElement, Element newElement)
Create a StorePutCommand

StoreRemoveCommand(Object key, Element oldElement)
Create a StoreRemoveCommand

Uses of Element in net.sf.ehcache.writer

Methods in net.sf.ehcache.writer with parameters of type Element

void	CacheWriterManager.put(Element element) Schedule a put operation for this element in the CacheWriterManager, which will call the CacheWriter when appropriate.
void	CacheWriter.throwAway(Element element, SingleOperationType operationType, RuntimeException e) This method will be called, whenever an Element couldn't be handled by the writer and all the retryAttempts have been tried.
void	AbstractCacheWriter.throwAway(Element element, SingleOperationType operationType, RuntimeException e) This method will be called, whenever an Element couldn't be handled by the writer and all the retryAttempts have been tried.
void	CacheWriter.write(Element element) Write the specified value under the specified key to the underlying store.
void	AbstractCacheWriter.write(Element element) Write the specified value under the specified key to the underlying store.

Method parameters in net.sf.ehcache.writer with type arguments of type Element

void	CacheWriter.writeAll(Collection<Element> elements) Write the specified Elements to the underlying store.
void	AbstractCacheWriter.writeAll(Collection<Element> elements) Write the specified Elements to the underlying store.

Uses of Element in net.sf.ehcache.writer.writebehind

Methods in net.sf.ehcache.writer.writebehind with parameters of type Element

void	WriteBehindManager.put(Element element) Schedule a put operation for this element in the CacheWriterManager, which will call the CacheWriter when appropriate.
void	WriteBehindQueueManager.write(Element element) Add a write operation for a given element.
void	WriteBehind.write(Element element) Add a write operation for a given element.
void	NonStopWriteBehind.write(Element element)
void	AbstractWriteBehindQueue.write(Element element) Add a write operation for a given element.

Uses of Element in net.sf.ehcache.writer.writebehind.operations

Methods in net.sf.ehcache.writer.writebehind.operations that return Element

Element

WriteOperation.getElement() Retrieves the element that will be used for this operation

Constructors in net.sf.ehcache.writer.writebehind.operations with parameters of type Element

WriteOperation(Element element)
Create a new write operation for a particular element

WriteOperation(Element element, long creationTime)
Create a new write operation for a particular element and creation time

Constructor parameters in net.sf.ehcache.writer.writebehind.operations with type arguments of type Element

WriteAllOperation(List<Element> elements)
Create a new write all operation for the provided list of element

Uses of Element in net.sf.ehcache.writer.writethrough

Methods in net.sf.ehcache.writer.writethrough with parameters of type Element

void	WriteThroughManager.put(Element element) Schedule a put operation for this element in the CacheWriterManager, which will call the CacheWriter when appropriate.