|
ehcache | |||||||||
PREV NEXT | FRAMES NO FRAMES |
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. |
|
|
Ehcache.getSearchAttribute(String attributeName)
Retrieve the given named search attribute |
|
|
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. |
|
|
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. |
|
SelfPopulatingCache(Ehcache cache,
int numberOfStripes,
CacheEntryFactory factory)
Create a SelfPopulatingCache, with a specific number of stripes passed to the underlying BlockingCache . |
|
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 . |
|
|
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 | ||
---|---|---|
|
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 | |||||||||
PREV NEXT | FRAMES NO FRAMES |