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.nonstop Ehcache-nonstopcache package 
net.sf.ehcache.constructs.nonstop.concurrency Nonstop feature related to concurrent package 
net.sf.ehcache.constructs.nonstop.store Ehcache-nonstopcache behaviors 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.statistics This package contains classes related to LiveCacheStatistics and its implementation. 
net.sf.ehcache.statistics.sampled This package contains classes related to SampledCacheStatistics and its implementation. 
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 Cache.calculateInMemorySize()
          Gets the size of the memory store for this cache.
 long Ehcache.calculateInMemorySize()
          Gets the size of the memory store for this cache

Warning: This method can be very expensive to run.

 long Cache.calculateOffHeapSize()
          Gets the size of the off-heap store for this cache.
 long Ehcache.calculateOffHeapSize()
          Gets the size of the off-heap store for this cache
 long Cache.calculateOnDiskSize()
          Gets the size of the on-disk store for this cache
 long Ehcache.calculateOnDiskSize()
          Gets the size of the on-disk store for this cache
 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 Cache.flush()
          Flushes all cache items from memory to the disk store, and from the DiskStore to disk.
 void Ehcache.flush()
          Flushes all cache items from memory to the disk store, and from the DiskStore to disk.
 Element Cache.get(Object key)
          Gets an element from the cache.
 Element Ehcache.get(Object key)
          Gets an element from the cache.
 Element Cache.get(Serializable key)
          Gets an element from the cache.
 Element Ehcache.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> Cache.getAll(Collection<?> keys)
          Gets all the elements from the cache for the keys provided.
 Map<Object,Element> Ehcache.getAll(Collection<?> keys)
          Gets all the elements from the cache for the keys provided.
 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".
 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".
static CacheManager CacheManager.getInstance()
          A factory method to create a singleton CacheManager with default config, or return it if it exists.
 List Cache.getKeys()
          Returns a list of all element keys in the cache, whether or not they are expired.
 List Ehcache.getKeys()
          Returns a list of all elements in the cache, whether or not they are expired.
 List Cache.getKeysWithExpiryCheck()
          Returns a list of all element keys in the cache.
 List Ehcache.getKeysWithExpiryCheck()
          Returns a list of all elements in the cache.
 String CacheManager.getOriginalConfigurationText(String cacheName)
          Returns the original configuration text for the input cacheName
 Element Cache.getQuiet(Object key)
          Gets an element from the cache, without updating Element statistics.
 Element Ehcache.getQuiet(Object 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.getQuiet(Serializable key)
          Gets an element from the cache, without updating Element statistics.
<T> Attribute<T>
Cache.getSearchAttribute(String attributeName)
          Retrieve the given named search attribute
<T> Attribute<T>
Ehcache.getSearchAttribute(String attributeName)
          Retrieve the given named search attribute
 int Cache.getSize()
          Gets the size of the cache.
 int Ehcache.getSize()
          Gets the size of the cache.
 int Cache.getSizeBasedOnAccuracy(int statisticsAccuracy)
          Accurately measuring statistics can be expensive.
 int Ehcache.getSizeBasedOnAccuracy(int statisticsAccuracy)
          Accurately measuring statistics can be expensive.
 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.getWithLoader(Object key, CacheLoader loader, Object loaderArgument)
          This method will return, from the cache, the object associated with the argument "key".
 void Cache.load(Object key)
          The load method provides a means to "pre-load" the cache.
 void Ehcache.load(Object key)
          The load method provides a means to "pre load" the cache.
 void Cache.loadAll(Collection keys, Object argument)
          The loadAll method provides a means to "pre load" objects into the cache.
 void Ehcache.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 Cache.put(Element element)
          Put an element in the cache.
 void Ehcache.put(Element element)
          Put an element in the cache.
 void Cache.put(Element element, boolean doNotNotifyCacheReplicators)
          Put an element in the cache.
 void Ehcache.put(Element element, boolean doNotNotifyCacheReplicators)
          Put an element in the cache.
 void Cache.putAll(Collection<Element> elements)
          Puts a collection of elements in the cache.
 void Ehcache.putAll(Collection<Element> elements)
          Puts a collection of elements in the cache.
 void Cache.putQuiet(Element element)
          Put an element in the cache, without updating statistics, or updating listeners.
 void Ehcache.putQuiet(Element element)
          Put an element in the cache, without updating statistics, or updating listeners.
 void Cache.putWithWriter(Element element)
          Put an element in the cache writing through a CacheWriter.
 void Ehcache.putWithWriter(Element element)
          Put an element in the cache writing through a CacheWriter.
 void Cache.removeAll()
          Removes all cached items.
 void Ehcache.removeAll()
          Removes all cached items.
 void Cache.removeAll(boolean doNotNotifyCacheReplicators)
          Removes all cached items.
 void Ehcache.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 Cache.setBootstrapCacheLoader(BootstrapCacheLoader bootstrapCacheLoader)
          Sets the bootstrap cache loader.
 void Ehcache.setBootstrapCacheLoader(BootstrapCacheLoader bootstrapCacheLoader)
          Sets the bootstrap cache loader.
 void Cache.setDiskStorePath(String diskStorePath)
          DiskStore paths can conflict between CacheManager instances.
 void Ehcache.setDiskStorePath(String diskStorePath)
          DiskStore paths can conflict between CacheManager instances.
 

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)
          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 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()
          Gets the size of the memory store for this cache

