ehcache

Uses of Class
net.sf.ehcache.CacheException

Packages that use CacheException
net.sf.ehcache This package contains the public API for using ehcache. 
net.sf.ehcache.bootstrap This package contains the bootstrap cache loader interface and abstract factory. 
net.sf.ehcache.cluster This package contains the API for accessing the cluster node topology and registering to receive events about changes in the cluster node topology. 
net.sf.ehcache.concurrent This package contains concurrency classes and utilities that are not available in java.util.concurrent. 
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.nonstop Ehcache-nonstopcache package 
net.sf.ehcache.constructs.nonstop.concurrency Nonstop feature related to concurrent package 
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.extension This package contains interfaces and classes for the cache extension mechanism. 
net.sf.ehcache.hibernate.management.impl This package contains JMX related classes for Hibernate and ehcache statistics 
net.sf.ehcache.loader This package contains a cache loaders and associated factories. 
net.sf.ehcache.management This package contains JMX MBeans and implementations for management of ehcache. 
net.sf.ehcache.management.sampled This package contains classes related to MBeans with Sampled Statistics. 
net.sf.ehcache.search This package contains classes for ehcache core search API. 
net.sf.ehcache.search.aggregator This package contains classes for search aggregator functionality. 
net.sf.ehcache.search.attribute This package contains classes for ehcache search attributes 
net.sf.ehcache.search.query This package contains the QueryMangerBuilder and the QueryManager interface to support BMSQL. 
net.sf.ehcache.store Store package. 
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.util Util package. 
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.writethrough This package contains the write through functionalities. 
 

Uses of CacheException in net.sf.ehcache
 

Subclasses of CacheException in net.sf.ehcache
 class LoaderTimeoutException
          A loader timeout Exception.
 class ObjectExistsException
          Thrown when a duplicate cache is attemtpted to be created
 

Methods in net.sf.ehcache that throw CacheException
 void CacheManager.addCache(Cache cache)
          Adds a Cache to the CacheManager.
 void CacheManager.addCache(Ehcache cache)
          Adds an Ehcache to the CacheManager.
 void CacheManager.addCache(String cacheName)
          Adds a Ehcache based on the defaultCache with the given name.
 long Ehcache.calculateInMemorySize()
          Deprecated. 
 long Cache.calculateInMemorySize()
          Deprecated. 
 long Ehcache.calculateOffHeapSize()
          Deprecated. 
 long Cache.calculateOffHeapSize()
          Deprecated. 
 long Ehcache.calculateOnDiskSize()
          Deprecated. 
 long Cache.calculateOnDiskSize()
          Deprecated. 
 void CacheManager.clearAll()
          Clears the contents of all caches in the CacheManager, but without removing any caches.
 void CacheManager.clearAllStartingWith(String prefix)
          Clears the contents of all caches in the CacheManager with a name starting with the prefix, but without removing them.
static CacheManager CacheManager.create()
          A factory method to create a singleton CacheManager with default config, or return it if it exists.
static CacheManager CacheManager.create(Configuration config)
          A factory method to create a singleton CacheManager from a net.sf.ehcache.config.Configuration.
static CacheManager CacheManager.create(InputStream inputStream)
          A factory method to create a singleton CacheManager from a java.io.InputStream.
static CacheManager CacheManager.create(String configurationFileName)
          A factory method to create a singleton CacheManager with a specified configuration.
static CacheManager CacheManager.create(URL configurationFileURL)
          A factory method to create a singleton CacheManager from an URL.
 void Ehcache.flush()
          Flushes all cache items from memory to the disk store, and from the DiskStore to disk.
 void Cache.flush()
          Flushes all cache items from memory to the disk store, and from the DiskStore to disk.
 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.
 String CacheManager.getActiveConfigurationText(String cacheName)
          Returns the active configuration text for the input cacheName
 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.
 Map Ehcache.getAllWithLoader(Collection keys, Object loaderArgument)
          The getAll method will return, from the cache, a Map of the objects associated with the Collection of keys in argument "keys".
 Map Cache.getAllWithLoader(Collection keys, Object loaderArgument)
          The getAll method will return, from the cache, a Map of the objects associated with the Collection of keys in argument "keys".
