All Classes

Class	Description
AATreeSet<T extends java.lang.Comparable>	A AA-Tree based SortedSet implementation
AATreeSet.AbstractTreeNode<E>	Abstract node implementation that can be extended with a custom payload.
AATreeSet.Node<E>	Interface implemented by nodes within this tree.
AbstractCacheConfigurationListener
AbstractCacheWriter	A convenience abstract base class that implements all CacheWriter methods.
AbstractDepthFirstVisitor	Implementation of NodeElementVisitor that does a depth-first traversal of the element.
AbstractNodeElement	An abstract implementation of NodeElement.
AbstractPolicy	A base policy class
AbstractPool	An abstract pool implementation.
AbstractPoolAccessor	Abstract PoolAccessor implementation providing pool to store binding functionality.
AbstractSoftLockManager	An abstract map backed soft lock manager.
AbstractStore
AbstractStoreCommand
AbstractTransactionIDFactory	An abstract map backed transaction id factory.
AbstractTransactionStore	Abstract transactional store which provides implementation of all non-transactional methods
AbstractWriteBehindQueue	Abstract implementation of a WriteBehindQueue.
AgentSizeOf	SizeOf implementation that relies on a Java agent to be loaded to do the measurement It will try to load the agent through the JDK6 Attach API if available All it's constructor do throw UnsupportedOperationException if the agent isn't present or couldn't be loaded dynamically
AggregateCacheRegionStats
AggregateIterator<T>	This Iterator iterates over a collection of iterators.
AggregateOnlyResult	A result implementation intended solely for holding aggregate results.
Aggregator	An Aggregator describes a requested aggregation for a query and provides aggregator instances for execution
AggregatorException	Thrown if an Aggregator cannot complete.
AggregatorInstance<T>	An AggregatorInstance takes input objects and computes an aggregate function from them.
Aggregators	Helper class to construct the builtin aggregator types.
AlwaysMatch	Criteria that always return true
And	A search criteria composed of the logical "and" of two or more other criteria
AnnotationProxyFactory	Allows you to transform the type of your custom annotation to a reference annotation type. It can come handy when you want to allow the consumers of your library not to depend on your API because of the annotations, still allowing them to use the original annotation methods.
AnnotationSizeOfFilter	A Filter that will filter fields, based on the IgnoreSizeOf annotation
AtomicLongSequence	Simple non-persistent implementation of LongSequence
AtomikosSelector	A Selector for the Atomikos transaction manager.
Attribute<T>	A search attribute.
AttributeExtractor	Used to extract a search attribute value for a given cache element. Instances must be Serializable in order to ensure identical extractors are used in distributed caches
AttributeExtractorException	An exception to indicate that an attribute extractor was unable to be processed.
AttributeProxy<T>	The Class AttributeProxy, used to proxy operations from a dynamic mbean to a POJO object.
AttributeType	Defines the legal set of runtime types for search attributes
AuthoritativeTier	Document me
Average	Compute the average (arithmetic mean) as a double
BalancedAccessEvictor	Abstract implementation of a global 'cache value' maximizing pool eviction algorithm.
BaseCriteria	Base class for all criteria types
BaseEmitterBean
BaseQueryInterpreter	Base class for interpreting store queries.
BaseResult	Base result implementation
BatchOperation	Interface to implement batch operations that are executed on a cache writer
BeanUtils	Reflective utilities for dealing with backward-incompatible change to statistics types in Hibernate 3.5.
Between	Range criteria
BitronixSelector	A Selector for the Bitronix Transaction Manager.
BlockingCache	A blocking decorator for an Ehcache, backed by a Ehcache.
BlockingCacheOperationOutcomes	The Class BlockingCacheOperationOutcomes.
BlockingCacheOperationOutcomes.GetOutcome	The operation outcome for BlockingCache gets
BooleanBeanProxy	A proxy for Boolean flavored bean proxies.
BootstrapCacheLoader
BootstrapCacheLoaderFactory<T extends BootstrapCacheLoader>	An abstract factory for creating BootstrapCacheLoader instances.
BoundedPool	A pool which loosely obeys to its bound: it can allow the accessors to consume more bytes than what has been configured if that helps concurrency.
BruteForceSearchManager	Brute force search implementation
Cache	Cache is the central class in ehcache.
Cache	A Cache implementation that supports JMX MBeans
CacheCluster	Allows you to explore the Terracotta cluster nodes and register for events about the cluster.
CacheClusterStateStatisticsListener	A listener to capture statistics relating to cluster events regarding this node.
CacheConfigError	Represents a config error in a cache configuration
CacheConfiguration	A value object used to represent cache configuration.
CacheConfiguration	A JMX MBean implementation and decorator to net.sf.ehcache.CacheConfiguration
CacheConfiguration.BootstrapCacheLoaderFactoryConfiguration	Configuration for the BootstrapCacheLoaderFactoryConfiguration.
CacheConfiguration.CacheDecoratorFactoryConfiguration	Configuration for the CacheDecoratorFactoryConfiguration.
CacheConfiguration.CacheEventListenerFactoryConfiguration	Configuration for the CacheEventListenerFactory.
CacheConfiguration.CacheExceptionHandlerFactoryConfiguration	Configuration for the BootstrapCacheLoaderFactoryConfiguration.
CacheConfiguration.CacheExtensionFactoryConfiguration	Configuration for the CacheExtensionFactoryConfiguration.
CacheConfiguration.CacheLoaderFactoryConfiguration	Configuration for the CacheLoaderFactoryConfiguration.
CacheConfiguration.TransactionalMode	Represents whether the Cache is transactional or not.
CacheConfigurationElement	Element representing the CacheConfiguration
CacheConfigurationListener	Instances of CacheConfigurationListener can be registered with CacheConfiguration instances in order to receive notification when any of the dynamic properties of the configuration are changed.
CacheConfigurationMBean	A JMX MBean interface for the configuration of a cache
CacheDecoratorFactory	An abstract factory for creating decorated Ehcache instances.
CacheEntry	Helper class to tie a key to an element.
CacheEntryFactory	Creates objects to populate the cache.
CacheEventListener	Allows implementers to register callback methods that will be executed when a cache event occurs.
CacheEventListenerAdapter	An adapter to simplify cache event listeners that do not need all events defined on the CacheEventListener interface.
CacheEventListenerFactory	An abstract factory for creating listeners.
CacheException	A runtime Cache Exception.
CacheExceptionHandler	A handler which may be registered with an Ehcache, to handle exceptions on Cache operations.
CacheExceptionHandlerFactory	An abstract factory for creating CacheExceptionHandlers at configuration time, in ehcache.xml.
CacheExtension	This is a general purpose mechanism to allow generic extensions to a Cache.
CacheExtensionFactory	An abstract factory for creating CacheExtensions.
CacheInitializationHelper	Helper class to initialize an Ehcache with a CacheManager without adding the Ehcache to the CacheManager.
CacheKeySet<E>	A Set of keys that will encapsulate keys present in a Cache.
CacheLoader	Extends JCache CacheLoader with load methods that take an argument in addition to a key This interface has exactly the same interface as in the JCache module.
CacheLoaderFactory	An abstract factory for creating cache loaders.
CacheLockProvider
CacheManager	A container for Ehcaches that maintain all aspects of their lifecycle.
CacheManager	An MBean implementation for those attributes and operations we wish to expose on net.sf.ehcache.CacheManager.
CacheManagerEventListener	Allows implementers to register callback methods that will be executed when a CacheManager event occurs.
CacheManagerEventListenerFactory	An abstract factory for creating CacheManagerEventListeners.
CacheManagerEventListenerRegistry	Registered listeners for registering and unregistering CacheManagerEventListeners and sending notifications to registrants.
CacheManagerMBean	An MBean interface for those attributes and operations we wish to expose on net.sf.ehcache.CacheManager
CacheManagerPeerListener	A listener for updates, which controls remote cache peers.
CacheManagerPeerListenerFactory	An abstract factory for creating cache manager peer listeners.
CacheManagerPeerProvider	Provides a discovery service to locate CachePeer listener peers for a Cache.
CacheManagerPeerProviderFactory	An abstract factory for creating peers.
CacheManagerSampler	An abstraction for sampled cache manager usage statistics.
CacheManagerSamplerImpl	An implementation of CacheManagerSampler
CacheMBean	A management bean for a cache
CacheOperationOutcomes	Interface containing cache operation outcome enums.
CacheOperationOutcomes.ClusterEventOutcomes	Cluster event operation outcomes.
CacheOperationOutcomes.EvictionOutcome	The eviction outcomes.
CacheOperationOutcomes.ExpiredOutcome	The expiration outcomes.
CacheOperationOutcomes.GetAllOutcome	The outcomes for GetAll operations.
CacheOperationOutcomes.GetOutcome	Outcomes for cache Get operations.
CacheOperationOutcomes.NonStopOperationOutcomes	The Enum NonStopOperationOutcomes.
CacheOperationOutcomes.PutAllOutcome	The outcomes for GetAll operations.
CacheOperationOutcomes.PutIfAbsentOutcome
CacheOperationOutcomes.PutOutcome	The outcomes for Put Outcomes.
CacheOperationOutcomes.RemoveAllOutcome	The outcomes for GetAll operations.
CacheOperationOutcomes.RemoveElementOutcome
CacheOperationOutcomes.RemoveOutcome	The outcomes for remove operations.
CacheOperationOutcomes.ReplaceOneArgOutcome
CacheOperationOutcomes.ReplaceTwoArgOutcome
CacheOperationOutcomes.SearchOutcome	The outcomes for the store search operation.
CachePeer	An interface for a cache peer to which updates are made remotely.
CacheRegionStats
CacheRegionUtils	CacheRegionUtils
CacheReplicator	Replicates cache entries to peers of the CacheManager
CacheSampler	An interface for exposing cache statistics.
CacheSamplerImpl	An implementation of CacheSampler
CacheStatistics	A JMX CacheStatistics decorator for an ehcache Statistics class.
CacheStatisticsMBean
CacheStore	The one store to rule them all!
CacheStoreHelper	A helper class to get the internal Store from a Cache
CacheTransactionHelper	A collection of utility methods helping controlling transactions for managed operations which may require them.
CacheUsageListener	Interface for listeners to any change in usage statistics of an Ehcache.
CacheWriter	A CacheWriter is an interface used for write-through and write-behind caching to a underlying resource.
CacheWriterConfiguration	Class to hold the CacheWriterManager configuration
CacheWriterConfiguration.CacheWriterFactoryConfiguration	Configuration for the CacheWriterFactoryConfiguration.
CacheWriterConfiguration.WriteMode	Represents how elements are written to the CacheWriter
CacheWriterConfigurationElement	Element representing the CacheWriterConfiguration
CacheWriterFactory	An abstract factory for creating cache writers.
CacheWriterManager	A CacheWriterManager coordinates how element are written to a back-end store.
CacheWriterManagerException	An exception specifically for throwing exceptions that happen with a CacheWriterManager implementation.
CachingTier<K,V>	This interface is to be implemented by CachingTier that sit above the AuthoritativeTier.
CachingTier.Listener<K,V>	A listener that will be notified when eviction of a mapping happens
CastingOperationConverter	A converter that simply casts an existing KeyBasedOperation instance.
CircularLossyQueue<T>	An implementation of a CircularQueue data-structure.
ClassLoaderAwareCache	A cache decorator that adjusts the Thread context classloader (TCCL) for every cache operation.
ClassLoaderUtil	Keeps all classloading in ehcache consistent.
ClassSelector	Abstract selector for instanciating a class
ClusteredInstanceFactory	Factory for creating clustered instances
ClusteredInstanceFactoryWrapper	A ClusteredInstanceFactory implementation that delegates all operations to an underlying delegate except for the following operations: ClusteredInstanceFactoryWrapper.getTopology() : Delegates to the TerracottaClient.getCacheCluster()
ClusterNode	Provides information about a node in a cache cluster.
ClusterScheme	Lists support cluster schemes (may not include all possible schemes).
ClusterSchemeNotAvailableException	Exception type that is thrown when requesting for a certain type of ClusterScheme and its not available.
ClusterTopologyListener	A listener for cluster topology events
CoalesceKeysFilter	Filters the operations by only retaining the latest operations for a given key.
CollectionStats	CollectionStats
CombinationSizeOfFilter	Filter combining multiple filters
Command
ComparableValue	Abstract base class for criteria involving Comparable values
ConcurrencyUtil	Various bits of black magic garnered from experts on the concurrency-interest@cs.oswego.edu mailing list.
ConcurrentHashMap<K,V>	A hash table supporting full concurrency of retrievals and high expected concurrency for updates.
ConcurrentHashMap.EntrySetView<K,V>	A view of a ConcurrentHashMap as a Set of (key, value) entries.
ConcurrentHashMap.KeySetView<K,V>	A view of a ConcurrentHashMap as a Set of keys, in which additions may optionally be enabled by mapping to a common value.
ConcurrentHashMap.Node	Key-value entry.
ConcurrentHashMap.RemovalCallback
ConcurrentHashMap.Spliterator<T>	A partitionable iterator.
ConcurrentHashMap.TreeNode	Nodes for use in TreeBins
ConcurrentHashMap.ValuesView<K,V>	A view of a ConcurrentHashMap as a Collection of values, in which additions are disabled.
ConfigError	Represents a config error
ConfigurableRMIClientSocketFactory	Default socket timeouts are unlikely to be suitable for cache replication.
Configuration	A bean, used by BeanUtils, to set configuration from an XML configuration file.
Configuration.Monitoring	Represents whether monitoring should be enabled or not.
ConfigurationElement	Element representing the Configuration.
ConfigurationFactory	A utility class which configures beans from XML, using reflection.
ConfigurationGenerator	Deprecated. Use ConfigurationUtil.generateCacheManagerConfigurationText(Configuration) or ConfigurationUtil.generateCacheConfigurationText(Configuration, CacheConfiguration) instead
ConfigurationHelper	The configuration for ehcache.
ConfigurationSource	Class encapsulating the source of configuration for a cache manager
ConfigurationUtil	Utility class with static methods for generating configuration texts in different ways based on input
Constants	The Operation/stats db Constants.
CopyingCacheStore<T extends Store>	Copies elements, either on read, write or both before using the underlying store to actually store things When copying both ways, the store might not see the same types being stored
CopyStrategy	Deprecated. replaced by ReadWriteCopyStrategy
CopyStrategyConfiguration
CopyStrategyConfigurationElement	NodeElement representing the CopyStrategyConfiguration
CopyStrategyHandler	Utility class for handling element copy based on the copy on read and write configurations.
CoreStatistics	The CoreStatistics interface.
CoreStatistics.CountOperation<T>	The Interface CountOperation.
CoreStatisticsImpl	The CoreStatisticsImpl class.
Count	Counts the number of results
CountBasedBackEnd<K,V>	A backend to a OnHeapCachingTier that will be cap'ed based on the amount of entries
Counter	A simple counter
CounterConfig	Config for a simple Counter
CounterImpl	A simple counter implementation
CounterManager	A Counter Manager that accepts a config to create counters.
CounterManagerImpl	An implementation of a CounterManager.
CountingThreadFactory	A custom ThreadFactory that maintains a count of how many threads this factory has created
Criteria	Criteria interface defines a boolean function that computes a search match result
DeadLockException	This exception is thrown when a deadlock between two transactions is detected
Decision	The decision types a Transaction ID can be in
DefaultCacheConfigurationElement	NodeElement representing the CacheConfiguration of the "defaultCache"
DefaultElementValueComparator	DefaultElementValueComparator does compare the values on the two elements based on their equals contract
DefaultSizeOfEngine
DefaultTransactionManagerLookup	Default TransactionManagerLookup implementation, that will be used by an initializing Cache should the user have not specified otherwise.
DelegatingManagementEventSink
DelegatingTransactionIDFactory	A TransactionIDFactory implementation with delegates calls to either a clustered or non-clustered factory
DeleteAllOperation	Implements the delete all operation for write behind
DeleteOperation	Implements the delete operation for write behind
DevModeClassLoader	Classloader used for devmode to load management classes Substitutes for ResourceClassLoader
Direction	The direction for search result ordering
DisconnectedClusterNode	ClusterNode which copies a disconnected ClusterNode without keeping any reference to the original one.
DiskSizeOfEngine	SizeOf engine which calculates exact usage of the disk store.
DiskStorageFactory	A mock-up of a on-disk element proxy factory.
DiskStorageFactory.DiskMarker	DiskMarker instances point to the location of their associated serialized Element instance.
DiskStorageFactory.DiskSubstitute	Abstract superclass for all disk substitutes.
DiskStore	Implements a persistent-to-disk store.
DiskStoreBootstrapCacheLoader
DiskStoreBootstrapCacheLoaderFactory	Factory class to create DiskStoreBootstrapCacheLoader instances.
DiskStoreConfiguration	A class to represent DiskStore configuration e.g.
DiskStoreConfigurationElement	Element representing the DiskStoreConfiguration
DiskStorePathManager	Manager class to handle disk store path.
Disposable	A Disposable is a resource that needs to release other resources when it is no longer needed.
DoubleBeanProxy	A Class for Double proxies.
DynamicAttributesExtractor	Dynamic indexing API
DynamicSearchChecker	Utility class for verifying dynamically extracted search attribute against "static" search configuration
DynamicSearchListener	Listener for changes to dynamic attributes extractor config
Ehcache	An interface for Ehcache.
EhCache	Deprecated.
EhcacheAccessStrategyFactory	Factory to create EntityRegionAccessStrategy
EhcacheAccessStrategyFactoryImpl	Class implementing EhcacheAccessStrategyFactory
EhcacheCollectionRegion	A collection region specific wrapper around an Ehcache instance.
EhcacheDataRegion	An Ehcache specific data region implementation.
EhcacheDecoratorAdapter	Adapter class for Ehcache interface decorators.
EhcacheDefaultClassLoader
EhcacheEntityRegion	An entity region specific wrapper around an Ehcache instance.
EhcacheHibernate	Implementation of the EhcacheHibernateMBean
EhcacheHibernateMBean	MBean interface for hibernate statistics of session-factories
EhcacheHibernateMbeanNames	Utility class used for getting ObjectName's for ehcache hibernate MBeans
EhcacheHibernateMBeanRegistration	Interface for helping registering mbeans for ehcache backed hibernate second-level cache
EhcacheHibernateMBeanRegistrationImpl	Implementation of EhcacheHibernateMBeanRegistration.
EhcacheJtaTransactionManagerLookup	Hibernate TransactionManagerLookup which also is a Ehcache transaction manager lookup.
EhcacheNonstrictReadWriteCache	Deprecated.
EhCacheProvider	Deprecated.
EhcacheQueryResultsRegion	A query results region specific wrapper around an Ehcache instance.
EhcacheReadOnlyCache	Deprecated.
EhcacheReadWriteCache	Deprecated.
EhCacheRegionFactory	A non-singleton EhCacheRegionFactory implementation.
EhcacheStats	Interface for ehcache related statistics of hibernate second level cache
EhcacheStatsImpl	Implementation of EhcacheStats
EhcacheTimestampsRegion	A timestamps region specific wrapper around an Ehcache instance.
EhcacheTransactionalDataRegion	An Ehcache specific TransactionalDataRegion.
EhcacheXAException	Small extension to the XAException defined in the JTA standard, so that the errorCode is provided when instantiating the Exception thrown
EhcacheXAResource	EhcacheXAResource represents an Ehcache instance.
EhcacheXAResourceImpl	The EhcacheXAResource implementation
Element	A Cache Element, consisting of a key, value and attributes.
ElementIdAssigningStore	Store wrapper that assigns sequential IDs to elements as they are added to the underlying store
ElementIdHelper	Provide access to the package private methods for getting/setting Element id.
ElementSubstituteFilter	Filter on Elements or ElementSubstitutes.
ElementValueComparator	Used to compare two element values.
ElementValueComparatorConfiguration
ElementValueComparatorConfigurationElement	NodeElement representing the ElementValueComparatorConfiguration
EntityStats	When we only support Java 6, all of this OpenMBean scaffolding can be removed in favor or MXBeans.
EqualTo	A comparison operator meaning Java "equals to" condition
EventMessage	An Event Message, in respect of a particular cache.
ExceptionHandlingDynamicCacheProxy	A dynamic proxy which provides CacheException handling.
ExecutionHints	Builder-style class that allows user to specify query execution preferences, if necessary
ExpiredTransactionIDImpl
ExpiredXidTransactionIDImpl
ExtendedStatistics	The ExtendedStatistics interface.
ExtendedStatistics.Latency	The Latency interface.
ExtendedStatistics.Operation<T extends java.lang.Enum<T>>	The Interface Operation.
ExtendedStatistics.Result	The Interface Result.
ExtendedStatistics.Statistic<T extends java.lang.Number>	The Interface Statistic.
ExtendedStatisticsImpl	The Class ExtendedStatisticsImpl.
ExtendedStatisticsMBean	A dynamically built mbean based on the available statistics for a cache.
FactoryConfiguration<T extends FactoryConfiguration>	A class to represent the CacheManagerEventListener configuration.
FactoryConfigurationElement	NodeElement representing the FactoryConfiguration
FactorySelector	Abstract selector for calling a factory method
FailSafeTimer	A fail-safe timer in the sense that if the runtime environment restricts creating new threads, it doesn't blow up with an exception.
FeaturesManager	Interface implemented by classes providing access to extended functionality.
FifoPolicy	Contains common LFU policy code for use between the LfuMemoryStore and the DiskStore, which also uses an LfuPolicy for evictions.
FileAllocationTree	File allocation tree allows C-like alloc/free operations on a random access file.
FindBugsSuppressWarnings	Annotation used to suppress FindBugs warnings in Ehcache core code.
FlatStatistics	The Interface FlatStatistics; the almighty confluence of all basic statistics.
FromLargestCachePoolEvictor	Abstract pool evictor which always evicts from the store consuming the most resources.
GenericJndiSelector	A generic selector for looking up any transaction manager under the java:/TransactionManager JNDI name
GlassfishSelector	A selector for the Glassfish Server's JTA transaction manager
GreaterThan	Greater than criteria
GreaterThanOrEqual	Greater than or equal criteria
GroupedResultImpl	Representation of single result row from group-by queries
HeapCacheBackEnd<K,V>	A backend to a OnHeapCachingTier It's responsibility, beyond being the actual storage (CHM like), is to evict when required.
HeapCacheBackEnd.EvictionCallback<K,V>	An eviction callback
HibernateNonstopCacheExceptionHandler	Class that takes care of NonStopCacheException that happens in hibernate module
HibernateStats	Interface for hibernate related statistics of hibernate second level cache
HibernateStatsImpl	Implementation of HibernateStats
HibernateUtil
IgnoreSizeOf	Annotation to ignore a field, type or entire package while doing a SizeOf measurement
ILike	A regular expression criteria that matches attribute string values.
ImmutableValueElementCopyStrategy
InCollection	Criteria for inclusion in a given Collection (presumably a Set) of values
InternalClassLoaderAwareCache	Extension of Class Loader Aware cache to accommodate the removeAndReturnElement method.
InternalEhcache	This is an extension of the Ehcache interface to allow addition of new methods to Cache without breaking the public contract.
InvalidConfigurationException	An exception to report invalid configuration settings.
InvalidLockStateAfterRejoinException	Exception class signifying invalid lock state.
IsNull	Tests whether the value of attribute with given name is null
JavaBeanAttributeExtractor	Extracts a search attribute determining the value as a javabean property on either the key or the value.
JndiSelector	Abstract selector performing JNDI lookup
JtaLocalTransactionStore	A Store implementation with support for local transactions driven by a JTA transaction manager
JvmInformation	Detects and represents JVM-specific properties that relate to the memory data model for java objects that are useful for size of calculations.
KeyBasedOperation	Interface to implement operations that are performed with write-behind and based on a key
KeyObjectAttributeExtractor	Attempt to use the element key object itself as a search attribute.
LargeCollection<E>	Collection for large set.
LargeSet<E>	Set for holding large entries of set.
LegacyCacheStatistics	Interface for sampled usage statistics of a Cache
LegacyCopyStrategyAdapter	ReadWriteCopyStrategy adaptor for a legacy CopyStrategy instance
LegacyEventMessage	An Event Message, in respect of a particular cache.
LegacyStoreWrapper	A wrapper to convert a legacy pair of stores into a new style compound store.
LessThan	Less than criteria
LessThanOrEqual	Less than or equal criteria
LfuPolicy	Contains common LFU policy code for use between the LfuMemoryStore and the DiskStore, which also uses an LfuPolicy for evictions.
LoaderTimeoutException	A loader timeout Exception.
LocalRecoveryManager	The local transactions mode recovery manager which is used to trigger full recovery of all caches configured with local transaction mode.
LocalTransactionContext	A local transaction's thread context
LocalTransactionStore	A Store implementation with support for local transactions
LockOperationTimedOutNonstopException	Special class of NonStopCacheException which is thrown on timeout of lock operations
LockTimeoutException	Indicates that a timeout has occured while attempting to obtain a lock using ReadWriteLockSync.tryLock(net.sf.ehcache.concurrent.LockType, long)
LockType	LockType tells the locking API what kind of lock should be acquired or released
LongAdder	One or more variables that together maintain an initially zero long sum.
LongBeanProxy	An implementation of a Long attribute proxy.
LongSequence	A sequence producing longs
LruMemoryStore	An implementation of a LruMemoryStore.
LruPolicy	Contains common LFU policy code for use between the LfuMemoryStore and the DiskStore, which also uses an LfuPolicy for evictions.
ManagedCacheManagerPeerProvider	A CacheManagerPeerProvider that supports MBean registration
ManagementAttribute	Annotation used to indicate that a Cache[Manager]Sampler method is a management attribute (non-statistic), used for filtering while creating entities when the REST interface doesn't request specific attributes.
ManagementEventSink
ManagementRESTServiceConfiguration	Configuration class of management REST services.
ManagementRESTServiceConfigurationElement	Element representing the ManagementRESTServiceConfiguration
ManagementServer	Interface implemented by management servers.
ManagementServerLoader	ManagementServerLoader is a facility class to access the rest management interface One would use it from EhCache or QuartzScheduler to start or stop a new rest management interface or to simply register a cache or a scheduler to an already started management interface.
ManagementService	Ehcache CacheManagers and Caches have lifecycles.
ManualRMICacheManagerPeerProvider	A provider of Peer RMI addresses based off manual configuration.
Max<T>	Determine the maximum value
MaxDepthExceededException
MBeanRegistrationProvider	Implementations of this interface will can initialize MBeanRegistration for the passed CacheManager.
MBeanRegistrationProviderException	Exception thrown from MBeanRegistrationProvider
MBeanRegistrationProviderFactory	Factory interface to create MBeanRegistrationProvider
MBeanRegistrationProviderFactoryImpl	Defult implementation of MBeanRegistrationProvider
MBeanRegistrationProviderImpl	Implementation of MBeanRegistrationProvider
MemoryEfficientByteArrayOutputStream	This class is designed to minimise the number of System.arraycopy(); methods required to complete.
MemoryLimitedCacheLoader	Abstract class for BootstrapCacheLoader implementers that should alter their load behavior (probably stop loading) whenever the cache being bootstrapped has reached its in-memory limit (off- or on-heap)
MemorySizeParser	Memory size parser using the letter k or K to indicate kilobytes, the letter m or M to indicate megabytes, the letter g or G to indicate gigabytes and the letter t or T to indicate terabytes.
MemoryStore	A Store implementation suitable for fast, concurrent in memory stores.
MemoryStore.BackingFactory	Factory interface to create a MemoryStore backing.
MemoryStoreEvictionPolicy	A typesafe enumeration of eviction policies.
MemoryStoreEvictionPolicy.MemoryStoreEvictionPolicyEnum	Enum for MemoryStoreEvictionPolicy
MemoryUnit	Memory unit: byte-based
MergedEnumeration<E>	An utility class to merge several enumerations into a single one
MimeTypeByteArray	A bean used to wrap byte[] values to be placed in an Element so as to preserve MIME type information.
Min<T>	Determine the minimum value
MulticastKeepaliveHeartbeatReceiver	Receives heartbeats from any MulticastKeepaliveHeartbeatSenders out there.
MulticastKeepaliveHeartbeatSender	Sends heartbeats to a multicast group containing a compressed list of URLs.
MulticastRMICacheManagerPeerProvider	A peer provider which discovers peers using Multicast.
MulticastRMICacheManagerPeerProvider.CachePeerEntry	Entry containing a looked up CachePeer and date
NamedThreadFactory	A ThreadFactory that sets names to the threads created by this factory.
NodeAttribute	Interface that abstracts the idea of an attribute.
NodeElement	Interface that abstracts the idea of an element.
NodeElementVisitor	Interface for visiting a NodeElement
NonstopAccessStrategyFactory	Implementation of EhcacheAccessStrategyFactory that takes care of Nonstop cache exceptions using HibernateNonstopCacheExceptionHandler
NonstopAwareCollectionRegionAccessStrategy	Implementation of CollectionRegionAccessStrategy that handles NonStopCacheException using HibernateNonstopCacheExceptionHandler
NonstopAwareEntityRegionAccessStrategy	Implementation of EntityRegionAccessStrategy that handles NonStopCacheException using HibernateNonstopCacheExceptionHandler
NonStopCacheException	Exception type thrown for NonStopCache operations
NonstopConfiguration	Configuration class of nonstop caches
NonstopConfigurationElement	NodeElement representing the NonstopConfiguration
NonStopWriteBehind	Non stop class for write behind
NonStrictReadWriteEhcacheCollectionRegionAccessStrategy	Ehcache specific non-strict read/write collection region access strategy
NonStrictReadWriteEhcacheEntityRegionAccessStrategy	Ehcache specific non-strict read/write entity region access strategy
NoopCacheCluster	This is a dummy implementation of the CacheCluster (Null Object Pattern).
Not	A search criteria composed of the logical "not" (ie.
NotEqualTo	Criteria for plain "not equals to" condition
NotificationScope	This enumeration defines valid values for event listener notification scope.
NotILike	Inverse of ILike
NotNull
NullHibernateStats	Implementation of HibernateStats that does nothing
NullMBeanRegistrationProvider	A Null implementation of MBeanRegistrationProvider which does nothing
NullReadWriteCopyStrategy	No-op copy strategy
NullResults	An empty result instance
NullSelector	A selector that always returns a null transaction manager
ObjectExistsException	Thrown when a duplicate cache is attemtpted to be created
OnHeapCachingTier<K,V>	An instance of this class will delegate the storage to the backing HeapCacheBackEnd. Adding : making sure only a single thread populates the cache for a given key at a time translate calls to the eviction listeners Add all the crap about sizing and stuff
OperationConverter<T>	Interface that allows an converter to be implemented that can create an operation based on an arbitrary object.
OperationsFilter<T>	An interface for implementing a filter for operations before they are processed.
OptimisticLockFailureException	This exception is used internally when an optimistic lock failed, ie: when the expected previous value is not found at commit time.
Or	A search criteria composed of the logical "or" of two or more other criteria
OrderComparator<T extends BaseResult>	Compound sort ordering comparactor
OverrideCheck	A utility class to check whether one class overrides all methods of its superclass or an interface that it implements
PassThroughFilter	Filter that doesn't filter!
PersistenceConfiguration	Class to hold the persistence policy configuration.
PersistenceConfiguration.Strategy	Enumeration of the legal persistence strategies
PersistenceConfigurationElement	Element representing the PersistenceConfiguration
PinningConfiguration	Class to hold the Pinning configuration.
PinningConfiguration.Store	Possible store values
PinningConfigurationElement	NodeElement representing the PinningConfiguration
Policy	An eviction policy.
Pool	Pools are used to track shared resource consumption.
PoolAccessor<T extends PoolParticipant>	PoolAccessors are used by stores to tell the pools about their resource consumption
PooledBasedBackEnd<K,V>	A backend to a OnHeapCachingTier that will be cap'ed using a pool
PooledBasedBackEnd.PoolParticipant	A pool participant to use with this Backend
PoolEvictor<T extends PoolParticipant>	PoolEvictors are responsible for finding the best candidates in a collection of resources using a shared resource pool and performing eviction on them.
PoolParticipant	A poolable store reports its resource usage to a Pool.
PreferredLoaderObjectInputStream	ObjectInputStream that uses a supplied classloader when resolving classes
PressuredStore	A store that can be under pressure...
ProductInfo	Build properties of the product
PropertyUtil	Property utilities.
ProviderMBeanRegistrationHelper	Helper class for registering mbeans for ehcache backed hibernate second level cache
ProxiedDynamicMBean	The ProxiedDynamicMBean.
Query	Creates queries for performing cache searches.
QueryManager	Main entry point from Ehcache into the query manager responsible for parsing SQL-like statements and returning a net.sf.ehcache.search.Query object.
QueryManagerBuilder	A Query Manager builder providing methods to add caches which can be queried.
QueryStats
RateImpl<T extends java.lang.Enum<T>>	The Class RateStatistic.
ReadCommittedSoftLockFactory	A factory of read-committed soft locks.
ReadCommittedSoftLockImpl	A SoftLock implementation with Read-Committed isolation level
ReadOnlyEhcacheCollectionRegionAccessStrategy	Ehcache specific read-only collection region access strategy
ReadOnlyEhcacheEntityRegionAccessStrategy	Ehcache specific read-only entity region access strategy
ReadThroughCache	This class implements the simplest of all possible read through cache behaviors, where a call the get() will delegate to a call to getWithLoader().
ReadThroughCacheConfiguration	This classed is used to programmatically configure a ReadThroughCache.
ReadThroughCacheFactory	CacheDecoratorFactory implementation for the ReadThroughCache cache decorator.
ReadWriteCopyStrategy<T>
ReadWriteEhcacheCollectionRegionAccessStrategy	Ehcache specific read/write collection region access strategy
ReadWriteEhcacheEntityRegionAccessStrategy	Ehcache specific read/write entity region access strategy
ReadWriteLockSync	A simple ReadWriteLock synchronizer.
ReadWriteSerializationCopyStrategy	A copy strategy that can use partial (if both copy on read and copy on write are set) or full Serialization to copy the object graph
ReflectionAttributeExtractor	Built-in search attribute extractor driven by method/value dotted expression chains. The expression chain must start with one of either "key", "value", or "element".
ReflectionSizeOf	SizeOf that uses reflection to measure on heap size of object graphs
RefreshAheadCache	A cache decorator which implements read ahead refreshing.
RefreshAheadCacheConfiguration	Fluent configuration class for RefreshAheadCache instances.
RefreshAheadCacheFactory	Cache decorator factory for RefreshAheadCache instances
Region	Class that represents the regions held within this set.
RegisteredEventListeners	Registered listeners for registering and unregistering CacheEventListeners and multicasting notifications to registrants.
RegisteredEventListeners.ElementCreationCallback	Callback interface for creating elements to pass to registered listeners.
RejoinCacheException	Exception type thrown for rejoins when non-stop is disabled.
RemoteCacheException	A Cache Exception in the distribution mechanism.
ResourceClassLoader	ResourceClassLoader can load classes nested in a subdirectory of a jar Example : ehcache.jar!/net/sf/ehcache/CacheManager is in the "normal" classpath and will be loaded by any typical classloader ehcache.jar!/subdirectory/net/sf/ehcache/CacheManager can only be loaded by the ResourceClassLoader, with prefix "subdirectory" Assumes classes under prefix directory to have ending .clazz
ResourceSizeOfFilter	Filters based on a configuration file
Result	Represents a single cache entry that has been selected by a cache query.
ResultImpl	Result implementation
Results	Results object for an execution of a Query.
ResultsImpl	Results implementation
RMIAsynchronousCacheReplicator	Listens to CacheManager and Cache events and propagates those to CachePeer peers of the Cache asynchronously.
RMIBootstrapCacheLoader	Loads Elements from a random Cache Peer
RMIBootstrapCacheLoaderFactory	A factory to create a configured RMIBootstrapCacheLoader
RMICacheManagerPeerListener	A cache server which exposes available cache operations remotely through RMI.
RMICacheManagerPeerListenerFactory	Builds a listener based on RMI.
RMICacheManagerPeerProvider	A provider of Peer RMI addresses.
RMICacheManagerPeerProviderFactory	Builds a factory based on RMI
RMICachePeer	An RMI based implementation of CachePeer.
RMICacheReplicatorFactory	Creates an RMICacheReplicator using properties.
RmiEventMessage
RmiEventMessage.RmiEventType	Enumeration of event types.
RMISynchronousCacheReplicator	Listens to CacheManager and Cache events and propagates those to CachePeer peers of the Cache.
SampledCache	An implementation of SampledCacheMBean
SampledCacheManager	An implementation of SampledCacheManagerMBean
SampledCacheManagerMBean	An MBean for CacheManager exposing sampled cache usage statistics
SampledCacheMBean	An MBean for Cache exposing cache statistics.
SampledCounter	Interface of a sampled counter -- a counter that keeps sampled values
SampledCounterConfig	Config for a SampledCounter
SampledCounterImpl	An implementation of SampledCounter
SampledCounterProxy<E extends java.lang.Number>	The Class SampledCounterProxy.
SampledEhcacheMBeans	Utility class used for getting ObjectName's for sampled MBeans
SampledMBeanRegistrationProvider	An implementation of MBeanRegistrationProvider which registers sampled MBeans for the CacheManager and its Caches.
SampledRateCounter	Interface of a sampled rate counter -- a counter that keeps sampled values of rates
SampledRateCounterConfig	An implementation of SampledCounterConfig
SampledRateCounterImpl	An implementation of SampledRateCounter
SampledRateCounterProxy<E extends java.lang.Number>	The Class SampledRateCounterProxy.
Searchable	Search configuration for a Cache
SearchableConfigurationElement	NodeElement representing a Searchable config element
SearchAttribute	A cache search attribute.
SearchException	A generic search exception.
SearchManager	Interface for ehcache search engine implementations
Segment	Segment implementation used in LocalStore.
SelectableConcurrentHashMap	SelectableConcurrentHashMap subclasses a repackaged version of ConcurrentHashMap ito allow efficient random sampling of the map values.
SelectableConcurrentHashMap.HashEntry
Selector	Abstract class which is used to do various things related to JTA transaction managers, like looking them up, registering XAResources for recovery...
SelfPopulatingCache	A selfpopulating decorator for Ehcache that creates entries on demand.
SemiExpiringStatistic<T extends java.lang.Number>	Statistic implementation that stops sampling history if the last history access is before a user supplied timestamp.
SerializableXid	A serializable XID
SerializationCopyStrategy	A copy strategy that uses full Serialization to copy the object graph
SetAsList<E>	Wraps a set to provide a list interface.
ShutdownListener	A ServletContextListener that shutsdown CacheManager.
SimpleNodeAttribute	Implementation of the NodeAttribute interface
SimpleNodeElement	A concrete class extending the AbstractNodeElement class
SingleOperation	Interface to implement single operations that are performed with write-behind
SingleOperationType	Enum class to provide distinct operation types for each single operation.
SingletonEhCacheProvider	Deprecated.
SingletonEhCacheRegionFactory	A singleton EhCacheRegionFactory implementation.
Size	Holder for the size calculated by the SizeOf engine
SizeOf	Abstract sizeOf for Java.
SizeOfEngine	SizeOf engines are used to calculate the size of elements stored in poolable stores.
SizeOfEngineFactory
SizeOfEngineLoader
SizeOfFilter	Filter to filter types or fields of object graphs passed to a SizeOf engine
SizeOfPolicyConfiguration	Class to hold the SizeOf policy configuration.
SizeOfPolicyConfiguration.MaxDepthExceededBehavior	Enum of the possible behaviors of the SizeOf engine when the max depth is exceeded
SizeOfPolicyConfigurationElement	Element representing the SizeOfPolicyConfiguration
SoftLock	A soft lock is used to lock elements in transactional stores
SoftLockFactory	A factory of soft-locks supporting a specific isolation level.
SoftLockID	A soft lock ID is used to uniquely identify a soft lock
SoftLockManager	A factory for SoftLocks
SoftLockManagerImpl	A SoftLockFactory implementation which creates soft locks with Read-Committed isolation level
StandardPassThroughStatistic
StatisticBuilder	The StatisticBuilder.
StatisticBuilder.OperationStatisticBuilder<T extends java.lang.Enum<T>>	The Class OperationStatisticBuilder.
StatisticsGateway	StatisticsGateway rollup class.
Status	A pre JDK1.5 compatible enum class to indicate the status of a CacheManager or Cache.
Store	Wrapper class for store specific dynamic mbeans.
Store	This is the interface for all stores.
StoreListener
StoreOperationOutcomes	The Interface StoreOperationOutcomes.
StoreOperationOutcomes.GetOutcome	The Enum GetOutcome.
StoreOperationOutcomes.PutOutcome	The Enum PutOutcome.
StoreOperationOutcomes.RemoveOutcome	The Enum RemoveOutcome.
StorePutCommand	Represents a Store.put(net.sf.ehcache.Element) put} operation to be executed on a Store.
StoreQuery	An immutable query that a Store can execute
StoreQuery.Ordering	An attribute / direction ordering pair
StoreRemoveCommand	Represents a remove operation to be executed on a Store.
StoreUpdateException	Exception thrown by the Store when the writer fails.
StrictlyBoundedPool	A pool which strictly obeys to its bound: it will never allow the accessors to consume more bytes than what has been configured.
StringBeanProxy	An impl of a String attribute proxy.
StripedReadWriteLock
StripedReadWriteLockProvider	Provider for StripedReadWriteLock that need to match a certain spreading function
StripedReadWriteLockSync	Provides a number of Sync which allow fine-grained concurrency.
StronglyConsistentCacheAccessor	StronglyConsistentCacheAccessor is a decorator that accepts distributed caches configured with eventual consistency.
Sum	Sums the results
Sync
TerracottaBootstrapCacheLoader	A BootstrapCacheLoader that will load Elements into a Terracotta clustered cache, based on a previously snapshotted key set.
TerracottaBootstrapCacheLoaderFactory
TerracottaCacheCluster	CacheCluster implementation that delegates to an underlying cache cluster.
TerracottaCacheEventReplication	Creates a wrapper for sending out cache events through the Terracotta cluster
TerracottaCacheEventReplicationFactory	Factory for TerracottaCacheEventReplication instances
TerracottaClient	Class encapsulating the idea of a Terracotta client.
TerracottaClientConfiguration	Holds the Terracotta configuration for a particular client
TerracottaConfigConfigurationElement	NodeElement representing the TerracottaClientConfiguration
TerracottaConfiguration	Class to hold the Terracotta configuration - either a pointer to the real config or a container for embedded config.
TerracottaConfiguration.Consistency	Enum for various consistency settings
TerracottaConfigurationElement	NodeElement representing the TerracottaConfiguration
TerracottaNotRunningException	Exception thrown when using Terracotta clustered operations and Terracotta is not running
TerracottaStore	Use for internal purpose only.
TerracottaTransactionalCopyingCacheStore	A copying cache store designed for transactional terracotta clustered stores
ThreadedWorkQueue<W>	This class implements a work queue of pooled objects.
ThreadedWorkQueue.BatchWorker<WW>	Callback class, think of it as a Runnable with an argument that is a Collection.
ThreadLocalRandom	A random number generator isolated to the current thread.
TimeoutBehaviorConfiguration	Configuration element for configuring timeoutBehavior for nonstop
TimeoutBehaviorConfiguration.TimeoutBehaviorType	Enum encapsulating type of TimeoutBehavior
TimeoutBehaviorConfigurationElement	NodeElement representing the TimeoutBehaviorConfiguration
TimeStampedCounterValue	A counter value at a particular time instance
Timestamper	Generates increasing identifiers (in a single VM only).
TimeUtil	Utilities for converting times
TransactionalEhcacheCollectionRegionAccessStrategy	JTA CollectionRegionAccessStrategy.
TransactionalEhcacheEntityRegionAccessStrategy	JTA EntityRegionAccessStrategy.
TransactionalRMICachePeer	An RMI based implementation of CachePeer supporting transactions.
TransactionController	TransactionController is used to begin, commit and rollback local transactions
TransactionException	Instances of this class or its subclasses are thrown when an error happen in the transaction subsystem
TransactionID	A transaction identifier.
TransactionIDFactory	A factory for transaction IDs.
TransactionIDFactoryImpl	A TransactionIDFactory implementation with uniqueness across a single JVM
TransactionIDImpl	A transaction ID implementation with uniqueness across a single JVM
TransactionIDNotFoundException	This exception is used when a transaction ID suddenly disappeared when trying to update its state.
TransactionIDSerializedForm	A replacement serialized form for transaction IDs.
TransactionInterruptedException	This exception is thrown when a transactional operation got interrupted via Thread.interrupt
TransactionListener	A listener interface to get called back when a transaction is being terminated
TransactionManagerLookup	Interface to enable a XA transactional cache to access the JTA TransactionManager.
TransactionTimeoutException	This exception is thrown when a transactional operation times out
TxCopyingCacheStore<T extends Store>	Copies elements, either on read, write or both before using the underlying store to actually store things.
TxCopyStrategyHandler
UnboundedPool	A no-op pool which does not enforce any resource consumption limit.
UnknownAttributeException	Thrown at query execution time if query referenced an unknown search attribute
UnsafeSizeOf	Unsafe.theUnsafe based sizeOf measurement All constructors will throw UnsupportedOperationException if theUnsafe isn't accessible on this platform
UpdatingCacheEntryFactory	A CacheEntryFactory with one additional method, updateEntryValue((Serializable key, Serializable value) which allows the cache entry to updated rather than replaced.
UpdatingSelfPopulatingCache	A Cache backed cache that creates entries on demand.
ValueObjectAttributeExtractor	Attempt to use the element value object itself as a search attribute.
VicariousThreadLocal<T>	A drop-in replacement ThreadLocal implementation that does not leak when thread-local values reference the ThreadLocal object.
VmUtils	Misc.
WeakIdentityConcurrentMap<K,V>	A poor man's implementation of a WeakIdentityConcurrentMap to hold the CacheManager associated ExecutorServices
WeakIdentityConcurrentMap.CleanUpTask<T>
WeblogicSelector	A Selector for the Weblogic Server's JTA transaction manager
WriteAllOperation	Implements the write all operation for write behind
WriteBehind	An interface for write behind behavior.
WriteBehindManager	Implements a WriterManager that writes elements to a queue first and in the background sends the to the CacheWriter.
WriteBehindQueueManager
WriteBehindQueueManager.WriteBehindQueueFactory	Factory used to create write behind queues.
WriteOperation	Implements the write operation for write behind
WriteThroughManager	Implements a WriterManager that writes elements directly through to the underlying store.
XaCommitOutcome	The Enum XaCommitOutcome.
XAExecutionListener	Listener interface which provides callback hooks for listening to the 2PC lifecycle
XaRecoveryOutcome	The Enum XaRecoveryOutcome.
XARequest
XARequest.RequestType	XA Requests types
XARequestProcessor	Default implementation for XARequestProcessor.
XaRollbackOutcome	The Enum XaRollbackOutcome.
XAThreadPool	Fast and minimalistic thread pool from which threads can be reserved and used many times until they are manually released.
XAThreadPool.MultiRunner	Pooled thread wrapper which allows reuse of the same thread
XATransactionContext	An XATransactionContext represents the data local to a Transaction that involves a transactional Cache.
XATransactionStore
XidTransactionID	A special TransactionID using a XID internally
XidTransactionIDImpl
XidTransactionIDSerializedForm	A replacement serialized form for XID transaction IDs.
XMLGeneratorVisitor	Implementation of an ElementVisitor extending from AbstractDepthFirstVisitor which can generate XML out of a NodeElement.
XMLGeneratorVisitor.OutputBehavior	Enum controlling the generated XML output