Warning: This method can be very expensive to run.

 long EhcacheDecoratorAdapter.calculateOffHeapSize()
          Gets the size of the off-heap store for this cache
 long EhcacheDecoratorAdapter.calculateOnDiskSize()
          Gets the size of the on-disk store for this cache
 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
 int EhcacheDecoratorAdapter.getSize()
          Gets the size of the cache.
 int EhcacheDecoratorAdapter.getSizeBasedOnAccuracy(int statisticsAccuracy)
          Accurately measuring statistics can be expensive.
 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 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.
 void EhcacheDecoratorAdapter.setDiskStorePath(String diskStorePath)
          DiskStore paths can conflict between CacheManager instances.
 

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 SelfPopulatingCache.refresh()
          Refresh the elements of this cache.
 void UpdatingSelfPopulatingCache.refresh()
          This method should not be used.
 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()
          Gets the size of the memory store for this cache

Warning: This method can be very expensive to run.

 long ClassLoaderAwareCache.calculateOffHeapSize()
          Gets the size of the off-heap store for this cache
 long ClassLoaderAwareCache.calculateOnDiskSize()
          Gets the size of the on-disk store for this cache
 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
 int ClassLoaderAwareCache.getSize()
          Gets the size of the cache.
 int ClassLoaderAwareCache.getSizeBasedOnAccuracy(int arg0)
          Accurately measuring statistics can be expensive.
 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 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.
 void ClassLoaderAwareCache.setDiskStorePath(String arg0)
          DiskStore paths can conflict between CacheManager instances.
 

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
 

Methods in net.sf.ehcache.constructs.nonstop that throw CacheException
<V> V
NonstopExecutorServiceImpl.execute(Callable<V> callable, long timeoutValueInMillis)
          Execute a Callable task with timeout.
<V> V
NonstopExecutorService.execute(Callable<V> callable, long timeoutValueInMillis)
          Execute a Callable task with timeout.
 

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.nonstop.store
 

Methods in net.sf.ehcache.constructs.nonstop.store that throw CacheException
protected
<V> V
ExecutorServiceStore.executeWithExecutor(Callable<V> callable)
          Execute call within NonStop executor