static CacheManager CacheManager.getInstance()
          A factory method to create a singleton CacheManager with default config, or return it if it exists.
 Serializable Element.getKey()
          Deprecated. Please use Element.getObjectKey() instead.
 List Ehcache.getKeys()
          Returns a list of all elements in the cache, whether or not they are expired.
 List Cache.getKeys()
          Returns a list of all element keys in the cache, whether or not they are expired.
 List Ehcache.getKeysWithExpiryCheck()
          Returns a list of all elements in the cache.
 List Cache.getKeysWithExpiryCheck()
          Returns a list of all element keys in the cache.
 String CacheManager.getOriginalConfigurationText(String cacheName)
          Returns the original configuration text for the input cacheName
 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.
<T> Attribute<T>
Ehcache.getSearchAttribute(String attributeName)
          Retrieve the given named search attribute
<T> Attribute<T>
Cache.getSearchAttribute(String attributeName)
          Retrieve the given named search attribute
 Set<Attribute> Ehcache.getSearchAttributes()
           
 Set<Attribute> Cache.getSearchAttributes()
           
 int Ehcache.getSize()
          Gets the size of the cache.
 int Cache.getSize()
          Gets the size of the cache.
 Serializable Element.getValue()
          Deprecated. Please use Element.getObjectValue() instead.
 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".
 void Ehcache.load(Object key)
          The load method provides a means to "pre load" the cache.
 void Cache.load(Object key)
          The load method provides a means to "pre-load" the cache.
 void Ehcache.loadAll(Collection keys, Object argument)
          The loadAll method provides a means to "pre load" objects into the cache.
 void Cache.loadAll(Collection keys, Object argument)
          The loadAll method provides a means to "pre load" objects into the cache.
static CacheManager CacheManager.newInstance()
          A factory method to create a CacheManager with default config, or return it if it exists.
static CacheManager CacheManager.newInstance(InputStream inputStream)
          A factory method to create a CacheManager from a java.io.InputStream.
static CacheManager CacheManager.newInstance(String configurationFileName)
          A factory method to create a CacheManager with a specified configuration.
static CacheManager CacheManager.newInstance(URL configurationFileURL)
          A factory method to create a CacheManager from an URL.
 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.
 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.
 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.
 void Ehcache.removeAll()
          Removes all cached items.
 void Cache.removeAll()
          Removes all cached items.
 void Ehcache.removeAll(boolean doNotNotifyCacheReplicators)
          Removes all cached items.
 void Cache.removeAll(boolean doNotNotifyCacheReplicators)
          Removes all cached items.
 boolean Ehcache.removeWithWriter(Object key)
          Removes an Element from the Cache and any stores it might be in.
 void CacheManager.replaceCacheWithDecoratedCache(Ehcache ehcache, Ehcache decoratedCache)
          Replaces in the map of Caches managed by this CacheManager an Ehcache with a decorated version of the same Ehcache.
 void Ehcache.setBootstrapCacheLoader(BootstrapCacheLoader bootstrapCacheLoader)
          Sets the bootstrap cache loader.
 void Cache.setBootstrapCacheLoader(BootstrapCacheLoader bootstrapCacheLoader)
          Sets the bootstrap cache loader.
 

Constructors in net.sf.ehcache that throw CacheException
CacheManager()
          Constructor.
CacheManager(Configuration configuration)
          An constructor for CacheManager, which takes a configuration object, rather than one created by parsing an ehcache.xml file.
CacheManager(InputStream configurationInputStream)
          An ordinary constructor for CacheManager.
CacheManager(String configurationFileName)
          An ordinary constructor for CacheManager.
CacheManager(URL configurationURL)
          An ordinary constructor for CacheManager.
 

Uses of CacheException in net.sf.ehcache.bootstrap
 

Methods in net.sf.ehcache.bootstrap that throw CacheException
 void BootstrapCacheLoader.load(Ehcache cache)
          Instructs the loader to load the given cache
 

Uses of CacheException in net.sf.ehcache.cluster
 

Subclasses of CacheException in net.sf.ehcache.cluster
 class ClusterSchemeNotAvailableException
          Exception type that is thrown when requesting for a certain type of ClusterScheme and its not available.
 

Uses of CacheException in net.sf.ehcache.concurrent
 

Methods in net.sf.ehcache.concurrent that throw CacheException
static int ConcurrencyUtil.selectLock(Object key, int numberOfLocks)
          Selects a lock for a key.
 

Uses of CacheException in net.sf.ehcache.config
 

Subclasses of CacheException in net.sf.ehcache.config
 class InvalidConfigurationException
          An exception to report invalid configuration settings.
 

