ehcache

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 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 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
 

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.
 


ehcache

Copyright 2001-2014, Terracotta, Inc.