protected
<V> V
ExecutorServiceStore.executeWithExecutor(Callable<V> callable, long timeoutMillis)
          Execute call within NonStop executor
 void ExceptionOnTimeoutStore.flush()
          Flush elements to persistent store.
 void LocalReadsOnTimeoutStore.flush()
          Flush elements to persistent store.
 Element ExceptionOnTimeoutStore.get(Object key)
          Gets an item from the cache.
 Element LocalReadsOnTimeoutStore.get(Object key)
          Gets an item from the cache.
 List ExceptionOnTimeoutStore.getKeys()
          Gets an Array of the keys for all elements in the disk store.
 List LocalReadsOnTimeoutStore.getKeys()
          Gets an Array of the keys for all elements in the disk store.
 Element ExceptionOnTimeoutStore.getQuiet(Object key)
          Gets an Element from the Store, without updating statistics
 Element LocalReadsOnTimeoutStore.getQuiet(Object key)
          Gets an Element from the Store, without updating statistics
 int ExceptionOnTimeoutStore.getSize()
          Returns the current local store size
 int LocalReadsOnTimeoutStore.getSize()
          Returns the current local store size
 boolean ExecutorServiceStore.put(Element element)
          Puts an item into the store.
 boolean ExceptionOnTimeoutStore.put(Element element)
          Puts an item into the store.
 boolean LocalReadsOnTimeoutStore.put(Element element)
          Puts an item into the store.
 boolean NonstopStoreImpl.put(Element element)
          Puts an item into the store.
 boolean TransactionalExecutorServiceStore.put(Element element)
          Puts an item into the store.
 boolean NoOpOnTimeoutStore.put(Element element)
          Puts an item into the store.
 void ExecutorServiceStore.putAll(Collection<Element> elements)
          Puts a collection of elements into the store.
 void ExceptionOnTimeoutStore.putAll(Collection<Element> elements)
          Puts a collection of elements into the store.
 void LocalReadsOnTimeoutStore.putAll(Collection<Element> elements)
          Puts a collection of elements into the store.
 void NonstopStoreImpl.putAll(Collection<Element> elements)
          Puts a collection of elements into the store.
 void NoOpOnTimeoutStore.putAll(Collection<Element> elements)
          Puts a collection of elements into the store.
 boolean ExecutorServiceStore.putWithWriter(Element element, CacheWriterManager writerManager)
          Puts an item into the store and the cache writer manager in an atomic operation
 boolean ExceptionOnTimeoutStore.putWithWriter(Element element, CacheWriterManager writerManager)
          Puts an item into the store and the cache writer manager in an atomic operation
 boolean LocalReadsOnTimeoutStore.putWithWriter(Element element, CacheWriterManager writerManager)
          Puts an item into the store and the cache writer manager in an atomic operation
 boolean NonstopStoreImpl.putWithWriter(Element element, CacheWriterManager writerManager)
          Puts an item into the store and the cache writer manager in an atomic operation
 boolean TransactionalExecutorServiceStore.putWithWriter(Element element, CacheWriterManager writerManager)
          Puts an item into the store and the cache writer manager in an atomic operation
 boolean NoOpOnTimeoutStore.putWithWriter(Element element, CacheWriterManager writerManager)
          Puts an item into the store and the cache writer manager in an atomic operation
 void ExecutorServiceStore.removeAll()
          Remove all of the elements from the store.
 void ExceptionOnTimeoutStore.removeAll()
          Remove all of the elements from the store.
 void LocalReadsOnTimeoutStore.removeAll()
          Remove all of the elements from the store.
 void NonstopStoreImpl.removeAll()
          Remove all of the elements from the store.
 void TransactionalExecutorServiceStore.removeAll()
          Remove all of the elements from the store.
 void NoOpOnTimeoutStore.removeAll()
          Remove all of the elements from the store.
 Element ExecutorServiceStore.removeWithWriter(Object key, CacheWriterManager writerManager)
          Removes an item from the store and the cache writer manager in an atomic operation.
 Element ExceptionOnTimeoutStore.removeWithWriter(Object key, CacheWriterManager writerManager)
          Removes an item from the store and the cache writer manager in an atomic operation.
 Element LocalReadsOnTimeoutStore.removeWithWriter(Object key, CacheWriterManager writerManager)
          Removes an item from the store and the cache writer manager in an atomic operation.
 Element NonstopStoreImpl.removeWithWriter(Object key, CacheWriterManager writerManager)
          Removes an item from the store and the cache writer manager in an atomic operation.
 Element TransactionalExecutorServiceStore.removeWithWriter(Object key, CacheWriterManager writerManager)
          Removes an item from the store and the cache writer manager in an atomic operation.
 Element NoOpOnTimeoutStore.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.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 CacheManagerPeerListener.attemptResolutionOfUniqueResourceConflict()
          If a conflict is detected in unique resource use, this method signals the listener to attempt automatic resolution of the resource conflict.
 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.
 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 MulticastRMICacheManagerPeerProvider.init()
          Notifies providers to initialise themselves.
 void RMICacheManagerPeerListener.init()
          Call to start the listeners and do any other required initialisation.