Methods in net.sf.ehcache.config that throw CacheException
static CacheExceptionHandler ConfigurationHelper.createCacheExceptionHandler(CacheConfiguration.CacheExceptionHandlerFactoryConfiguration factoryConfiguration, ClassLoader loader)
          Tries to create a CacheLoader from the configuration using the factory specified.
 CacheManagerEventListener ConfigurationHelper.createCacheManagerEventListener(CacheManager cacheManager)
          Tries to load the class specified.
 Ehcache ConfigurationHelper.createDefaultCache()
           
static CacheConfiguration ConfigurationFactory.parseCacheConfiguration(String xmlString)
          Configures a cache bean from a string of XML.
static Configuration ConfigurationFactory.parseConfiguration()
          Configures a bean from an XML file in the classpath.
static Configuration ConfigurationFactory.parseConfiguration(File file)
          Configures a bean from an XML file.
static Configuration ConfigurationFactory.parseConfiguration(InputStream inputStream)
          Configures a bean from an XML input stream.
static Configuration ConfigurationFactory.parseConfiguration(URL url)
          Configures a bean from an XML file available as an URL.
 

Uses of CacheException in net.sf.ehcache.constructs
 

Methods in net.sf.ehcache.constructs that throw CacheException
 long EhcacheDecoratorAdapter.calculateInMemorySize()
          Deprecated. 
 long EhcacheDecoratorAdapter.calculateOffHeapSize()
          Deprecated. 
 long EhcacheDecoratorAdapter.calculateOnDiskSize()
          Deprecated. 
 void EhcacheDecoratorAdapter.flush()
          Flushes all cache items from memory to the disk store, and from the DiskStore to disk.
 Element EhcacheDecoratorAdapter.get(Object key)
          Gets an element from the cache.
 Element EhcacheDecoratorAdapter.get(Serializable key)
          Gets an element from the cache.
 Map<Object,Element> EhcacheDecoratorAdapter.getAll(Collection<?> keys)
          Gets all the elements from the cache for the keys provided.
 Map EhcacheDecoratorAdapter.getAllWithLoader(Collection keys, Object loaderArgument)
          The getAll method will return, from the cache, a Map of the objects associated with the Collection of keys in argument "keys".
 List EhcacheDecoratorAdapter.getKeys()
          Returns a list of all elements in the cache, whether or not they are expired.
 List EhcacheDecoratorAdapter.getKeysWithExpiryCheck()
          Returns a list of all elements in 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.
<T> Attribute<T>
EhcacheDecoratorAdapter.getSearchAttribute(String attributeName)
          Retrieve the given named search attribute
 Set<Attribute> EhcacheDecoratorAdapter.getSearchAttributes()
           
 int EhcacheDecoratorAdapter.getSize()
          Gets the size of the cache.
 Element EhcacheDecoratorAdapter.getWithLoader(Object key, CacheLoader loader, Object loaderArgument)
          This method will return, from the cache, the object associated with the argument "key".
 void EhcacheDecoratorAdapter.load(Object key)
          The load method provides a means to "pre load" the cache.
 void EhcacheDecoratorAdapter.loadAll(Collection keys, Object argument)
          The loadAll method provides a means to "pre load" objects into the cache.
 void EhcacheDecoratorAdapter.put(Element element)
          Put an element in the cache.
 void EhcacheDecoratorAdapter.put(Element element, boolean doNotNotifyCacheReplicators)
          Put an element in the cache.
 void EhcacheDecoratorAdapter.putAll(Collection<Element> elements)
          Puts a collection of elements in to the cache.
 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.
 void EhcacheDecoratorAdapter.removeAll()
          Removes all cached items.
 void EhcacheDecoratorAdapter.removeAll(boolean doNotNotifyCacheReplicators)
          Removes all cached items.
 boolean EhcacheDecoratorAdapter.removeWithWriter(Object key)
          Removes an Element from the Cache and any stores it might be in.
 void EhcacheDecoratorAdapter.setBootstrapCacheLoader(BootstrapCacheLoader bootstrapCacheLoader)
          Sets the bootstrap cache loader.
 

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

Subclasses of CacheException in net.sf.ehcache.constructs.blocking
 class LockTimeoutException
          Indicates that a timeout has occured while attempting to obtain a lock using ReadWriteLockSync.tryLock(net.sf.ehcache.concurrent.LockType, long)

This is a normal runtime exception which should be handled by calling code.

 

Methods in net.sf.ehcache.constructs.blocking that throw CacheException
 Element BlockingCache.get(Serializable key)
          Gets an element from the cache.
 Map BlockingCache.getAllWithLoader(Collection keys, Object loaderArgument)
          This method is not appropriate to use with BlockingCache.
 Element BlockingCache.getWithLoader(Object key, CacheLoader loader, Object loaderArgument)
          This method is not appropriate to use with BlockingCache.
 void BlockingCache.load(Object key)
          This method is not appropriate to use with BlockingCache.
 void BlockingCache.loadAll(Collection keys, Object argument)
          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.
 void BlockingCache.put(Element element, boolean doNotNotifyCacheReplicators)
           
 void BlockingCache.putQuiet(Element element)
           
 void BlockingCache.putWithWriter(Element element)
           
 void UpdatingSelfPopulatingCache.refresh()
          This method should not be used.
 void SelfPopulatingCache.refresh()
          Refresh the elements of this cache.
 void SelfPopulatingCache.refresh(boolean quiet)
          Refresh the elements of this cache.
 Element SelfPopulatingCache.refresh(Object key)
          Refresh a single element.
 Element SelfPopulatingCache.refresh(Object key, boolean quiet)
          Refresh a single element.
 

Constructors in net.sf.ehcache.constructs.blocking that throw CacheException
BlockingCache(Ehcache cache)
          Creates a BlockingCache which decorates the supplied cache.
BlockingCache(Ehcache cache, int numberOfStripes)
          Creates a BlockingCache which decorates the supplied cache.
SelfPopulatingCache(Ehcache cache, CacheEntryFactory factory)
          Creates a SelfPopulatingCache.
UpdatingSelfPopulatingCache(Ehcache cache, UpdatingCacheEntryFactory factory)
          Creates a SelfPopulatingCache.
 

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

Methods in net.sf.ehcache.constructs.classloader that throw CacheException
 long ClassLoaderAwareCache.calculateInMemorySize()
          Deprecated. 
 long ClassLoaderAwareCache.calculateOffHeapSize()
          Deprecated. 
 long ClassLoaderAwareCache.calculateOnDiskSize()
          Deprecated. 
 void ClassLoaderAwareCache.flush()
          Flushes all cache items from memory to the disk store, and from the DiskStore to disk.
 Element ClassLoaderAwareCache.get(Object arg0)
          Gets an element from the cache.
 Element ClassLoaderAwareCache.get(Serializable arg0)
          Gets an element from the cache.
 Map ClassLoaderAwareCache.getAll(Collection arg0)
          Gets all the elements from the cache for the keys provided.
 Map ClassLoaderAwareCache.getAllWithLoader(Collection arg0, Object arg1)
          The getAll method will return, from the cache, a Map of the objects associated with the Collection of keys in argument "keys".
 List ClassLoaderAwareCache.getKeys()
          Returns a list of all elements in the cache, whether or not they are expired.
 List ClassLoaderAwareCache.getKeysWithExpiryCheck()
          Returns a list of all elements in 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.
 Attribute ClassLoaderAwareCache.getSearchAttribute(String arg0)
          Retrieve the given named search attribute
 Set<Attribute> ClassLoaderAwareCache.getSearchAttributes()
          
 int ClassLoaderAwareCache.getSize()
          Gets the size of the cache.
 Element ClassLoaderAwareCache.getWithLoader(Object arg0, CacheLoader arg1, Object arg2)
          This method will return, from the cache, the object associated with the argument "key".
 void ClassLoaderAwareCache.load(Object arg0)
          The load method provides a means to "pre load" the cache.
 void ClassLoaderAwareCache.loadAll(Collection arg0, Object arg1)
          The loadAll method provides a means to "pre load" objects into the cache.
 void ClassLoaderAwareCache.put(Element arg0)
          Put an element in the cache.
 void ClassLoaderAwareCache.put(Element arg0, boolean arg1)
          Put an element in the cache.
 void ClassLoaderAwareCache.putAll(Collection arg0)
          Puts a collection of elements in to the cache.
 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.
 void ClassLoaderAwareCache.removeAll()
          Removes all cached items.
 void ClassLoaderAwareCache.removeAll(boolean arg0)
          Removes all cached items.
 boolean ClassLoaderAwareCache.removeWithWriter(Object arg0)
          Removes an Element from the Cache and any stores it might be in.
 void ClassLoaderAwareCache.setBootstrapCacheLoader(BootstrapCacheLoader arg0)
          Sets the bootstrap cache loader.
 

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