protected  String[] RMICacheManagerPeerListener.listBoundRMICachePeers()
          Returns a list of bound objects.
abstract  List RMICacheManagerPeerProvider.listRemoteCachePeers(Ehcache cache)
           
 List ManualRMICacheManagerPeerProvider.listRemoteCachePeers(Ehcache cache)
           
 List MulticastRMICacheManagerPeerProvider.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 RMIAsynchronousCacheReplicator.notifyElementPut(Ehcache cache, Element element)
          Called immediately after an element has been put into the cache.
 void RMISynchronousCacheReplicator.notifyElementPut(Ehcache cache, Element element)
          Called immediately after an element has been put into the cache.
 void RMIAsynchronousCacheReplicator.notifyElementRemoved(Ehcache cache, Element element)
          Called immediately after an attempt to remove an element.
 void RMISynchronousCacheReplicator.notifyElementRemoved(Ehcache cache, Element element)
          Called immediately after an attempt to remove an element.
 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 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.
 

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 CacheEventListenerAdapter.notifyElementPut(Ehcache cache, Element element)
          Called immediately after an element has been put into the cache.
 void NonstopCacheEventListener.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 TerracottaCacheEventReplication.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 CacheEventListenerAdapter.notifyElementRemoved(Ehcache cache, Element element)
          Called immediately after an attempt to remove an element.
 void NonstopCacheEventListener.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 TerracottaCacheEventReplication.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 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 NonstopCacheEventListener.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 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.
 

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()
          Providers 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 Cache.flush()
          Flushes all cache items from memory to the disk store, and from the DiskStore to disk.
 void CacheMBean.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 Cache.removeAll()
          Removes all cached items.
 void CacheMBean.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.
 

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.
 

Uses of CacheException in net.sf.ehcache.statistics
 

Methods in net.sf.ehcache.statistics that throw CacheException
 void LiveCacheStatisticsWrapper.notifyElementPut(Ehcache cache, Element element)
          Called immediately after an element has been put into the cache.
 void LiveCacheStatisticsImpl.notifyElementPut(Ehcache cache, Element element)
          Called immediately after an element has been put into the cache.
 void NullLiveCacheStatisticsData.notifyElementPut(Ehcache cache, Element element)
          Called immediately after an element has been put into the cache.
 void LiveCacheStatisticsWrapper.notifyElementRemoved(Ehcache cache, Element element)
          Called immediately after an attempt to remove an element.
 void LiveCacheStatisticsImpl.notifyElementRemoved(Ehcache cache, Element element)
          Called immediately after an attempt to remove an element.
 void NullLiveCacheStatisticsData.notifyElementRemoved(Ehcache cache, Element element)
          Called immediately after an attempt to remove an element.
 void LiveCacheStatisticsWrapper.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 LiveCacheStatisticsImpl.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 NullLiveCacheStatisticsData.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.statistics.sampled
 