Methods in net.sf.ehcache.constructs.eventual that throw CacheException
 Element StronglyConsistentCacheAccessor.get(Object key)
           
 Element StronglyConsistentCacheAccessor.get(Serializable key)
           
 Map<Object,Element> StronglyConsistentCacheAccessor.getAll(Collection<?> keys)
           
 Map StronglyConsistentCacheAccessor.getAllWithLoader(Collection keys, Object loaderArgument)
           
 Element StronglyConsistentCacheAccessor.getQuiet(Object key)
           
 Element StronglyConsistentCacheAccessor.getQuiet(Serializable key)
           
 Element StronglyConsistentCacheAccessor.getWithLoader(Object key, CacheLoader loader, Object loaderArgument)
           
 void StronglyConsistentCacheAccessor.put(Element element)
           
 void StronglyConsistentCacheAccessor.put(Element element, boolean doNotNotifyCacheReplicators)
           
 void StronglyConsistentCacheAccessor.putAll(Collection<Element> elements)
           
 void StronglyConsistentCacheAccessor.putQuiet(Element element)
           
 void StronglyConsistentCacheAccessor.putWithWriter(Element element)
           
 boolean StronglyConsistentCacheAccessor.removeWithWriter(Object key)
           
 

Uses of CacheException in net.sf.ehcache.constructs.nonstop
 

Subclasses of CacheException in net.sf.ehcache.constructs.nonstop
 class NonStopCacheException
          Exception type thrown for NonStopCache operations
 class RejoinCacheException
          Exception type thrown for rejoins when non-stop is disabled.
 

Uses of CacheException in net.sf.ehcache.constructs.nonstop.concurrency
 

Subclasses of CacheException in net.sf.ehcache.constructs.nonstop.concurrency
 class InvalidLockStateAfterRejoinException
          Exception class signifying invalid lock state.
 class LockOperationTimedOutNonstopException
          Special class of NonStopCacheException which is thrown on timeout of lock operations
 

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

Methods in net.sf.ehcache.constructs.readthrough that throw CacheException
 Element ReadThroughCache.get(Object key)
           
 Element ReadThroughCache.get(Serializable key)
           
 

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

Methods in net.sf.ehcache.constructs.refreshahead that throw CacheException
 Element RefreshAheadCache.get(Object key)
           
 Element RefreshAheadCache.get(Serializable key)
           
 

Uses of CacheException in net.sf.ehcache.distribution
 

Subclasses of CacheException in net.sf.ehcache.distribution
 class RemoteCacheException
          A Cache Exception in the distribution mechanism.
 

Methods in net.sf.ehcache.distribution that throw CacheException
 void RMICacheManagerPeerListener.attemptResolutionOfUniqueResourceConflict()
          If a conflict is detected in unique resource use, this method signals the listener to attempt automatic resolution of the resource conflict.
 void CacheManagerPeerListener.attemptResolutionOfUniqueResourceConflict()
          If a conflict is detected in unique resource use, this method signals the listener to attempt automatic resolution of the resource conflict.
 CacheManagerPeerListener RMICacheManagerPeerListenerFactory.createCachePeerListener(CacheManager cacheManager, Properties properties)
           
 CacheManagerPeerProvider RMICacheManagerPeerProviderFactory.createCachePeerProvider(CacheManager cacheManager, Properties properties)
           
 void RMICacheManagerPeerProvider.dispose()
          Providers may be doing all sorts of exotic things and need to be able to clean up on dispose.
 void RMICacheManagerPeerListener.dispose()
          Stop the listener.
 void CacheManagerPeerProvider.dispose()
          Providers may be doing all sorts of exotic things and need to be able to clean up on dispose.
 void RMICacheManagerPeerListener.init()
          Call to start the listeners and do any other required initialisation.
 void MulticastRMICacheManagerPeerProvider.init()
          Notifies providers to initialise themselves.
protected  String[] RMICacheManagerPeerListener.listBoundRMICachePeers()
          Returns a list of bound objects.
abstract  List RMICacheManagerPeerProvider.listRemoteCachePeers(Ehcache cache)
           
 List MulticastRMICacheManagerPeerProvider.listRemoteCachePeers(Ehcache cache)
           
 List ManualRMICacheManagerPeerProvider.listRemoteCachePeers(Ehcache cache)
           
 List CacheManagerPeerProvider.listRemoteCachePeers(Ehcache cache)
           