Methods in net.sf.ehcache.statistics.sampled that throw CacheException
 void SampledCacheStatisticsImpl.notifyCacheElementPut()
          Called when an element is inserted in the cache
 void SampledCacheStatisticsImpl.notifyCacheElementRemoved()
          Called when an element is removed from the cache
 void SampledCacheStatisticsImpl.notifyCacheElementUpdated()
          Called when an element is updated in the cache, i.e.
 

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
<T> Attribute<T>
MemoryOnlyStore.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 NullStore.put(Element element)
          Puts an item into the store.
 boolean MemoryStore.put(Element element)
          Puts an item in the store.
 boolean LegacyStoreWrapper.put(Element element)
          Puts an item into the store.
 boolean LruMemoryStore.put(Element element)
          Puts an item in the cache.
 void Store.putAll(Collection<Element> elements)
          Puts a collection of elements into the store.
 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 NullStore.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 LegacyStoreWrapper.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
 void Store.removeAll()
          Remove all of the elements from the store.
 void NullStore.removeAll()
          Remove all of the elements from the store.
 void MemoryStore.removeAll()
          Remove all of the elements from the store.
 void LegacyStoreWrapper.removeAll()
          Remove all of the elements from the store.
 void LruMemoryStore.removeAll()
          Remove all of the elements from the store.
 void FrontEndCacheTier.removeAll()
          Remove all of the elements from the store.
 Element Store.removeWithWriter(Object key, CacheWriterManager writerManager)
          Removes an item from the store and the cache writer manager in an atomic operation.
 Element NullStore.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 LegacyStoreWrapper.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 FrontEndCacheTier.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.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 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 JtaLocalTransactionStore.put(Element element)
          Puts an item into the store.
 boolean LocalTransactionStore.put(Element e)
          Puts an item into the store.
 void JtaLocalTransactionStore.putAll(Collection<Element> elements)
          Puts a collection of elements into the store.
 boolean JtaLocalTransactionStore.putWithWriter(Element element, CacheWriterManager writerManager)
          Puts an item into the store and the cache writer manager in an atomic operation
 boolean LocalTransactionStore.putWithWriter(Element element, CacheWriterManager writerManager)
          Puts an item into the store and the cache writer manager in an atomic operation
 void JtaLocalTransactionStore.removeAll()
          Remove all of the elements from the store.
 void LocalTransactionStore.removeAll()
          Remove all of the elements from the store.
 Element JtaLocalTransactionStore.removeWithWriter(Object key, CacheWriterManager writerManager)
          Removes an item from the store and the cache writer manager in an atomic operation.
 Element LocalTransactionStore.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(String className)
          Creates a new class instance.
static Object ClassLoaderUtil.createNewInstance(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 AbstractCacheWriter.delete(CacheEntry entry)
          Delete the cache entry from the store
 void CacheWriter.delete(CacheEntry entry)
          Delete the cache entry from the store
 void AbstractCacheWriter.deleteAll(Collection<CacheEntry> entries)
          Remove data and keys from the underlying store for the given collection of keys, if present.
 void CacheWriter.deleteAll(Collection<CacheEntry> entries)
          Remove data and keys from the underlying store for the given collection of keys, if present.
 void AbstractCacheWriter.dispose()
          Providers may be doing all sorts of exotic things and need to be able to clean up on dispose.
 void CacheWriter.dispose()
          Providers may be doing all sorts of exotic things and need to be able to clean up on dispose.
 void CacheWriterManager.dispose()
          Cleans up the resources of the cache writer manager.
 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 AbstractCacheWriter.write(Element element)
          Write the specified value under the specified key to the underlying store.
 void CacheWriter.write(Element element)
          Write the specified value under the specified key to the underlying store.
 void AbstractCacheWriter.writeAll(Collection<Element> elements)
          Write the specified Elements to the underlying store.
 void CacheWriter.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 WriteBehind.start(CacheWriter writer)
          Start the write behind queue with a cache writer
 void WriteBehindQueueManager.start(CacheWriter writer)
          Start the write behind queue with a cache writer
 void WriteBehind.stop()
          Stop the coordinator and all the internal data structures.
 void WriteBehindQueueManager.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 © 2003-2012 Terracotta, Inc.. All Rights Reserved.