protected  Remote RMICacheManagerPeerListener.lookupPeer(String name)
          Returns a reference to the remote object.
 void RMICacheManagerPeerListener.notifyCacheAdded(String cacheName)
          Called immediately after a cache has been added and activated.
 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.
 

Uses of CacheException in net.sf.ehcache.event
 

Methods in net.sf.ehcache.event that throw CacheException
 void CacheManagerEventListener.dispose()
          Stop the listener and free any resources.
 void CacheManagerEventListener.init()
          Call to start the listeners and do any other required initialisation.
 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.notifyElementPut(RegisteredEventListeners.ElementCreationCallback callback, boolean remoteEvent)
          Notifies all registered listeners, in no guaranteed order, that an element was put into the cache
 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.notifyElementRemoved(RegisteredEventListeners.ElementCreationCallback callback, boolean remoteEvent)
          Notifies all registered listeners, in no guaranteed order, that an element was removed
 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.
 

Uses of CacheException in net.sf.ehcache.extension
 

Methods in net.sf.ehcache.extension that throw CacheException
 void CacheExtension.dispose()
          Providers may be doing all sorts of exotic things and need to be able to clean up on dispose.
 

Uses of CacheException in net.sf.ehcache.hibernate.management.impl
 

Methods in net.sf.ehcache.hibernate.management.impl that throw CacheException
 void EhcacheHibernateMBeanRegistrationImpl.dispose()
          Stop the listener and free any resources.
 void EhcacheHibernateMBeanRegistrationImpl.init()
          No-op in this case
 

Uses of CacheException in net.sf.ehcache.loader
 

Methods in net.sf.ehcache.loader that throw CacheException
 void CacheLoader.dispose()
          CacheLoader instances may be doing all sorts of exotic things and need to be able to clean up on dispose.
 Object CacheLoader.load(Object key)
          loads an object.
 

Uses of CacheException in net.sf.ehcache.management
 

Methods in net.sf.ehcache.management that throw CacheException
 void ManagementService.dispose()
          Stop the listener and free any resources.
 void CacheMBean.flush()
          Flushes all cache items from memory to the disk store, and from the DiskStore to disk.
 void Cache.flush()
          Flushes all cache items from memory to the disk store, and from the DiskStore to disk.
 void ManagementService.init()
          Call to register the mbeans in the mbean server and start the event listeners and do any other required initialisation.
static void ManagementService.registerMBeans(CacheManager cacheManager, MBeanServer mBeanServer, boolean registerCacheManager, boolean registerCaches, boolean registerCacheConfigurations, boolean registerCacheStatistics)
          A convenience static method which creates a ManagementService and initialises it with the supplied parameters.
static void ManagementService.registerMBeans(CacheManager cacheManager, MBeanServer mBeanServer, boolean registerCacheManager, boolean registerCaches, boolean registerCacheConfigurations, boolean registerCacheStatistics, boolean registerCacheStores)
          A convenience static method which creates a ManagementService and initialises it with the supplied parameters.
 void CacheMBean.removeAll()
          Removes all cached items.
 void Cache.removeAll()
          Removes all cached items.
 

Constructors in net.sf.ehcache.management that throw CacheException
Cache(Ehcache cache)
          A constructor for JCache.
CacheManager(CacheManager cacheManager)
          Create a management CacheManager
ManagementService(CacheManager cacheManager, MBeanServer mBeanServer, boolean registerCacheManager, boolean registerCaches, boolean registerCacheConfigurations, boolean registerCacheStatistics)
          A constructor for a management service for a range of possible MBeans.
ManagementService(CacheManager cacheManager, MBeanServer mBeanServer, boolean registerCacheManager, boolean registerCaches, boolean registerCacheConfigurations, boolean registerCacheStatistics, boolean registerCacheStores)
          A constructor for a management service for a range of possible MBeans.
 

Uses of CacheException in net.sf.ehcache.management.sampled
 

Methods in net.sf.ehcache.management.sampled that throw CacheException
 void SampledMBeanRegistrationProvider.dispose()
          Stop the listener and free any resources.
 void SampledMBeanRegistrationProvider.init()
          CacheManagerEventListener.init() - no need to do anything here
 boolean SampledCacheManager.isEnabled()
          Returns if each contained cache is enabled.
 boolean CacheManagerSamplerImpl.isEnabled()
          Returns if each cache is enabled.
 

Uses of CacheException in net.sf.ehcache.search
 

Subclasses of CacheException in net.sf.ehcache.search
 class SearchException
          A generic search exception.
 

Uses of CacheException in net.sf.ehcache.search.aggregator
 

Subclasses of CacheException in net.sf.ehcache.search.aggregator
 class AggregatorException
          Thrown if an Aggregator cannot complete.
 

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

Subclasses of CacheException in net.sf.ehcache.search.attribute
 class AttributeExtractorException
          An exception to indicate that an attribute extractor was unable to be processed.
 class UnknownAttributeException
          Thrown at query execution time if query referenced an unknown search attribute
 

Uses of CacheException in net.sf.ehcache.search.query
 

Methods in net.sf.ehcache.search.query that throw CacheException
 Query QueryManager.createQuery(String statement)
          Parses a String statement expressing an Ehcache Search query and returns a Query object for the cache specified in the statement.
 

Uses of CacheException in net.sf.ehcache.store
 

Methods in net.sf.ehcache.store that throw CacheException
protected  void LruMemoryStore.doPut(Element element)
          Allow specialised actions over adding the element to the map.
protected  void LruMemoryStore.evict(Element element)
          Evict the Element.
<T> Attribute<T>
AbstractStore.getSearchAttribute(String attributeName)
          Retrieve the given named search attribute
 long LruMemoryStore.getSizeInBytes()
          Measures the size of the memory store by using the sizeof engine.
 void DiskStoreBootstrapCacheLoader.load(Ehcache cache)
          Instructs the loader to load the given cache
 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 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.
 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)
           
 void Store.removeAll()
          Remove all of the elements from the store.
 void MemoryStore.removeAll()
          Remove all of the elements from the store.
 void LruMemoryStore.removeAll()
          Remove all of the elements from the store.
 void LegacyStoreWrapper.removeAll()
          Remove all of the elements from the store.
 void ElementIdAssigningStore.removeAll()
          Remove all of the elements from the store.
 void CacheStore.removeAll()
           
 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)
           
 

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

Subclasses of CacheException in net.sf.ehcache.store.disk
 class StoreUpdateException
          Exception thrown by the Store when the writer fails.
 

Uses of CacheException in net.sf.ehcache.terracotta
 

Subclasses of CacheException in net.sf.ehcache.terracotta
 class TerracottaNotRunningException
          Exception thrown when using Terracotta clustered operations and Terracotta is not running
 

Methods in net.sf.ehcache.terracotta that throw CacheException
 void TerracottaBootstrapCacheLoader.load(Ehcache cache)
          Instructs the loader to load the given cache
 

Uses of CacheException in net.sf.ehcache.transaction
 

Subclasses of CacheException in net.sf.ehcache.transaction
 class DeadLockException
          This exception is thrown when a deadlock between two transactions is detected
 class TransactionException
          Instances of this class or its subclasses are thrown when an error happen in the transaction subsystem
 class TransactionIDNotFoundException
          This exception is used when a transaction ID suddenly disappeared when trying to update its state.
 class TransactionInterruptedException
          This exception is thrown when a transactional operation got interrupted via Thread.interrupt
 class TransactionTimeoutException
          This exception is thrown when a transactional operation times out
 

Methods in net.sf.ehcache.transaction that throw CacheException
<T> Attribute<T>
AbstractTransactionStore.getSearchAttribute(String attributeName)
          Retrieve the given named search attribute
 

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

Methods in net.sf.ehcache.transaction.local that throw CacheException
 boolean LocalTransactionStore.put(Element element)
          Puts an item into the store.
 boolean JtaLocalTransactionStore.put(Element element)
          Puts an item into the store.
 void JtaLocalTransactionStore.putAll(Collection<Element> elements)
          Puts a collection of elements into the store.
 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
 void LocalTransactionStore.removeAll()
          Remove all of the elements from the store.
 void JtaLocalTransactionStore.removeAll()
          Remove all of the elements from the store.
 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.
 

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

Subclasses of CacheException in net.sf.ehcache.transaction.xa
 class OptimisticLockFailureException
          This exception is used internally when an optimistic lock failed, ie: when the expected previous value is not found at commit time.
 

Methods in net.sf.ehcache.transaction.xa that throw CacheException
 boolean XATransactionStore.put(Element element)
          Puts an item into the store.
 boolean XATransactionStore.putWithWriter(Element element, CacheWriterManager writerManager)
          Puts an item into the store and the cache writer manager in an atomic operation
 void XATransactionStore.removeAll()
          Remove all of the elements from the store.
 Element XATransactionStore.removeWithWriter(Object key, CacheWriterManager writerManager)
          Removes an item from the store and the cache writer manager in an atomic operation.
 

Uses of CacheException in net.sf.ehcache.util
 

Methods in net.sf.ehcache.util that throw CacheException
static void CacheTransactionHelper.beginTransactionIfNeeded(Ehcache cache)
          Begin a transaction on the current thread if the cache is configured as transactional, otherwise this method does nothing.
static void CacheTransactionHelper.commitTransactionIfNeeded(Ehcache cache)
          Commit a transaction previously begun on the current thread if the cache is configured as transactional, otherwise this method does nothing.
static Object ClassLoaderUtil.createNewInstance(ClassLoader loader, String className)
          Creates a new class instance with the given loader.
static Object ClassLoaderUtil.createNewInstance(ClassLoader loader, String className, Class[] argTypes, Object[] args)
          Creates a new class instance and passes args to the constructor call.
static boolean CacheTransactionHelper.isTransactionStarted(Ehcache cache)
          Check if a transaction has begun on the current thread if the cache is configured as transactional, otherwise always return false.
 

Uses of CacheException in net.sf.ehcache.writer
 

Subclasses of CacheException in net.sf.ehcache.writer
 class CacheWriterManagerException
          An exception specifically for throwing exceptions that happen with a CacheWriterManager implementation.
 

Methods in net.sf.ehcache.writer that throw CacheException
 void CacheWriter.delete(CacheEntry entry)
          Delete the cache entry from the store
 void AbstractCacheWriter.delete(CacheEntry entry)
          Delete the cache entry from the store
 void CacheWriter.deleteAll(Collection<CacheEntry> entries)
          Remove data and keys from the underlying store for the given collection of keys, if present.
 void AbstractCacheWriter.deleteAll(Collection<CacheEntry> entries)
          Remove data and keys from the underlying store for the given collection of keys, if present.
 void CacheWriterManager.dispose()
          Cleans up the resources of the cache writer manager.
 void CacheWriter.dispose()
          Providers may be doing all sorts of exotic things and need to be able to clean up on dispose.
 void AbstractCacheWriter.dispose()
          Providers may be doing all sorts of exotic things and need to be able to clean up on dispose.
 void CacheWriterManager.init(Cache cache)
          Initialize the cache writer manager.
 void CacheWriterManager.put(Element element)
          Schedule a put operation for this element in the CacheWriterManager, which will call the CacheWriter when appropriate.
 void CacheWriterManager.remove(CacheEntry entry)
          Schedule a remove operation for this key in the CacheWriterManager, which will call the CacheWriter when appropriate.
 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.
 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 CacheException in net.sf.ehcache.writer.writebehind
 

Methods in net.sf.ehcache.writer.writebehind that throw CacheException
 void WriteBehindManager.init(Cache cache)
          Initialize the cache writer manager.
 void WriteBehindManager.put(Element element)
          Schedule a put operation for this element in the CacheWriterManager, which will call the CacheWriter when appropriate.
 void WriteBehindManager.remove(CacheEntry entry)
          Schedule a remove operation for this key in the CacheWriterManager, which will call the CacheWriter when appropriate.
 void WriteBehindQueueManager.start(CacheWriter writer)
          Start the write behind queue with a cache writer
 void WriteBehind.start(CacheWriter writer)
          Start the write behind queue with a cache writer
 void NonStopWriteBehind.start(CacheWriter writerParam)
           
 void WriteBehindQueueManager.stop()
          Stop the coordinator and all the internal data structures.
 void WriteBehind.stop()
          Stop the coordinator and all the internal data structures.
 void NonStopWriteBehind.stop()
           
 void AbstractWriteBehindQueue.stop()
          Stop the coordinator and all the internal data structures.
 

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

Methods in net.sf.ehcache.writer.writethrough that throw CacheException
 void WriteThroughManager.init(Cache cache)
          Initialize the cache writer manager.
 void WriteThroughManager.put(Element element)
          Schedule a put operation for this element in the CacheWriterManager, which will call the CacheWriter when appropriate.
 void WriteThroughManager.remove(CacheEntry entry)
          Schedule a remove operation for this key in the CacheWriterManager, which will call the CacheWriter when appropriate.
 


ehcache

Copyright 2001-2014, Terracotta, Inc.