Search Java Classes and Packages

Search Java Frameworks and Libraries

255581 classes and counting ...
Search Tips Index Status



#Cache Classes and Interfaces - 2449 results found.
NameDescriptionTypePackageFramework
AbstractLayoutCache Serialized objects of this class will not be compatible with future Swing releases.Classjavax.swing.treeJava SE
AbstractLayoutCache .NodeDimensionsUsed by AbstractLayoutCache to determine the size and x origin of a particular node.Classjavax.swing.tree.AbstractLayoutCacheJava SE
AbstractRegionPainter .PaintContext .CacheModeReturns the enum constant of this type with Classjavax.swing.plaf.nimbus.AbstractRegionPainter.PaintContextJava SE
CacheRequestRepresents channels for storing resources in the ResponseCache.Classjava.netJava SE
CacheResponseRepresent channels for retrieving resources from the ResponseCache.Classjava.netJava SE
CachedRowSetThe interface that all standard implementations of CachedRowSet must implement.Interfacejavax.sql.rowsetJava SE
FileCacheImageInputStreamAn implementation of ImageInputStream that gets its input from a regular InputStream.Classjavax.imageio.streamJava SE
FileCacheImageOutputStreamAn implementation of ImageOutputStream that writes its output to a regular OutputStream.Classjavax.imageio.streamJava SE
FixedHeightLayoutCacheNOTE: This will become more open in a future release.Classjavax.swing.treeJava SE
MemoryCacheImageInputStreamAn implementation of ImageInputStream that gets its input from a regular InputStream.Classjavax.imageio.streamJava SE
MemoryCacheImageOutputStreamAn implementation of ImageOutputStream that writes its output to a regular OutputStream.Classjavax.imageio.streamJava SE
ResponseCacheRepresents implementations of URLConnection caches.Classjava.netJava SE
SecureCacheResponseRepresents a cache response originally retrieved through secure means, such as TLS.Classjava.netJava SE
VariableHeightLayoutCacheNOTE: This will become more open in a future release.Classjavax.swing.treeJava SE
CacheInterface used to interact with the second-level cache.Interfacejavax.persistenceJava EE
CacheableSpecifies whether an entity should be cached if caching is enabled when the value of the persistence.Classjavax.persistenceJava EE
CacheControlAn abstraction for the value of a HTTP Cache-Control response header.Classjavax.ws.rs.coreJava EE
CacheRetrieveModeenum CacheRetrieveModeUsed as the value of theClassjavax.persistenceJava EE
CacheStoreModeUsed as the value of the javax.Classjavax.persistenceJava EE
FaceletCacheThis API defines the facility by which the Facelets ViewDeclarationLanguageClassjavax.faces.view.faceletsJava EE
FaceletCache .MemberFactoryFactory interface for creating Facelet or View Metadata Facelet instances.Interfacejavax.faces.view.facelets.FaceletCacheJava EE
FaceletCacheFactoryAllows customization of the implementation of FaceletCache.Classjavax.faces.view.faceletsJava EE
SharedCacheModeenum SharedCacheModeSpecifies how the provider must use a second-level cache for theClassjavax.persistenceJava EE
CacheHintCache hints for use with Node.Classjavafx.sceneJava FX
CachingConnectionFactory .CacheModeCache channels - single connectionCache connections and channels within each connectionClassorg.springframework.amqp.rabbit.connection.CachingConnectionFactorySpring AMQP
AbstractJmxCacheStatisticsProviderBase CacheStatisticsProvider implementation that uses JMX to retrieve the cacheSince:1.Classorg.springframework.boot.actuate.cacheSpring Boot
CacheAutoConfigurationAuto-configuration for the cache abstraction.Classorg.springframework.boot.autoconfigure.cacheSpring Boot
CacheAutoConfiguration .CacheManagerJpaDependencyConfigurationClassorg.springframework.boot.autoconfigure.cache.CacheAutoConfigurationSpring Boot
CachePropertiesConfiguration properties for the cache abstraction.Classorg.springframework.boot.autoconfigure.cacheSpring Boot
CacheProperties .EhCacheEhCache specific cache properties.Classorg.springframework.boot.autoconfigure.cache.CachePropertiesSpring Boot
CacheProperties .GuavaGuava specific cache properties.Classorg.springframework.boot.autoconfigure.cache.CachePropertiesSpring Boot
CacheProperties .HazelcastHazelcast specific cache properties.Classorg.springframework.boot.autoconfigure.cache.CachePropertiesSpring Boot
CacheProperties .InfinispanInfinispan specific cache properties.Classorg.springframework.boot.autoconfigure.cache.CachePropertiesSpring Boot
CacheProperties .JCacheJCache (JSR-107) specific cache properties.Classorg.springframework.boot.autoconfigure.cache.CachePropertiesSpring Boot
CachePublicMetricsA PublicMetrics implementation that provides cache statistics.Classorg.springframework.boot.actuate.endpointSpring Boot
CacheStatisticsSnapshot of the statistics of a given cache.Interfaceorg.springframework.boot.actuate.cacheSpring Boot
CacheStatisticsAutoConfigurationAuto-configuration for CacheStatisticsProviderSince:1.Classorg.springframework.boot.actuate.autoconfigureSpring Boot
CacheStatisticsProviderProvide a CacheStatistics based on a Cache.Interfaceorg.springframework.boot.actuate.cacheSpring Boot
CacheTypeSupported cache types (defined in order of precedence).Classorg.springframework.boot.autoconfigure.cacheSpring Boot
ConcurrentMapCacheStatisticsProviderCacheStatisticsProvider implementation for ConcurrentMapCache.Classorg.springframework.boot.actuate.cacheSpring Boot
DefaultCacheStatisticsA default CacheStatistics implementation.Classorg.springframework.boot.actuate.cacheSpring Boot
EhCacheStatisticsProviderCacheStatisticsProvider implementation for EhCache.Classorg.springframework.boot.actuate.cacheSpring Boot
GuavaCacheStatisticsProviderCacheStatisticsProvider implementation for Guava.Classorg.springframework.boot.actuate.cacheSpring Boot
HazelcastCacheStatisticsProviderCacheStatisticsProvider implementation for Hazelcast.Classorg.springframework.boot.actuate.cacheSpring Boot
InfinispanCacheConfigurationInfinispan cache configuration.Classorg.springframework.boot.autoconfigure.cacheSpring Boot
InfinispanCacheStatisticsProviderCacheStatisticsProvider implementation for Infinispan.Classorg.springframework.boot.actuate.cacheSpring Boot
JCacheCacheStatisticsProviderCacheStatisticsProvider implementation for a JSR-107 compliant cache.Classorg.springframework.boot.actuate.cacheSpring Boot
JCacheManagerCustomizerCallback interface that can be implemented by beans wishing to customize the cachemanager before it is used, in particular to create additional caches.Interfaceorg.springframework.boot.autoconfigure.cacheSpring Boot
CacheWritingMessageHandlerA MessageHandler implementation that writes to a GemFire Region.Classorg.springframework.integration.gemfire.outboundSpring Integration
CacheListeningMessageProducerAn inbound endpoint that listens to a GemFire region for events and then publishes Messages toa channel.Classorg.springframework.integration.gemfire.inboundSpring Integration
AbstractCacheInvokerA base component for invoking Cache operations and using aconfigurable CacheErrorHandler when an exception occurs.Classorg.springframework.cache.interceptorSpring MVC
AbstractCacheManagerAbstract base class implementing the common CacheManager methods.Classorg.springframework.cache.supportSpring MVC
AbstractCacheResolverA base CacheResolver implementation that requires the concreteSince:4.Classorg.springframework.cache.interceptorSpring MVC
AbstractFallbackCacheOperationSourceAbstract implementation of CacheOperation that cachesattributes for methods and implements a fallback policy: 1.Classorg.springframework.cache.interceptorSpring MVC
AbstractFallbackJCacheOperationSourceAbstract implementation of JCacheOperationSource that caches attributesfor methods and implements a fallback policy: 1.Classorg.springframework.cache.jcache.interceptorSpring MVC
AbstractJCacheConfigurationAbstract JSR-107 specific @Configuration class providing commonstructure for enabling JSR-107 annotation-driven cache management capability.Classorg.springframework.cache.jcache.configSpring MVC
AbstractTransactionSupportingCacheManagerBase class for CacheManager implementations that want to support built-inawareness of Spring-managed transactions.Classorg.springframework.cache.transactionSpring MVC
AbstractValueAdaptingCacheCommon base class for Cache implementations that need to adaptnull values (and potentially other such special values) beforeClassorg.springframework.cache.supportSpring MVC
AnnotationCacheOperationSourceThis class reads Spring's Cacheable, CachePut and CacheEvictannotations and exposes corresponding caching operation definition to Spring's cacheClassorg.springframework.cache.annotationSpring MVC
AnnotationCacheOperationSource .CacheOperationProviderCallback interface providing CacheOperation instance(s) based ona given CacheAnnotationParser.Interfaceorg.springframework.cache.annotation.AnnotationCacheOperationSourceSpring MVC
AnnotationJCacheOperationSourcethe JSR-107 CacheResult, CachePut, CacheRemove andCacheRemoveAll annotations.Classorg.springframework.cache.jcache.interceptorSpring MVC
AppCacheManifestTransformerA ResourceTransformer implementation that helps handling resourceswithin HTML5 AppCache manifests for HTML5 offline applications.Classorg.springframework.web.servlet.resourceSpring MVC
AspectJJCacheConfiguration@Configuration class that registers the Spring infrastructure beans necessaryto enable AspectJ-based annotation-driven cache management for standard JSR-107Classorg.springframework.cache.aspectjSpring MVC
BeanFactoryCacheOperationSourceAdvisorAdvisor driven by a CacheOperationSource, used to include acache advice bean for methods that are cacheable.Classorg.springframework.cache.interceptorSpring MVC
BeanFactoryJCacheOperationSourceAdvisorAdvisor driven by a JCacheOperationSource, used to include acache advice bean for methods that are cacheable.Classorg.springframework.cache.jcache.interceptorSpring MVC
CacheInterface that defines common cache operations.Interfaceorg.springframework.cacheSpring MVC
Cache .ValueWrapperA (wrapper) object representing a cache value.Interfaceorg.springframework.cache.CacheSpring MVC
CacheableAnnotation indicating that the result of invoking a method (or all methodsin a class) can be cached.Classorg.springframework.cache.annotationSpring MVC
CacheableOperationClass describing a cache 'cacheable' operation.Classorg.springframework.cache.interceptorSpring MVC
CacheAnnotationParserStrategy interface for parsing known caching annotation types.Interfaceorg.springframework.cache.annotationSpring MVC
CacheAspectSupportBase class for caching aspects, such as the CacheInterceptoror an AspectJ aspect.Classorg.springframework.cache.interceptorSpring MVC
CacheAspectSupport .CacheOperationMetadataMetadata of a cache operation that does not depend on a particular invocationwhich makes it a good candidate for caching.Classorg.springframework.cache.interceptor.CacheAspectSupportSpring MVC
CacheAwareContextLoaderDelegateA CacheAwareContextLoaderDelegate is responsible for loading and closing applicationcontexts, interacting transparently with aInterfaceorg.springframework.test.contextSpring MVC
CacheConfig@CacheConfig provides a mechanism for sharing common cache-relatedsettings at the class level.Classorg.springframework.cache.annotationSpring MVC
CacheControlA builder for creating Cache-Control HTTP response headers.Classorg.springframework.httpSpring MVC
CachedExpressionEvaluatorShared utility class used to evaluate and cache SpEL expressions thatare defined on AnnotatedElement.Classorg.springframework.context.expressionSpring MVC
CachedExpressionEvaluator .ExpressionKeyClassorg.springframework.context.expression.CachedExpressionEvaluatorSpring MVC
CachedIntrospectionResultsInternal class that caches JavaBeans PropertyDescriptorinformation for a Java class.Classorg.springframework.beansSpring MVC
CacheErrorHandlerA strategy for handling cache-related errors.Interfaceorg.springframework.cache.interceptorSpring MVC
CacheEvictAnnotation indicating that a method (or all methods on a class) triggers acache evict operation.Classorg.springframework.cache.annotationSpring MVC
CacheEvictOperationClass describing a cache 'evict' operation.Classorg.springframework.cache.interceptorSpring MVC
CacheInterceptorAOP Alliance MethodInterceptor for declarative cachemanagement using the common Spring caching infrastructureClassorg.springframework.cache.interceptorSpring MVC
CacheManagementConfigUtilsConfiguration constants for internal sharing across subpackages.Classorg.springframework.cache.configSpring MVC
CacheManagerSpring's central cache manager SPI.Interfaceorg.springframework.cacheSpring MVC
CacheNamespaceHandlerNamespaceHandler allowing for the configuration of declarativecache management using either XML or using annotations.Classorg.springframework.cache.configSpring MVC
CacheOperationBase class for cache operations.Classorg.springframework.cache.interceptorSpring MVC
CacheOperationInvocationContextRepresentation of the context of the invocation of a cache operation.Interfaceorg.springframework.cache.interceptorSpring MVC
CacheOperationInvokerAbstract the invocation of a cache operation.Interfaceorg.springframework.cache.interceptorSpring MVC
CacheOperationInvoker .ThrowableWrapperWrap any exception thrown while invoking CacheOperationInvoker.Classorg.springframework.cache.interceptor.CacheOperationInvokerSpring MVC
CacheOperationSourceInterface used by CacheInterceptor.Interfaceorg.springframework.cache.interceptorSpring MVC
CacheProxyFactoryBeanProxy factory bean for simplified declarative caching handling.Classorg.springframework.cache.interceptorSpring MVC
CachePutAnnotation indicating that a method (or all methods on a class) triggers acache put operation.Classorg.springframework.cache.annotationSpring MVC
CachePutOperationClass describing a cache 'put' operation.Classorg.springframework.cache.interceptorSpring MVC
CacheResolverDetermine the Cache instance(s) to use for an intercepted method invocation.Interfaceorg.springframework.cache.interceptorSpring MVC
CompositeCacheManagerComposite CacheManager implementation that iterates overa given collection of delegate CacheManager instances.Classorg.springframework.cache.supportSpring MVC
CompositeCacheOperationSourceComposite CacheOperationSource implementation that iteratesover a given array of CacheOperationSource instances.Classorg.springframework.cache.interceptorSpring MVC
ConcurrentMapCacheSimple Cache implementation based on thecore JDK java.Classorg.springframework.cache.concurrentSpring MVC
ConcurrentMapCacheFactoryBeanFactoryBean for easy configuration of a ConcurrentMapCachewhen used within a Spring container.Classorg.springframework.cache.concurrentSpring MVC
ConcurrentMapCacheManagerCacheManager implementation that lazily builds ConcurrentMapCacheinstances for each getCache(java.Classorg.springframework.cache.concurrentSpring MVC
ContextCacheContextCache defines the SPI for caching SpringApplicationContexts within the SpringInterfaceorg.springframework.test.context.cacheSpring MVC
DefaultCacheAwareContextLoaderDelegateDefault implementation of the CacheAwareContextLoaderDelegate interface.Classorg.springframework.test.context.cacheSpring MVC
DefaultContextCacheDefault implementation of the ContextCache API.Classorg.springframework.test.context.cacheSpring MVC
DefaultJCacheOperationSourceThe default JCacheOperationSource implementation delegatingdefault operations to configurable services with sensible defaultsClassorg.springframework.cache.jcache.interceptorSpring MVC
EhCacheCacheCache implementation on top of an Ehcache instance.Classorg.springframework.cache.ehcacheSpring MVC
EhCacheCacheManagerCacheManager backed by an EhCache CacheManager.Classorg.springframework.cache.ehcacheSpring MVC
EhCacheFactoryBeanFactoryBean that creates a named EhCache Cache instance(or a decorator that implements the Ehcache interface),Classorg.springframework.cache.ehcacheSpring MVC
EhCacheManagerFactoryBeanFactoryBean that exposes an EhCache CacheManagerinstance (independent or shared), configured from a specified config location.Classorg.springframework.cache.ehcacheSpring MVC
EhCacheManagerUtilsConvenient builder methods for EhCache 2.Classorg.springframework.cache.ehcacheSpring MVC
GuavaCacheSpring Cache adapter implementationon top of a Guava Cache instance.Classorg.springframework.cache.guavaSpring MVC
GuavaCacheManagerCacheManager implementation that lazily builds GuavaCacheinstances for each getCache(java.Classorg.springframework.cache.guavaSpring MVC
JCacheAspectSupportBase class for JSR-107 caching aspects, such as the JCacheInterceptoror an AspectJ aspect.Classorg.springframework.cache.jcache.interceptorSpring MVC
JCacheCacheCache implementation on top of aNote: This class has been updated for JCache 1.Classorg.springframework.cache.jcacheSpring MVC
JCacheCacheManagerCacheManager implementationbacked by a JCache CacheManager.Classorg.springframework.cache.jcacheSpring MVC
JCacheConfigurerExtension of CachingConfigurer for the JSR-107 implementation.Interfaceorg.springframework.cache.jcache.configSpring MVC
JCacheConfigurerSupportAn extension of CachingConfigurerSupport that also implementsUsers of JSR-107 annotations may extend from this class rather thanClassorg.springframework.cache.jcache.configSpring MVC
JCacheInterceptorAOP Alliance MethodInterceptor for declarative cachemanagement using JSR-107 caching annotations.Classorg.springframework.cache.jcache.interceptorSpring MVC
JCacheManagerFactoryBeanFactoryBean for a JCache CacheManager,obtaining a pre-defined CacheManager by name through the standardClassorg.springframework.cache.jcacheSpring MVC
JCacheOperationModel the base of JSR-107 cache operation.Interfaceorg.springframework.cache.jcache.interceptorSpring MVC
JCacheOperationSourceInterface used by JCacheInterceptor.Interfaceorg.springframework.cache.jcache.interceptorSpring MVC
JCacheOperationSourcePointcutA Pointcut that matches if the underlying JCacheOperationSourcehas an operation for a given method.Classorg.springframework.cache.jcache.interceptorSpring MVC
MockCacheControlMock implementation of the CacheControl interface.Classorg.springframework.mock.web.portletSpring MVC
NamedCacheResolverA CacheResolver that forces the resolution to a configurablecollection of name(s) against a given CacheManager.Classorg.springframework.cache.interceptorSpring MVC
NameMatchCacheOperationSourceSimple CacheOperationSource implementation that allows attributes to be matchedSince:3.Classorg.springframework.cache.interceptorSpring MVC
NoOpCacheManagerA basic, no operation CacheManager implementation suitablefor disabling caching, typically used for backing cache declarationsClassorg.springframework.cache.supportSpring MVC
ProxyJCacheConfiguration@Configuration class that registers the Spring infrastructure beans necessaryto enable proxy-based annotation-driven JSR-107 cache management.Classorg.springframework.cache.jcache.configSpring MVC
SimpleCacheErrorHandlerA simple CacheErrorHandler that does not handle theexception at all, simply throwing it back at the client.Classorg.springframework.cache.interceptorSpring MVC
SimpleCacheManagerSimple cache manager working against a given collection of caches.Classorg.springframework.cache.supportSpring MVC
SimpleCacheResolverA simple CacheResolver that resolves the Cache instance(s)based on a configurable CacheManager and the name of theClassorg.springframework.cache.interceptorSpring MVC
SimpleExceptionCacheResolverA simple CacheResolver that resolves the exception cachebased on a configurable CacheManager and the name of theClassorg.springframework.cache.jcache.interceptorSpring MVC
SpringCacheAnnotationParserStrategy implementation for parsing Spring's Caching, Cacheable,CacheEvict, and CachePut annotations.Classorg.springframework.cache.annotationSpring MVC
TransactionAwareCacheDecoratorCache decorator which synchronizes its put(java.Classorg.springframework.cache.transactionSpring MVC
TransactionAwareCacheManagerProxyProxy for a target CacheManager, exposing transaction-aware Cache objectswhich synchronize their Cache.Classorg.springframework.cache.transactionSpring MVC
AclCacheInterfaceapidocs.orgSpring Security
AclPermissionCacheOptimizerClassapidocs.orgSpring Security
CacheControlHeadersWriterClassapidocs.orgSpring Security
EhCacheBasedAclCacheClassapidocs.orgSpring Security
EhCacheBasedTicketCacheClassapidocs.orgSpring Security
EhCacheBasedUserCacheClassapidocs.orgSpring Security
HttpSessionRequestCacheClassapidocs.orgSpring Security
NullRequestCacheClassapidocs.orgSpring Security
NullStatelessTicketCacheClassapidocs.orgSpring Security
NullUserCacheClassapidocs.orgSpring Security
PermissionCacheOptimizerInterfaceapidocs.orgSpring Security
RequestCacheInterfaceapidocs.orgSpring Security
RequestCacheAwareFilterClassapidocs.orgSpring Security
RequestCacheConfigurerClassapidocs.orgSpring Security
SpringCacheBasedAclCacheClassapidocs.orgSpring Security
SpringCacheBasedTicketCacheClassapidocs.orgSpring Security
SpringCacheBasedUserCacheClassapidocs.orgSpring Security
StatelessTicketCacheInterfaceapidocs.orgSpring Security
UserCacheInterfaceapidocs.orgSpring Security
EhCacheBasedX509UserCacheCaches User objects using a Spring IoC defined EHCACHE.Classorg.springframework.ws.soap.security.x509.cacheSpring WebService
NullX509UserCacheCache that doesn't do any caching.Classorg.springframework.ws.soap.security.x509.cacheSpring WebService
X509UserCacheProvides a cache of UserDetails objects for theX509AuthenticationProvider.Interfaceorg.springframework.ws.soap.security.x509.cacheSpring WebService
CacheServerA simple driver class to run a Gemfire cache server.Classorg.springframework.xd.gemfire.serverSpring XD
LoggingCacheListenerA simple cache listener that will log events.Classorg.springframework.xd.gemfire.serverSpring XD
SoftReferenceCacheThis is a thread safe cache who's implementation is based on a SoftReference so the cache may be cleared if the JVM is running low on memory.Classoracle.adf.view.rich.utilOracle ADF
AddCacheRequestClassamazonaws.servicesAmazon AWS
AddCacheResultClassamazonaws.servicesAmazon AWS
AmazonElastiCacheInterfaceamazonaws.servicesAmazon AWS
AmazonElastiCacheAsyncInterfaceamazonaws.servicesAmazon AWS
AmazonElastiCacheAsyncClientClassamazonaws.servicesAmazon AWS
AmazonElastiCacheClientClassamazonaws.servicesAmazon AWS
AuthorizeCacheSecurityGroupIngressRequestClassamazonaws.servicesAmazon AWS
CacheBehaviorClassamazonaws.servicesAmazon AWS
CacheBehaviorsClassamazonaws.servicesAmazon AWS
CacheClusterClassamazonaws.servicesAmazon AWS
CacheClusterAlreadyExistsExceptionClassamazonaws.servicesAmazon AWS
CacheClusterNotFoundExceptionClassamazonaws.servicesAmazon AWS
CachediSCSIVolumeClassamazonaws.servicesAmazon AWS
CachedMethodsClassamazonaws.servicesAmazon AWS
CacheEngineVersionClassamazonaws.servicesAmazon AWS
CacheNodeClassamazonaws.servicesAmazon AWS
CacheNodeTypeSpecificParameterClassamazonaws.servicesAmazon AWS
CacheNodeTypeSpecificValueClassamazonaws.servicesAmazon AWS
CacheParameterGroupClassamazonaws.servicesAmazon AWS
CacheParameterGroupAlreadyExistsExceptionClassamazonaws.servicesAmazon AWS
CacheParameterGroupNotFoundExceptionClassamazonaws.servicesAmazon AWS
CacheParameterGroupQuotaExceededExceptionClassamazonaws.servicesAmazon AWS
CacheParameterGroupStatusClassamazonaws.servicesAmazon AWS
CacheSecurityGroupClassamazonaws.servicesAmazon AWS
CacheSecurityGroupAlreadyExistsExceptionClassamazonaws.servicesAmazon AWS
CacheSecurityGroupMembershipClassamazonaws.servicesAmazon AWS
CacheSecurityGroupNotFoundExceptionClassamazonaws.servicesAmazon AWS
CacheSecurityGroupQuotaExceededExceptionClassamazonaws.servicesAmazon AWS
CacheSubnetGroupClassamazonaws.servicesAmazon AWS
CacheSubnetGroupAlreadyExistsExceptionClassamazonaws.servicesAmazon AWS
CacheSubnetGroupInUseExceptionClassamazonaws.servicesAmazon AWS
CacheSubnetGroupNotFoundExceptionClassamazonaws.servicesAmazon AWS
CacheSubnetGroupQuotaExceededExceptionClassamazonaws.servicesAmazon AWS
CacheSubnetQuotaExceededExceptionClassamazonaws.servicesAmazon AWS
CreateCacheClusterRequestClassamazonaws.servicesAmazon AWS
CreateCachediSCSIVolumeRequestClassamazonaws.servicesAmazon AWS
CreateCachediSCSIVolumeResultClassamazonaws.servicesAmazon AWS
CreateCacheParameterGroupRequestClassamazonaws.servicesAmazon AWS
CreateCacheSecurityGroupRequestClassamazonaws.servicesAmazon AWS
CreateCacheSubnetGroupRequestClassamazonaws.servicesAmazon AWS
DefaultCacheBehaviorClassamazonaws.servicesAmazon AWS
DeleteCacheClusterRequestClassamazonaws.servicesAmazon AWS
DeleteCacheParameterGroupRequestClassamazonaws.servicesAmazon AWS
DeleteCacheSecurityGroupRequestClassamazonaws.servicesAmazon AWS
DeleteCacheSubnetGroupRequestClassamazonaws.servicesAmazon AWS
DescribeCacheClustersRequestClassamazonaws.servicesAmazon AWS
DescribeCacheClustersResultClassamazonaws.servicesAmazon AWS
DescribeCachediSCSIVolumesRequestClassamazonaws.servicesAmazon AWS
DescribeCachediSCSIVolumesResultClassamazonaws.servicesAmazon AWS
DescribeCacheEngineVersionsRequestClassamazonaws.servicesAmazon AWS
DescribeCacheEngineVersionsResultClassamazonaws.servicesAmazon AWS
DescribeCacheParameterGroupsRequestClassamazonaws.servicesAmazon AWS
DescribeCacheParameterGroupsResultClassamazonaws.servicesAmazon AWS
DescribeCacheParametersRequestClassamazonaws.servicesAmazon AWS
DescribeCacheParametersResultClassamazonaws.servicesAmazon AWS
DescribeCacheRequestClassamazonaws.servicesAmazon AWS
DescribeCacheResultClassamazonaws.servicesAmazon AWS
DescribeCacheSecurityGroupsRequestClassamazonaws.servicesAmazon AWS
DescribeCacheSecurityGroupsResultClassamazonaws.servicesAmazon AWS
DescribeCacheSubnetGroupsRequestClassamazonaws.servicesAmazon AWS
DescribeCacheSubnetGroupsResultClassamazonaws.servicesAmazon AWS
DescribeReservedCacheNodesOfferingsRequestClassamazonaws.servicesAmazon AWS
DescribeReservedCacheNodesOfferingsResultClassamazonaws.servicesAmazon AWS
DescribeReservedCacheNodesRequestClassamazonaws.servicesAmazon AWS
DescribeReservedCacheNodesResultClassamazonaws.servicesAmazon AWS
ElastiCacheActionsClassamazonaws.authAmazon AWS
InsufficientCacheClusterCapacityExceptionClassamazonaws.servicesAmazon AWS
InvalidCacheClusterStateExceptionClassamazonaws.servicesAmazon AWS
InvalidCacheParameterGroupStateExceptionClassamazonaws.servicesAmazon AWS
InvalidCacheSecurityGroupStateExceptionClassamazonaws.servicesAmazon AWS
ModifyCacheClusterRequestClassamazonaws.servicesAmazon AWS
ModifyCacheParameterGroupRequestClassamazonaws.servicesAmazon AWS
ModifyCacheParameterGroupResultClassamazonaws.servicesAmazon AWS
ModifyCacheSubnetGroupRequestClassamazonaws.servicesAmazon AWS
PurchaseReservedCacheNodesOfferingRequestClassamazonaws.servicesAmazon AWS
RebootCacheClusterRequestClassamazonaws.servicesAmazon AWS
Cache The interface is similar to java.Interfaceorg.zkoss.utilZKoss (ZK)
CacheMapThe cache map.Classorg.zkoss.utilZKoss (ZK)
CacheMap .ValueThe class to hold key/value.Classorg.zkoss.util.CacheMapZKoss (ZK)
ConcurrentCacheClassorg.zkoss.zel.impl.utilZKoss (ZK)
DesktopCacheThe cache used to store desktops.Interfaceorg.zkoss.zk.ui.sysZKoss (ZK)
DesktopCacheProviderUsed to retrieve a desktop cache (DesktopCache).Interfaceorg.zkoss.zk.ui.sysZKoss (ZK)
FastReadCacheA CacheMap that the possibility to have cache hit is much more than not.Classorg.zkoss.utilZKoss (ZK)
GlobalDesktopCacheProviderA implementation of DesktopCacheProvider that stores all desktops from the same Web application into one desktop cache.Classorg.zkoss.zk.ui.implZKoss (ZK)
JQueryRenderCachedPatchUsed to patch the rendering result of a ZK portlet for Liferay.Classorg.zkoss.zkplus.liferayZKoss (ZK)
MultiCacheA CacheMap that uses multiple instanceof CacheMap to speed up It creates multiple instances of CacheMap, calledClassorg.zkoss.utilZKoss (ZK)
ResourceCacheUsed to cache resources.Classorg.zkoss.util.resourceZKoss (ZK)
ResourceCacheUsed to cache Servlet resources.Classorg.zkoss.web.util.resourceZKoss (ZK)
ResourceCachesUtilities to load (and parse) the Servlet resource.Classorg.zkoss.web.util.resourceZKoss (ZK)
SessionCacheThe cache for storing ZK sessions.Interfaceorg.zkoss.zk.ui.sysZKoss (ZK)
SessionDesktopCacheProviderA implementation of DesktopCacheProvider that stores all desktops from the same session in one desktop cache.Classorg.zkoss.zk.ui.implZKoss (ZK)
SimpleDesktopCacheA simple implementation of DesktopCache.Classorg.zkoss.zk.ui.implZKoss (ZK)
SimpleSessionCacheA simple implementation of SessionCache.Classorg.zkoss.zk.ui.httpZKoss (ZK)
CacheExceptionClassbr.com.caelum.vraptor.cacheVRaptor
CacheStoreInterfacebr.com.caelum.vraptor.cacheVRaptor
DefaultCacheStoreClassbr.com.caelum.vraptor.cacheVRaptor
InterceptorStackHandlersCacheCache all instances of InterceptorHandler when application starts.Classbr.com.caelum.vraptor.coreVRaptor
LRUCacheFactoryClassbr.com.caelum.vraptor.cacheVRaptor
LRUCacheStoreA LRU cache based on LinkedHashMap.Classbr.com.caelum.vraptor.cacheVRaptor
CacheGeneral purpose cache.Interfaceorg.jivesoftware.util.cacheEcho
CacheableInterface that defines the necessary behavior for objects added to a Cache.Interfaceorg.jivesoftware.util.cacheEcho
CachedPreparedStatementAllows PreparedStatement information to be cached.Classorg.jivesoftware.databaseEcho
CacheFactoryCreates Cache objects.Classorg.jivesoftware.util.cacheEcho
CacheFactoryStrategyInterfaceorg.jivesoftware.util.cacheEcho
CacheInfoConfiguration to use when creating caches.Classorg.jivesoftware.openfire.containerEcho
CacheInfo .TypeAn distributed-scheme defines caches where the storage for entries is partitioned across cluster nodes.Classorg.jivesoftware.openfire.container.CacheInfoEcho
CacheSizesUtility class for determining the sizes in bytes of commonly used objects.Classorg.jivesoftware.util.cacheEcho
CacheWrapperActs as a proxy for a Cache implementation.Classorg.jivesoftware.util.cacheEcho
ComponentCacheWrapperThis specialized wrapper is used for the Components cache, which should not be purged.Classorg.jivesoftware.util.cacheEcho
DefaultCacheDefault, non-distributed implementation of the Cache interface.Classorg.jivesoftware.util.cacheEcho
DefaultLocalCacheStrategyCacheFactoryStrategy for use in Openfire.Classorg.jivesoftware.util.cacheEcho
PluginCacheConfiguratorA helper class to read cache configuration data for a plugin and register the defined caches with the cache factory.Classorg.jivesoftware.openfire.containerEcho
PluginCacheRegistryA simple registry of cache configuration data for plugins.Classorg.jivesoftware.openfire.containerEcho
AWPageCacheMarkInterfaceariba.ui.aribaweb.coreAriba Web
UIMeta .LocalizedStringCacheConstructor SummaryUIMeta.Classariba.ui.meta.core.UIMetaAriba Web
CachedObjectWrapper for an object you want to store in a cache for a period ofVersion:$Id: CachedObject.Classorg.apache.turbine.services.cacheApache Turbine
GlobalCacheServiceGlobalCacheService interface.Interfaceorg.apache.turbine.services.cacheApache Turbine
RefreshableCachedObjectThe idea of the RefreshableCachedObject is that, rather than removing items from the cache when they become stale, we'll tell them toClassorg.apache.turbine.services.cacheApache Turbine
TurbineGlobalCacheThis is a Facade class for GlobalCacheService.Classorg.apache.turbine.services.cacheApache Turbine
TurbineGlobalCacheServiceThis Service functions as a Global Cache.Classorg.apache.turbine.services.cacheApache Turbine
BytestreamCacheA wrapper around a byte-stream, represented internally as a byte array.Classorg.apache.tapestry5.internal.services.assetsApache Tapestry
CacheQuick and dirty key/value cache that is subclassed to provide the logic that generates the value forConstructor SummaryCache()Classorg.apache.tapestry5.internal.plasticApache Tapestry
CachedIndicates that a method should only be evaluated once per request and the result cached.Classorg.apache.tapestry5.annotationsApache Tapestry
CachedWorkerCaches method return values for methods annotated with Cached.Classorg.apache.tapestry5.internal.transformApache Tapestry
ComponentClassCacheA cache for converting between class names and component (or other) classes.Interfaceorg.apache.tapestry5.internal.servicesApache Tapestry
ComponentClassCacheImplClassorg.apache.tapestry5.internal.servicesApache Tapestry
MethodResultCacheManages a cache value as the result of invoking a no-arguments method.Interfaceorg.apache.tapestry5.internal.transformApache Tapestry
NameCacheA cache of translations from type names to internal names and descriptors, as well as a cache from MethodDescription to method descriptor.Classorg.apache.tapestry5.internal.plasticApache Tapestry
NonPoolingRequestPageCacheImplIn Tapestry 5.Classorg.apache.tapestry5.internal.servicesApache Tapestry
RequestPageCachePer-thread service that caches page instances for the duration of the request, and is also responsible for tracking the active page (the page which will ultimately render the response).Interfaceorg.apache.tapestry5.internal.servicesApache Tapestry
ReferenceCacheClasscom.opensymphony.xwork2.inject.utilApache Struts
CachedSecurityEvaluatorA SecurityEvaluator that can be cached for later use.Classorg.apache.jena.permissions.implApache Jena
IndexCacheClassorg.apache.jena.sdb.layout2.indexApache Jena
AggregatedCacheValidityA validation object aggregating several validity objects.Classorg.apache.cocoon.cachingApache Cocoon
CacheThis is the Cocoon cache.Interfaceorg.apache.cocoon.cachingApache Cocoon
CacheableThis marker interface declares a (sitemap) component as cacheable.Interfaceorg.apache.cocoon.cachingApache Cocoon
CacheableProcessingComponentThis marker interface declares a (sitemap) component as cacheable.Interfaceorg.apache.cocoon.cachingApache Cocoon
CachedEventObjectThis is a cached object as it is stored in the EventCacheVersion:CVS $Id: CachedEventObject.Classorg.apache.cocoon.cachingApache Cocoon
CachedResponseThis is a cached response.Classorg.apache.cocoon.cachingApache Cocoon
CachedSourceResponseCached response for caching Source contents and extra meta information.Classorg.apache.cocoon.components.source.implApache Cocoon
CachedStreamObjectThis is an cached object as it is stored in the StreamCacheVersion:CVS $Id: CachedStreamObject.Classorg.apache.cocoon.cachingApache Cocoon
CacheEventActionSimple action to cause notification of a NamedEvent to an EventAwareCacheImpl.Classorg.apache.cocoon.actingApache Cocoon
CacheImplThis is the Cocoon cache.Classorg.apache.cocoon.caching.implApache Cocoon
CacheManagerWork interface for the component that caches objects for Cocoon Forms.Interfaceorg.apache.cocoon.formsApache Cocoon
CacheManagerWork interface for the component that caches objects for Woody.Interfaceorg.apache.cocoon.woodyApache Cocoon
CacheValidityA CacheValidity object contains all information for one pipeline component to check if it is still valid.Interfaceorg.apache.cocoon.cachingApache Cocoon
CacheValidityToSourceValidityA CacheValidity object wrapping the Avalon Excalibur SourceValidity object.Classorg.apache.cocoon.cachingApache Cocoon
ClearCacheActionSimple action which ensures the cache is cleared of allVersion:CVS $Id: ClearCacheAction.Classorg.apache.cocoon.actingApache Cocoon
ComponentCacheKeyThis is the cache key for one sitemap component.Classorg.apache.cocoon.cachingApache Cocoon
CompositeCacheValidityA validation object aggregating two validity objects.Classorg.apache.cocoon.cachingApache Cocoon
Convertor .FormatCacheInterfaceorg.apache.cocoon.forms.datatype.convertor.ConvertorApache Cocoon
Convertor .FormatCacheInterfaceorg.apache.cocoon.woody.datatype.convertor.ConvertorApache Cocoon
DatabaseAction .CacheHelperStructure that takes all processed data for a table depending on current default modesClassorg.apache.cocoon.acting.modular.DatabaseActionApache Cocoon
DefaultCacheManagerComponent implementing the CacheManager role.Classorg.apache.cocoon.formsApache Cocoon
DefaultCacheManagerComponent implementing the CacheManager role.Classorg.apache.cocoon.woodyApache Cocoon
DefaultFormatCacheClassorg.apache.cocoon.forms.datatype.convertorApache Cocoon
DefaultFormatCacheClassorg.apache.cocoon.woody.datatype.convertorApache Cocoon
DefaultIncludeCacheManagerDefault implementation of a IncludeCacheManager.Classorg.apache.cocoon.transformation.helpersApache Cocoon
DeltaTimeCacheValidityA validation object that remains valid for a specified amount of time.Classorg.apache.cocoon.cachingApache Cocoon
EventAwareCacheImplThis implementation holds all mappings between Events and PipelineCacheKeys in two MultiValueMaps to facilitate efficient lookup by either as Key.Classorg.apache.cocoon.caching.implApache Cocoon
EventCacheGeneratorGenerator wrapper that forwards generation to to its delegate but overides its caching strategyClassorg.apache.cocoon.generationApache Cocoon
HttpCacheActionThis action adds the Last-Modified, Expires and Cache-Control HTTP headers to the response.Classorg.apache.cocoon.actingApache Cocoon
IdentifierCacheKeyThis is a simple cache key that does not consider the components used in the pipeline.Classorg.apache.cocoon.cachingApache Cocoon
IncludeCacheManagerThe include cache manager is a component that can manage included content.Interfaceorg.apache.cocoon.transformation.helpersApache Cocoon
IncludeCacheManagerSessionThis object encapsulates a caching session.Classorg.apache.cocoon.transformation.helpersApache Cocoon
IncludeCacheStorageProxyA CacheStorageProxy is an interface object between the IncludeCacheManager and the real store caching the content.Interfaceorg.apache.cocoon.transformation.helpersApache Cocoon
IncludeCacheValidityA validation object used in CachingCIncludeTransformerVersion:CVS $Id: IncludeCacheValidity.Classorg.apache.cocoon.cachingApache Cocoon
JXCacheKeyClassorg.apache.cocoon.template.environmentApache Cocoon
ModifiableSourceIncludeCacheStorageProxyThis is the interface between the IncludeCacheManager and a Source object that stores the cached content in a directoryClassorg.apache.cocoon.transformation.helpersApache Cocoon
NOPCacheValidityA validation object which is always valid.Classorg.apache.cocoon.cachingApache Cocoon
ParametersCacheValidityA validation object using a set of key/value pairs contained in a Map.Classorg.apache.cocoon.cachingApache Cocoon
PipelineCacheKeyThis is the cache key for one pipeline (or the first part of a pipeline).Classorg.apache.cocoon.cachingApache Cocoon
SourceCacheValidityA CacheValidity object wrapping the Avalon Excalibur SourceValidity object.Classorg.apache.cocoon.cachingApache Cocoon
StoreIncludeCacheStorageProxyThis is the interface between the IncludeCacheManager and the usualSince:2.Classorg.apache.cocoon.transformation.helpersApache Cocoon
TimeStampCacheValidityA validation object for time-stamps.Classorg.apache.cocoon.cachingApache Cocoon
CacheDefines the interface used to cache messages.Interfaceorg.apache.activemq.memoryApache ActiveMQ
CachedLDAPAuthorizationMapA DefaultAuthorizationMap implementation which uses LDAP to initialize and update authorizationAuthor:Hiram ChirinoClassorg.apache.activemq.securityApache ActiveMQ
CachedMessageGroupMapClassorg.apache.activemq.broker.region.groupApache ActiveMQ
CachedMessageGroupMapFactoryA factory to create instances of CachedMessageGroupMap when implementing the Message Groups functionality.Classorg.apache.activemq.broker.region.groupApache ActiveMQ
CacheEntryClassorg.apache.activemq.memoryApache ActiveMQ
CacheEntryListMaintains a simple linked list of CacheEntry objects.Classorg.apache.activemq.memoryApache ActiveMQ
CacheEvictionUsageListenerClassorg.apache.activemq.memoryApache ActiveMQ
CacheFilterFilters another Cache implementation.Classorg.apache.activemq.memoryApache ActiveMQ
DtoCachedLDAPAuthorizationMapJava class for anonymous complex type.Classorg.apache.activemq.schema.coreApache ActiveMQ
DtoCachedMessageGroupMapFactoryJava class for anonymous complex type.Classorg.apache.activemq.schema.coreApache ActiveMQ
DtoVirtualSelectorCacheBrokerPluginJava class for anonymous complex type.Classorg.apache.activemq.schema.coreApache ActiveMQ
LFUCacheLFU cache implementation based on http://dhruvbird.Classorg.apache.activemq.utilApache ActiveMQ
LRUCacheClassorg.apache.activemq.utilApache ActiveMQ
MapCacheUse any Map to implement the Cache.Classorg.apache.activemq.memoryApache ActiveMQ
NonCachedMessageEvaluationContextClassorg.apache.activemq.filterApache ActiveMQ
SimpleCachedLDAPAuthorizationMapClassorg.apache.activemq.securityApache ActiveMQ
SimpleCachedLDAPAuthorizationMap .DestinationTypeClassorg.apache.activemq.security.SimpleCachedLDAPAuthorizationMapApache ActiveMQ
SimpleCachedLDAPAuthorizationMap .PermissionTypeClassorg.apache.activemq.security.SimpleCachedLDAPAuthorizationMapApache ActiveMQ
SubQueueSelectorCacheBrokerA plugin which allows the caching of the selector from a subscription queue.Classorg.apache.activemq.pluginApache ActiveMQ
SubQueueSelectorCacheBrokerPluginA plugin which allows the caching of the selector from a subscription queue.Classorg.apache.activemq.pluginApache ActiveMQ
UsageManagerCacheFilterSimple CacheFilter that increases/decreases usage on a UsageManager as objects are added/removed from the Cache.Classorg.apache.activemq.memoryApache ActiveMQ
VirtualDestinationSelectorCacheViewClassorg.apache.activemq.broker.jmxApache ActiveMQ
VirtualDestinationSelectorCacheViewMBeanInterfaceorg.apache.activemq.broker.jmxApache ActiveMQ
BeanInfoCacheKeyClassorg.apache.camel.component.beanApache Camel
ByteArrayInputStreamCacheClassorg.apache.camel.converter.streamApache Camel
CachedByteArrayOutputStreamA ByteArrayOutputStream that is capable of returning a InputStreamCache view of the buffer.Classorg.apache.camel.converter.streamApache Camel
CachedOutputStreamThis output stream will store the content into a File if the stream context size is exceed the THRESHOLD value.Classorg.apache.camel.converter.streamApache Camel
ConsumerCacheCache containing created Consumer.Classorg.apache.camel.implApache Camel
EmptyProducerCacheA ProducerCache which is always empty and does not cache any Producers.Classorg.apache.camel.implApache Camel
FileInputStreamCacheClassorg.apache.camel.converter.streamApache Camel
InputStreamCacheA StreamCache for caching using an in-memory byte array.Classorg.apache.camel.converter.streamApache Camel
LRUCacheA Least Recently Used Cache.Classorg.apache.camel.utilApache Camel
LRUSoftCacheA Least Recently Used Cache which uses SoftReference.Classorg.apache.camel.utilApache Camel
LRUWeakCacheA Least Recently Used Cache which uses WeakReference.Classorg.apache.camel.utilApache Camel
ManagedConsumerCacheClassorg.apache.camel.management.mbeanApache Camel
ManagedConsumerCacheMBeanInterfaceorg.apache.camel.api.management.mbeanApache Camel
ManagedProducerCacheClassorg.apache.camel.management.mbeanApache Camel
ManagedProducerCacheMBeanInterfaceorg.apache.camel.api.management.mbeanApache Camel
MethodInfoCacheRepresents a cache of MethodInfo objects to avoid the expense of introspection for each invocation of a method via a proxy.Classorg.apache.camel.component.beanApache Camel
ProducerCacheCache containing created Producer.Classorg.apache.camel.implApache Camel
ReaderCacheClassorg.apache.camel.converter.streamApache Camel
SourceCacheStreamCache implementation for StringSourcesSee Also:Serialized FormClassorg.apache.camel.converter.streamApache Camel
StreamCacheTagging interface to indicate that a type is capable of caching the underlying data stream.Interfaceorg.apache.camelApache Camel
StreamCacheConverterA set of Converter methods for wrapping stream-based messages in a StreamCache implementation to ensure message re-readability (eg multicasting, retrying)Classorg.apache.camel.converter.streamApache Camel
StreamSourceCacheClassorg.apache.camel.converter.streamApache Camel
BlockCacheWARNING: This API is experimental and might change in incompatible ways in the next release.Classorg.apache.solr.store.blockcacheApache Solr Lucene
BlockCacheKeyWARNING: This API is experimental and might change in incompatible ways in the next release.Classorg.apache.solr.store.blockcacheApache Solr Lucene
BlockCacheLocationWARNING: This API is experimental and might change in incompatible ways in the next release.Classorg.apache.solr.store.blockcacheApache Solr Lucene
BlockDirectoryCacheWARNING: This API is experimental and might change in incompatible ways in the next release.Classorg.apache.solr.store.blockcacheApache Solr Lucene
CacheWARNING: This API is experimental and might change in incompatible ways in the next release.Interfaceorg.apache.solr.store.blockcacheApache Solr Lucene
CacheConfigContains the knowledge of how cache config is stored in the solrconfig.Classorg.apache.solr.searchApache Solr Lucene
CachedIndexOutputCache the blocks as they are written.Classorg.apache.solr.store.blockcacheApache Solr Lucene
CachedSearcherStatsClassorg.apache.solr.search.statsApache Solr Lucene
CacheRegenerator based on an old cache.Interfaceorg.apache.solr.searchApache Solr Lucene
ConcurrentLFUCacheA LFU cache implementation based upon ConcurrentHashMap.Classorg.apache.solr.utilApache Solr Lucene
ConcurrentLFUCache .EvictionListenerInterfaceorg.apache.solr.util.ConcurrentLFUCacheApache Solr Lucene
ConcurrentLFUCache .StatsClassorg.apache.solr.util.ConcurrentLFUCacheApache Solr Lucene
ConcurrentLRUCacheA LRU cache implementation based upon ConcurrentHashMap and other techniques to reduce contention and synchronization overhead to utilize multiple CPU cores more effectively.Classorg.apache.solr.utilApache Solr Lucene
ConcurrentLRUCache .EvictionListenerInterfaceorg.apache.solr.util.ConcurrentLRUCacheApache Solr Lucene
ConcurrentLRUCache .StatsClassorg.apache.solr.util.ConcurrentLRUCacheApache Solr Lucene
ExactSharedStatsCacheClassorg.apache.solr.search.statsApache Solr Lucene
ExactStatsCacheThis class implements exact caching of statistics.Classorg.apache.solr.search.statsApache Solr Lucene
ExactStatsCache .ExactStatsSourceClassorg.apache.solr.search.stats.ExactStatsCacheApache Solr Lucene
FastLRUCacheSolrCache based on ConcurrentLRUCache implementation.Classorg.apache.solr.searchApache Solr Lucene
FileFloatSource .ReloadCacheRequestHandlerClassorg.apache.solr.search.function.FileFloatSourceApache Solr Lucene
HttpCacheHeaderUtilClassorg.apache.solr.servlet.cacheApache Solr Lucene
LFUCacheSolrCache based on ConcurrentLFUCache implementation.Classorg.apache.solr.searchApache Solr Lucene
LocalStatsCacheDefault implementation that simply ignores global term statistics, and always uses local term statistics.Classorg.apache.solr.search.statsApache Solr Lucene
LRUCacheClassorg.apache.solr.searchApache Solr Lucene
LRUStatsCacheUnlike ExactStatsCache this implementation preserves term stats across queries in a set of LRU caches, and based on surface features of aClassorg.apache.solr.search.statsApache Solr Lucene
SolrCachePrimary API for dealing with Solr's internal caches.Interfaceorg.apache.solr.searchApache Solr Lucene
SolrCache .StateClassorg.apache.solr.search.SolrCacheApache Solr Lucene
SolrCacheBaseClassorg.apache.solr.searchApache Solr Lucene
SolrCacheBase .AutoWarmCountRefClassorg.apache.solr.search.SolrCacheBaseApache Solr Lucene
SolrFieldCacheMBeanClassorg.apache.solr.searchApache Solr Lucene
StatsCacheThis class represents a cache of global document frequency information for selected terms.Classorg.apache.solr.search.statsApache Solr Lucene
CacheInterfaceorg.apache.solr.common.utilApache Solr Lucene
JavaBinCodec .StringCacheClassorg.apache.solr.common.util.JavaBinCodecApache Solr Lucene
SolrClientCacheThe SolrClientCache caches SolrClients so they can be reused by different TupleStreams.Classorg.apache.solr.client.solrj.ioApache Solr Lucene
CachePropertyUtilClassorg.apache.solr.handler.dataimportApache Solr Lucene
DateFormatEvaluator .DateFormatCacheKeyClassorg.apache.solr.handler.dataimport.DateFormatEvaluatorApache Solr Lucene
DIHCache A cache that allows a DIH entity's data to persist locally prior being joined to other data and/or indexed.Interfaceorg.apache.solr.handler.dataimportApache Solr Lucene
DIHCacheSupportClassorg.apache.solr.handler.dataimportApache Solr Lucene
SortedMapBackedCacheClassorg.apache.solr.handler.dataimportApache Solr Lucene
AbstractCacheClassorg.ofbizApache OfBiz
AbstractCacheClassorg.ofbizApache OfBiz
AbstractEntityConditionCacheClassorg.ofbizApache OfBiz
CachedDataSetHold copy of another dataset or a consumed provider content.Classorg.dbunit.datasetSourceForge DBUnit
CachedResultSetTableClassorg.dbunit.databaseSourceForge DBUnit
CachedResultSetTableFactoryClassorg.dbunit.databaseSourceForge DBUnit
CachedTableClassorg.dbunit.datasetSourceForge DBUnit
CacheA made-up class used to demonstrate some PowerMock functionality.Classpowermock.examples.bypassencapsulation.nontestPowerMock
AddApplicationCacheClassorg.openqa.selenium.remote.html5Selenium
AppCacheStatusRepresents the application cache status.Classorg.openqa.selenium.html5Selenium
ApplicationCacheThe current state of the application cache.Interfaceorg.openqa.selenium.html5Selenium
RemoteApplicationCacheProvides remote access to the ApplicationCache API.Classorg.openqa.selenium.remote.html5Selenium
DbQueryManagerCacheThis class is a simple cache for DbQueryManager objects.Classcom.uwyn.rife.databaseRife
UncachedClasscom.uwyn.rife.engine.elementsRife
BeansModelCacheClassfreemarker.ext.beansFreeMarker Template
CacheStorageCache storage abstracts away the storage aspects of a cache - associating an object with a key, retrieval and removal via the key.Interfacefreemarker.cacheFreeMarker Template
CacheStorageWithGetSizeA cache storage that has a getSize() method for returning the current number of cache entries.Interfacefreemarker.cacheFreeMarker Template
ConcurrentCacheStorageAn optional interface for cache storage that knows whether it can be concurrently accessible without synchronization.Interfacefreemarker.cacheFreeMarker Template
ModelCacheClassfreemarker.ext.utilFreeMarker Template
MruCacheStorageA cache storage that implements a two-level Most Recently Used cache.Classfreemarker.cacheFreeMarker Template
NullCacheStorageA cache storage that doesn't store anything.Classfreemarker.cacheFreeMarker Template
SoftCacheStorageSoft cache storage is a cache storage that uses SoftReference objects to hold the objects it was passed, therefore allows the garbageClassfreemarker.cacheFreeMarker Template
StrongCacheStorageStrong cache storage is a cache storage that simply wraps a Map.Classfreemarker.cacheFreeMarker Template
TemplateCachePerforms caching and on-demand loading of the templates.Classfreemarker.cacheFreeMarker Template
TemplateCache .MaybeMissingTemplateUsed for the return value of TemplateCache.Classfreemarker.cache.TemplateCacheFreeMarker Template
CachedGeneratorResultAn interface to represent the cached results from a previous generator invocation.Interfacecom.google.gwt.core.extGoogle WebToolkit (GWT)
CachedPropertyInformationA container for saving lists of deferred-binding and configuration properties to be compared subsequently with a PropertyOracle.Classcom.google.gwt.core.extGoogle WebToolkit (GWT)
ServiceLayerCacheClasscom.google.web.bindery.requestfactory.serverGoogle WebToolkit (GWT)
AnyType .ObjectTypeCacheEntrySee Also:Serialized FormMethods inherited from class java.Classorg.hibernate.type.AnyTypeHibernate ORM
CacheAdd caching strategy to a root entity or a collectionRequired Element SummaryClassorg.hibernate.annotationsHibernate ORM
CacheProvides an API for querying/managing the second level cache regions.Interfaceorg.hibernateHibernate ORM
Cache71DialectClassorg.hibernate.dialectHibernate ORM
CacheableResultTransformerA ResultTransformer that is used to transform tuples to a value(s) that can be cached.Classorg.hibernate.transformHibernate ORM
CacheCommandExtensionsCommand extensions for second-level cache use caseConstructor SummaryCacheCommandExtensions()Classorg.hibernate.cache.infinispan.utilHibernate ORM
CacheCommandFactoryClassorg.hibernate.cache.infinispan.utilHibernate ORM
CacheCommandIdsInterfaceorg.hibernate.cache.infinispan.utilHibernate ORM
CacheCommandInitializerClassorg.hibernate.cache.infinispan.utilHibernate ORM
CacheConcurrencyStrategyenum CacheConcurrencyStrategyextends EnumCache concurrency strategyClassorg.hibernate.annotationsHibernate ORM
CacheDataDescriptionDescribes attributes regarding the type of data to be cached.Interfaceorg.hibernate.cache.spiHibernate ORM
CacheDataDescriptionImplClassorg.hibernate.cache.internalHibernate ORM
CachedNaturalIdValueSourceenum CachedNaturalIdValueSourceextends EnumThe type of action from which the cache call is originating.Classorg.hibernate.engine.spiHibernate ORM
CacheEntryA cached instance of a persistent classSee Also:Serialized FormClassorg.hibernate.cache.spi.entryHibernate ORM
CacheEntryStructureInterfaceorg.hibernate.cache.spi.entryHibernate ORM
CacheExceptionSomething went wrong in the cacheSee Also:Serialized FormClassorg.hibernate.cacheHibernate ORM
CacheImplClassorg.hibernate.internalHibernate ORM
CacheImplementorInterfaceorg.hibernate.engine.spiHibernate ORM
CacheInitiatorClassorg.hibernate.engine.spiHibernate ORM
CacheJoinFragmentClassorg.hibernate.sqlHibernate ORM
CacheKeyAllows multiple entity classes / collection roles to be stored in the same cache region.Classorg.hibernate.cache.spiHibernate ORM
CacheModeenum CacheModeextends EnumControls how the session interacts with the second-levelClassorg.hibernateHibernate ORM
CacheModeHelperClassorg.hibernate.ejb.utilHibernate ORM
CacheModeTypeenum CacheModeTypeextends EnumEnumeration for the different interaction modes between the session andClassorg.hibernate.annotationsHibernate ORM
CacheRegionStatsClassorg.hibernate.cache.ehcache.management.implHibernate ORM
CacheRegionUtilsClassorg.hibernate.cache.ehcache.management.implHibernate ORM
CachesHelper for dealing with Infinispan cache instances.Classorg.hibernate.cache.infinispan.utilHibernate ORM
CacheSQLExceptionConversionDelegateClassorg.hibernate.exception.internalHibernate ORM
CollectionCacheEntryClassorg.hibernate.cache.spi.entryHibernate ORM
ColumnNameCacheClassorg.hibernate.engine.jdbcHibernate ORM
ConcurrentNaturalIdCacheStatisticsImplNaturalId cache statistics of a specific regionSee Also:Serialized FormClassorg.hibernate.stat.internalHibernate ORM
ConcurrentSecondLevelCacheStatisticsImplSecond level cache statistics of a specific regionSee Also:Serialized FormClassorg.hibernate.stat.internalHibernate ORM
EhcacheAccessStrategyFactoryInterfaceorg.hibernate.cache.ehcache.internal.strategyHibernate ORM
EhcacheAccessStrategyFactoryImplClass implementing EhcacheAccessStrategyFactoryConstructor SummaryEhcacheAccessStrategyFactoryImpl()Classorg.hibernate.cache.ehcache.internal.strategyHibernate ORM
EhcacheCollectionRegionA collection region specific wrapper around an Ehcache instance.Classorg.hibernate.cache.ehcache.internal.regionsHibernate ORM
EhcacheDataRegionAn Ehcache specific data region implementation.Classorg.hibernate.cache.ehcache.internal.regionsHibernate ORM
EhcacheEntityRegionAn entity region specific wrapper around an Ehcache instance.Classorg.hibernate.cache.ehcache.internal.regionsHibernate ORM
EhcacheHibernateFields inherited from class org.Classorg.hibernate.cache.ehcache.management.implHibernate ORM
EhcacheHibernateMbeanNamesClassorg.hibernate.cache.ehcache.management.implHibernate ORM
EhcacheHibernateMBeanRegistrationInterfaceorg.hibernate.cache.ehcache.management.implHibernate ORM
EhcacheHibernateMBeanRegistrationImpl Also implements CacheManagerEventListener.Classorg.hibernate.cache.ehcache.management.implHibernate ORM
EhCacheMessageLoggerThe jboss-logging MessageLogger for the hibernate-ehcache module.Interfaceorg.hibernate.cache.ehcacheHibernate ORM
EhcacheNaturalIdRegionA collection region specific wrapper around an Ehcache instance.Classorg.hibernate.cache.ehcache.internal.regionsHibernate ORM
EhcacheQueryResultsRegionA query results region specific wrapper around an Ehcache instance.Classorg.hibernate.cache.ehcache.internal.regionsHibernate ORM
EhCacheRegionFactoryA non-singleton EhCacheRegionFactory implementation.Classorg.hibernate.cache.ehcacheHibernate ORM
EhcacheStatsImplFields inherited from class org.Classorg.hibernate.cache.ehcache.management.implHibernate ORM
EhcacheTimestampsRegionA timestamps region specific wrapper around an Ehcache instance.Classorg.hibernate.cache.ehcache.internal.regionsHibernate ORM
EhcacheTransactionalDataRegionAn Ehcache specific TransactionalDataRegion.Classorg.hibernate.cache.ehcache.internal.regionsHibernate ORM
FirstLevelCacheFirst level cache for versioned entities, versions reader-scoped.Classorg.hibernate.envers.readerHibernate ORM
HibernateNonstopCacheExceptionHandlerClassorg.hibernate.cache.ehcache.internal.nonstopHibernate ORM
JaxbCacheElementJava class for cache-element complex type.Classorg.hibernate.internal.jaxb.mapping.hbmHibernate ORM
JaxbCacheModeAttributeenum JaxbCacheModeAttributeextends EnumJava class for cache-mode-attribute.Classorg.hibernate.internal.jaxb.mapping.hbmHibernate ORM
JaxbHibernateConfiguration .JaxbSessionFactory .JaxbClassCacheJava class for anonymous complex type.Classorg.hibernate.internal.jaxb.cfg.JaxbHibernateConfiguration.JaxbSessionFactoryHibernate ORM
JaxbHibernateConfiguration .JaxbSessionFactory .JaxbCollectionCacheJava class for anonymous complex type.Classorg.hibernate.internal.jaxb.cfg.JaxbHibernateConfiguration.JaxbSessionFactoryHibernate ORM
NaturalIdCacheUsed to specify that the natural id values associated with the annotated entity should be cached in Hibernate's shared (L2) cache.Classorg.hibernate.annotationsHibernate ORM
NaturalIdCacheKeyDefines a key for caching natural identifier resolutions into the second level cache.Classorg.hibernate.cache.spiHibernate ORM
NaturalIdCacheStatisticsNaturalId query statistics Note that for a cached natural id, the cache miss is equals to the db countInterfaceorg.hibernate.statHibernate ORM
NoCacheRegionFactoryAvailableExceptionSee Also:Serialized FormConstructor SummaryNoCacheRegionFactoryAvailableException()Classorg.hibernate.cacheHibernate ORM
NonStrictReadWriteEhcacheCollectionRegionAccessStrategyClassorg.hibernate.cache.ehcache.internal.strategyHibernate ORM
NonStrictReadWriteEhcacheEntityRegionAccessStrategyClassorg.hibernate.cache.ehcache.internal.strategyHibernate ORM
NonStrictReadWriteEhcacheNaturalIdRegionAccessStrategyClassorg.hibernate.cache.ehcache.internal.strategyHibernate ORM
OptimisticCacheSourceContract for sources of optimistically lockable data sent to the second level Note currently EntityPersisters areInterfaceorg.hibernate.cache.spiHibernate ORM
PersistenceUtilHelper .MetadataCacheCache hierarchy and member resolution in a weak hash mapSee Also:Serialized FormClassorg.hibernate.ejb.util.PersistenceUtilHelperHibernate ORM
QueryCacheDefines the contract for caches capable of storing query results.Interfaceorg.hibernate.cache.spiHibernate ORM
QueryCacheFactoryDefines a factory for query cache instances.Interfaceorg.hibernate.cache.spiHibernate ORM
QueryPlanCacheActs as a cache for compiled query plans, as well as query-parameter metadata.Classorg.hibernate.engine.query.spiHibernate ORM
ReadOnlyEhcacheCollectionRegionAccessStrategyClassorg.hibernate.cache.ehcache.internal.strategyHibernate ORM
ReadOnlyEhcacheEntityRegionAccessStrategyClassorg.hibernate.cache.ehcache.internal.strategyHibernate ORM
ReadOnlyEhcacheNaturalIdRegionAccessStrategyClassorg.hibernate.cache.ehcache.internal.strategyHibernate ORM
ReadWriteEhcacheCollectionRegionAccessStrategyClassorg.hibernate.cache.ehcache.internal.strategyHibernate ORM
ReadWriteEhcacheEntityRegionAccessStrategyClassorg.hibernate.cache.ehcache.internal.strategyHibernate ORM
ReadWriteEhcacheNaturalIdRegionAccessStrategyClassorg.hibernate.cache.ehcache.internal.strategyHibernate ORM
SecondLevelCacheStatisticsInterfaceorg.hibernate.statHibernate ORM
SessionCacheCleanerClass responsible for evicting audit data entries that have been stored in the session level cache.Classorg.hibernate.envers.synchronizationHibernate ORM
SingletonEhCacheRegionFactoryA singleton EhCacheRegionFactory implementation.Classorg.hibernate.cache.ehcacheHibernate ORM
StandardQueryCacheThe standard implementation of the Hibernate QueryCache interface.Classorg.hibernate.cache.internalHibernate ORM
StandardQueryCacheFactoryStandard Hibernate implementation of the QueryCacheFactory interface.Classorg.hibernate.cache.internalHibernate ORM
StructuredCacheEntryClassorg.hibernate.cache.spi.entryHibernate ORM
StructuredCollectionCacheEntryClassorg.hibernate.cache.spi.entryHibernate ORM
StructuredMapCacheEntryClassorg.hibernate.cache.spi.entryHibernate ORM
TransactionalEhcacheCollectionRegionAccessStrategyJTA CollectionRegionAccessStrategy.Classorg.hibernate.cache.ehcache.internal.strategyHibernate ORM
TransactionalEhcacheEntityRegionAccessStrategyJTA EntityRegionAccessStrategy.Classorg.hibernate.cache.ehcache.internal.strategyHibernate ORM
TransactionalEhcacheNaturalIdRegionAccessStrategyJTA NaturalIdRegionAccessStrategy.Classorg.hibernate.cache.ehcache.internal.strategyHibernate ORM
UnstructuredCacheEntryClassorg.hibernate.cache.spi.entryHibernate ORM
UpdateTimestampsCacheTracks the timestamps of the most recent updates to particular tables.Classorg.hibernate.cache.spiHibernate ORM
CacheInterfaceorg.apache.ibatis.cacheIBatis
CacheBuilderClassorg.apache.ibatis.mappingIBatis
CacheExceptionSee Also:Serialized FormConstructor SummaryCacheException()Classorg.apache.ibatis.cacheIBatis
CacheKeyClassorg.apache.ibatis.cacheIBatis
CacheNamespaceClassorg.apache.ibatis.annotationsIBatis
CacheRefResolverClassorg.apache.ibatis.builderIBatis
FastResultSetHandler .ResultColumnCacheprotected FastResultSetHandler.Classorg.apache.ibatis.executor.resultset.FastResultSetHandlerIBatis
FifoCacheClassorg.apache.ibatis.cache.decoratorsIBatis
LocalCacheScopeenum LocalCacheScopeextends EnumEnum Constant SummarySESSIONClassorg.apache.ibatis.sessionIBatis
LoggingCacheClassorg.apache.ibatis.cache.decoratorsIBatis
LruCacheClassorg.apache.ibatis.cache.decoratorsIBatis
NullCacheKeyFields inherited from class org.Classorg.apache.ibatis.cacheIBatis
OgnlCacheCaches OGNL parsed expressions.Classorg.apache.ibatis.builder.xml.dynamicIBatis
PerpetualCacheClassorg.apache.ibatis.cache.implIBatis
ScheduledCacheClassorg.apache.ibatis.cache.decoratorsIBatis
SerializedCacheClassorg.apache.ibatis.cache.decoratorsIBatis
SerializedCache .CustomObjectInputStreamNested Class SummaryNested classes/interfaces inherited from class java.Classorg.apache.ibatis.cache.decorators.SerializedCacheIBatis
SoftCacheSoft Reference cache decorator Thanks to Dr.Classorg.apache.ibatis.cache.decoratorsIBatis
SynchronizedCacheClassorg.apache.ibatis.cache.decoratorsIBatis
TransactionalCacheClassorg.apache.ibatis.cache.decoratorsIBatis
TransactionalCacheManagerClassorg.apache.ibatis.cacheIBatis
WeakCacheWeak Reference cache decorator.Classorg.apache.ibatis.cache.decoratorsIBatis
AbstractLayoutCache Serialized objects of this class will not be compatible with future Swing releases.Classswing.treeCode Trails
AbstractLayoutCache .NodeDimensionsUsed by AbstractLayoutCache to determine the size and x origin of a particular node.Classswing.tree.AbstractLayoutCacheCode Trails
AbstractRegionPainter .PaintContext .CacheModeClassswing.plaf.nimbus.AbstractRegionPainter.PaintContextCode Trails
AuthCacheInterfacenet.www.protocol.httpCode Trails
AuthCacheImplClassnet.www.protocol.httpCode Trails
AuthCacheValueAuthCacheValue: interface to minimise exposure to authentication cache for external users (ie.Classnet.www.protocol.httpCode Trails
AuthCacheValue .TypeClassnet.www.protocol.http.AuthCacheValueCode Trails
BaseFileManager .ByteBufferCacheA single-element cache of direct byte buffers.Classsun.tools.javac.util.BaseFileManagerCode Trails
BaseFileManager .ContentCacheEntryClasssun.tools.javac.util.BaseFileManagerCode Trails
BaseLocale .CacheClassutil.locale.BaseLocaleCode Trails
BreakIterator .BreakIteratorCacheClasstext.BreakIteratorCode Trails
Byte .ByteCacheClasslang.ByteCode Trails
CacheThe Cache class.ClassmiscCode Trails
CacheAbstract base class and factory for caches.Classsecurity.utilCode Trails
Cache .EqualByteArrayUtility class that wraps a byte array and implements the equals() and hashCode() contract in a way suitable for Maps and caches.Classsecurity.util.CacheCode Trails
CachedCodeBaseProvides the reading side with a per connection cache of info obtained via calls to the remote CodeBase.Classsun.corba.se.impl.encodingCode Trails
CachedDatatypeLibraryFactoryClasssun.xml.internal.rngom.dtCode Trails
CachedNodeListIteratorCachedNodeListIterator is used for select expressions in a variable or parameter.Classsun.org.apache.xalan.internal.xsltc.domCode Trails
CachedPainterA base class used for icons or images that are expensive to paint.ClassswingCode Trails
CachedRowSetThe interface that all standard implementations of CachedRowSet must implement.Interfacesql.rowsetCode Trails
CachedRowSetImplThe standard implementation of the CachedRowSet interface.Classsun.rowsetCode Trails
CachedRowSetReaderThe facility called by the RIOptimisticProvider object internally to read data into it.Classsun.rowset.internalCode Trails
CachedRowSetWriterThe facility called on internally by the RIOptimisticProvider implementation to propagate changes back to the data source from which the rowset got its data.Classsun.rowset.internalCode Trails
CachedXPathAPIThe methods in this class are convenience methods into the low-level XPath API.Classsun.org.apache.xpath.internalCode Trails
CachedXPathAPIHolderClasssun.org.apache.xml.internal.security.utilsCode Trails
CachedXPathFuncHereAPIClasssun.org.apache.xml.internal.security.utilsCode Trails
CacheEntryClassmiscCode Trails
CacheEnumeratorClassmiscCode Trails
CacheFSInfoCaching implementation of FSInfo.Classsun.tools.javac.fileCode Trails
CacheFSInfo .EntryClasssun.tools.javac.file.CacheFSInfoCode Trails
CacheMapLike WeakHashMap, except that the keys of the n most recently-accessed entries are kept as softClasssun.jmx.remote.utilCode Trails
CacheRequestRepresents channels for storing resources in the ResponseCache.ClassnetCode Trails
CacheResponseRepresent channels for retrieving resources from the ResponseCache.ClassnetCode Trails
CacheTableClasssun.corba.se.impl.orbutilCode Trails
CacheTableThis class implements Hashtable to store the replay caches.Classsecurity.krb5.internal.rcacheCode Trails
CCacheInputStreamThis class extends KrbDataInputStream.Classsecurity.krb5.internal.ccacheCode Trails
CCacheOutputStreamThis class implements a buffered output stream.Classsecurity.krb5.internal.ccacheCode Trails
Character .CharacterCacheClasslang.CharacterCode Trails
ClassLoaderReferenceImpl .CacheClasssun.tools.jdi.ClassLoaderReferenceImplCode Trails
CoderResult .CacheClassnio.charset.CoderResultCode Trails
CodeSetCacheClasssun.corba.se.impl.encodingCode Trails
ConnectionCacheInterfacesun.corba.se.pept.transportCode Trails
CorbaConnectionCacheBaseClasssun.corba.se.impl.transportCode Trails
CorbaInboundConnectionCacheImplClasssun.corba.se.impl.transportCode Trails
CorbaOutboundConnectionCacheImplClasssun.corba.se.impl.transportCode Trails
CredentialsCacheCredentialsCache stores credentials(tickets, session keys, etc) in a semi-permanent store for later use by different program.Classsecurity.krb5.internal.ccacheCode Trails
DescriptorCacheClasssun.jmx.mbeanserverCode Trails
DocumentCacheClasssun.org.apache.xalan.internal.xsltc.domCode Trails
DOMCacheInterfacesun.org.apache.xalan.internal.xsltcCode Trails
PointableCacheClassapache.vxquery.datamodel.accessorsApache VQuery
AliasBlurFilterCacheThis implementation on BlurFilterCache does nothing and it is the default BlurFilterCache.Classapache.blur.managerApache Blur
BaseCacheClassapache.blur.store.blockcache_v2Apache Blur
BaseCache .STOREClassapache.blur.store.blockcache_v2.BaseCacheApache Blur
BaseCacheValueClassapache.blur.store.blockcache_v2.cachevalueApache Blur
BaseCacheValue .EvictedSee Also:Serialized FormConstructor SummaryBaseCacheValue.Classapache.blur.store.blockcache_v2.cachevalue.BaseCacheValueApache Blur
BlockCacheClassapache.blur.store.blockcacheApache Blur
BlockCacheDirectoryFactoryClassapache.blur.storeApache Blur
BlockCacheDirectoryFactoryV1Classapache.blur.storeApache Blur
BlockCacheDirectoryFactoryV2Classapache.blur.storeApache Blur
BlockCacheKeyClassapache.blur.store.blockcacheApache Blur
BlockCacheLocationClassapache.blur.store.blockcacheApache Blur
BlockDirectoryCacheClassapache.blur.store.blockcacheApache Blur
BlurFilterCacheThe BlurFilterCache class provides the ability to cache pre and post filters on a per table basis.Classapache.blur.managerApache Blur
BlurFilterCache .FilterParserInterfaceapache.blur.manager.BlurFilterCacheApache Blur
ByteArrayCacheValueNested Class SummaryNested classes/interfaces inherited from class org.Classapache.blur.store.blockcache_v2.cachevalueApache Blur
CacheInterfaceapache.blur.store.blockcacheApache Blur
CacheClassapache.blur.store.blockcache_v2Apache Blur
CachedDecompressorConstructor SummaryCachedDecompressor(org.Classapache.blur.lucene.codecApache Blur
CachedIndexOutputFields inherited from class org.Classapache.blur.store.blockcacheApache Blur
CacheDirectoryNested Class SummaryNested classes/interfaces inherited from class org.Classapache.blur.store.blockcache_v2Apache Blur
CachedMapClassapache.blurApache Blur
CacheIndexInputClassapache.blur.store.blockcache_v2Apache Blur
CacheIndexOutputClassapache.blur.store.blockcache_v2Apache Blur
CacheKeyClassapache.blur.store.blockcache_v2Apache Blur
CacheValueInterfaceapache.blur.store.blockcache_v2Apache Blur
CacheValueBufferPoolConstructor SummaryCacheValueBufferPool(BaseCache.Classapache.blur.store.blockcache_v2Apache Blur
DeepPagingCacheClassapache.blur.lucene.searchApache Blur
DeepPagingCache .DeepPageContainerConstructor SummaryDeepPagingCache.Classapache.blur.lucene.search.DeepPagingCacheApache Blur
DeepPagingCache .DeepPageKeyConstructor SummaryDeepPagingCache.Classapache.blur.lucene.search.DeepPagingCacheApache Blur
DefaultBlurFilterCacheThis implementation on BlurFilterCache does nothing and it is the default BlurFilterCache.Classapache.blur.managerApache Blur
DetachableCacheValueClassapache.blur.store.blockcache_v2.cachevalueApache Blur
FilterCacheClassapache.blur.filterApache Blur
PrimeDocCacheClassapache.blur.lucene.searchApache Blur
QueryCacheClassapache.blur.utilsApache Blur
QueryCacheEntryClassapache.blur.utilsApache Blur
QueryCacheKeyClassapache.blur.utilsApache Blur
UnsafeCacheValueNested Class SummaryNested classes/interfaces inherited from class org.Classapache.blur.store.blockcache_v2.cachevalueApache Blur
ZkCachedMapThis is an simple implementation of a set-once map of string-to-string that is backed by ZooKeeper.Classapache.blur.zookeeperApache Blur
EditCacheDialogDialog for editing resource's caching setting.Classclient.gwt.views.gxtContent Control
OpenEditCacheActionEdit resource's cache setting.Classclient.gwt.remotingContent Control
UpdateCacheDurationActionRemote action for cache duration updating.Classclient.gwt.remotingContent Control
JdbcMeta .ConnectionCacheSettingsConfigurable connection cache settings.Classorg.apache.calcite.avatica.jdbc.JdbcMetaCalcite
JdbcMeta .StatementCacheSettingsConfigurable statement cache settings.Classorg.apache.calcite.avatica.jdbc.JdbcMetaCalcite
ParserBenchmark_parseCached_jmhTestClassorg.apache.calcite.benchmarks.generatedCalcite
ParserBenchmark_parseNonCached_jmhTestClassorg.apache.calcite.benchmarks.generatedCalcite
CountingCacheCache which counts the number of flushes per task id (destination worker id), so we know how many requests were sent to the workerClassorg.apache.giraph.comm.aggregatorsGiraph
DistributedCacheUtilsClassorg.apache.giraph.utilsGiraph
SendDataCacheAn abstract structure for caching data by partitions to be sent to workers in bulk.Classorg.apache.giraph.commGiraph
SendEdgeCacheAggregates the edges to be sent to workers so they can be sent in bulk.Classorg.apache.giraph.commGiraph
SendGlobalCommCacheTakes and serializes global communication values and keeps them grouped by owner partition id, to be sent in bulk.Classorg.apache.giraph.comm.aggregatorsGiraph
SendMessageCacheAggregates the messages to be sent to workers so they can be sent in bulk.Classorg.apache.giraph.commGiraph
SendMutationsCacheClassorg.apache.giraph.commGiraph
SendOneMessageToManyCacheClassorg.apache.giraph.commGiraph
SendPartitionCacheCaches partition vertices prior to sending.Classorg.apache.giraph.commGiraph
SendVertexIdDataCacheAn abstract structure for caching data indexed by vertex id, to be sent to workers in bulk.Classorg.apache.giraph.commGiraph
AbstractCacheEventFilterConverterThis is a base class that should be used when implementing a CacheEventFilterConverter that provides default implementations for the CacheEventFilter.Classorg.infinispan.notifications.cachelistener.filterInfinispan
AbstractDelegatingAdvancedCacheClassorg.infinispanInfinispan
AbstractDelegatingCacheClassorg.infinispanInfinispan
AbstractDelegatingEmbeddedCacheManagerClassorg.infinispan.managerInfinispan
AdvancedCacheAn advanced interface that exposes additional methods not available on Cache.Interfaceorg.infinispanInfinispan
AdvancedCacheExpirationWriterDefines functionality for advanced expiration techniques.Interfaceorg.infinispan.persistence.spiInfinispan
AdvancedCacheExpirationWriter .ExpirationPurgeListenerCallback to be notified when an entry is removed by the AdvancedCacheExpirationWriter.Interfaceorg.infinispan.persistence.spi.AdvancedCacheExpirationWriterInfinispan
AdvancedCacheLoaderA specialised extension of the CacheLoader interface that allows processing parallel iteration over theSince:6.Interfaceorg.infinispan.persistence.spiInfinispan
AdvancedCacheLoader .CacheLoaderTaskOffers a callback to be invoked for parallel iteration over the entries in an external store.Interfaceorg.infinispan.persistence.spi.AdvancedCacheLoaderInfinispan
AdvancedCacheLoader .TaskContextUsed during the parallel iteration in order to offer the AdvancedCacheLoader.Interfaceorg.infinispan.persistence.spi.AdvancedCacheLoaderInfinispan
AdvancedCacheWriterDefines advanced functionality for persisting data to an external storage.Interfaceorg.infinispan.persistence.spiInfinispan
AdvancedCacheWriter .PurgeListenerCallback to be notified when an entry is removed by the AdvancedCacheWriter.Interfaceorg.infinispan.persistence.spi.AdvancedCacheWriterInfinispan
AsyncCacheAsyncCache.Interfaceorg.infinispan.commons.apiInfinispan
BasicCacheBasicCache provides the common building block for the two different types of caches that Infinispan provides: embedded and remote.Interfaceorg.infinispan.commons.apiInfinispan
BasicCacheContainerBasicCacheContainer defines the methods used to obtain a org.Interfaceorg.infinispan.commons.apiInfinispan
BatchingCacheThe BatchingCache is implemented by all caches which support batchingSince:6.Interfaceorg.infinispan.commons.apiInfinispan
CacheThe central interface of Infinispan.Interfaceorg.infinispanInfinispan
CacheCollectionA collection type that returns special Cache based streams that have additional options to tweak behavior.Interfaceorg.infinispanInfinispan
CacheCollectorsHelper class designed to be used to create a serializable Collector for use with CacheStream.Classorg.infinispan.streamInfinispan
CacheConfigurationExceptionAn exception that represents an error in the configuration.Classorg.infinispan.commonsInfinispan
CacheContainerInterfaceorg.infinispan.managerInfinispan
CacheContainerStatsSimilar to Stats but in the scope of a single per node CacheContainerSince:7.Interfaceorg.infinispan.statsInfinispan
CachedThreadPoolExecutorFactoryClassorg.infinispan.commons.executorsInfinispan
CacheEntriesEvictedThis annotation should be used on methods that need to be notified when cache entries are evicted.Classorg.infinispan.notifications.cachelistener.annotationInfinispan
CacheEntriesEvictedEventThis event subtype is passed in to any method annotated with CacheEntriesEvicted.Interfaceorg.infinispan.notifications.cachelistener.eventInfinispan
CacheEntryActivatedThis annotation should be used on methods that need to be notified when a cache entry is activated.Classorg.infinispan.notifications.cachelistener.annotationInfinispan
CacheEntryActivatedEventThis event subtype is passed in to any method annotated with CacheEntryActivated.Interfaceorg.infinispan.notifications.cachelistener.eventInfinispan
CacheEntryCreatedThis annotation should be used on methods that need to be notified when a cache entry is created.Classorg.infinispan.notifications.cachelistener.annotationInfinispan
CacheEntryCreatedEventThis event subtype is passed in to any method annotated withSince:4.Interfaceorg.infinispan.notifications.cachelistener.eventInfinispan
CacheEntryEventA transactional event subtype that additionally expose a key as such events pertain to a specific cache entry.Interfaceorg.infinispan.notifications.cachelistener.eventInfinispan
CacheEntryExpiredThis annotation should be used on methods that need to be notified when a cache entry is expired Methods annotated with this annotation should be public and take in a single parameter, a CacheEntryExpiredEvent otherwise an IncorrectListenerException will be thrown when registering your cache listener.Classorg.infinispan.notifications.cachelistener.annotationInfinispan
CacheEntryExpiredEventThis event subtype is passed in to any method annotated with The getValue() method returns the value of the entry before it expired.Interfaceorg.infinispan.notifications.cachelistener.eventInfinispan
CacheEntryInvalidatedThis annotation should be used on methods that need to be notified when a cache entry is invalidated.Classorg.infinispan.notifications.cachelistener.annotationInfinispan
CacheEntryInvalidatedEventNotifies a listener of an invalidation event.Interfaceorg.infinispan.notifications.cachelistener.eventInfinispan
CacheEntryLoadedThis annotation should be used on methods that need to be notified when a cache entry is loaded from a CacheLoader.Classorg.infinispan.notifications.cachelistener.annotationInfinispan
CacheEntryLoadedEventThis event subtype is passed in to any method annotated with CacheEntryLoaded.Interfaceorg.infinispan.notifications.cachelistener.eventInfinispan
CacheEntryModifiedThis annotation should be used on methods that need to be notified when a cache entry has been modified.Classorg.infinispan.notifications.cachelistener.annotationInfinispan
CacheEntryModifiedEventThis event subtype is passed in to any method annotated with CacheEntryModified The getValue() method's behavior is specific to whether the callback is triggered before or after the eventInterfaceorg.infinispan.notifications.cachelistener.eventInfinispan
CacheEntryPassivatedThis annotation should be used on methods that need to be notified when cache entries are passivated.Classorg.infinispan.notifications.cachelistener.annotationInfinispan
CacheEntryPassivatedEventThis event subtype is passed in to any method annotated with CacheEntryPassivated.Interfaceorg.infinispan.notifications.cachelistener.eventInfinispan
CacheEntryRemovedThis annotation should be used on methods that need to be notified when a cache entry is removed from the cache.Classorg.infinispan.notifications.cachelistener.annotationInfinispan
CacheEntryRemovedEventThis event subtype is passed in to any method annotated with CacheEntryRemoved.Interfaceorg.infinispan.notifications.cachelistener.eventInfinispan
CacheEntryVisitedThis annotation should be used on methods that need to be notified when a cache entry is visited.Classorg.infinispan.notifications.cachelistener.annotationInfinispan
CacheEntryVisitedEventThis event subtype is passed in to any method annotated with CacheEntryVisited.Interfaceorg.infinispan.notifications.cachelistener.eventInfinispan
CacheEventConverterA converter that can be used to convert the value given for an event.Interfaceorg.infinispan.notifications.cachelistener.filterInfinispan
CacheEventConverterAsConverterConverter that is implemented by using the provided CacheEventConverter.Classorg.infinispan.notifications.cachelistener.filterInfinispan
CacheEventConverterAsConverter .ExternalizerClassorg.infinispan.notifications.cachelistener.filter.CacheEventConverterAsConverterInfinispan
CacheEventConverterFactoryFactory that can produce CacheEventConvertersSince:7.Interfaceorg.infinispan.notifications.cachelistener.filterInfinispan
CacheEventFilterA filter that can be used to tell if an event should be raised or not.Interfaceorg.infinispan.notifications.cachelistener.filterInfinispan
CacheEventFilterAsKeyValueFilterKeyValueFilter that is implemented by using the provided CacheEventFilter.Classorg.infinispan.notifications.cachelistener.filterInfinispan
CacheEventFilterAsKeyValueFilter .ExternalizerClassorg.infinispan.notifications.cachelistener.filter.CacheEventFilterAsKeyValueFilterInfinispan
CacheEventFilterConverterThis interface is an optimization that can be used when an event filter and converter are most efficiently used as the same object composing the filtering and conversion in the same method invocation.Interfaceorg.infinispan.notifications.cachelistener.filterInfinispan
CacheEventFilterConverterAsKeyValueFilterConverterClassorg.infinispan.notifications.cachelistener.filterInfinispan
CacheEventFilterConverterAsKeyValueFilterConverter .ExternalizerClassorg.infinispan.notifications.cachelistener.filter.CacheEventFilterConverterAsKeyValueFilterConverterInfinispan
CacheEventFilterConverterFactoryFactory that can produce CacheEventFilterConverter instances.Interfaceorg.infinispan.notifications.cachelistener.filterInfinispan
CacheEventFilterFactoryFactory that can produce CacheEventFiltersSince:7.Interfaceorg.infinispan.notifications.cachelistener.filterInfinispan
CacheExceptionThrown when operations on Cache fail unexpectedly.Classorg.infinispan.commonsInfinispan
CacheFiltersStatic factory class that contains utility methods that can be used for performing proper transformations from KeyValueFilter, Converter & KeyValueFilterConverter to appropraite distributed streamClassorg.infinispan.filterInfinispan
CacheFilters .CacheFiltersExternalizerClassorg.infinispan.filter.CacheFiltersInfinispan
CacheListenerExceptionWraps exceptions produced by listener implementations.Classorg.infinispan.commonsInfinispan
CacheLoaderDefines the logic for loading data from an external storage.Interfaceorg.infinispan.persistence.spiInfinispan
CacheModeCache replication mode.Classorg.infinispan.configuration.cacheInfinispan
CachePermissionClassorg.infinispan.securityInfinispan
CachePermissionCollectionCachePermissionCollection.Classorg.infinispan.securityInfinispan
CacheQueryA cache-query is what will be returned when the getQuery() method is run on SearchManagerImpl.Interfaceorg.infinispan.queryInfinispan
CacheSetA set that also must implement the various CacheCollection methods for streams.Interfaceorg.infinispanInfinispan
CacheStartedThis annotation should be used on methods that need to be notified when a cache is started.Classorg.infinispan.notifications.cachemanagerlistener.annotationInfinispan
CacheStartedEventThis event is passed in to any method annotated with CacheStarted.Interfaceorg.infinispan.notifications.cachemanagerlistener.eventInfinispan
CacheStatisticCollectorCollects and maintains all the statistics for a cache.Classorg.infinispan.statsInfinispan
CacheStatisticManagerManages all the statistics for a single cache.Classorg.infinispan.statsInfinispan
CacheStoppedThis annotation should be used on methods that need to be notified when a cache is stopped.Classorg.infinispan.notifications.cachemanagerlistener.annotationInfinispan
CacheStoppedEventThis event is passed in to any method annotated with CacheStopped.Interfaceorg.infinispan.notifications.cachemanagerlistener.eventInfinispan
CacheStreamA Stream that has additional operations to monitor or control behavior when used from a Cache.Interfaceorg.infinispanInfinispan
CacheStream .SegmentCompletionListenerFunctional interface that is used as a callback when segments are completed.Interfaceorg.infinispan.CacheStreamInfinispan
CacheWriterAllows persisting data to an external storage, as opposed to the CacheLoader.Interfaceorg.infinispan.persistence.spiInfinispan
ClusterCacheStatsSimilar to Stats but cluster wide.Interfaceorg.infinispan.statsInfinispan
CompositeCacheEventFilterAllows AND-composing several cache event filters.Classorg.infinispan.notifications.cachelistener.filterInfinispan
ConverterAsCacheEventConverterCacheEventConverter that implements it's conversion solely on the use of the provided ConverterSince:7.Classorg.infinispan.notifications.cachelistener.filterInfinispan
ConverterAsCacheEventConverter .ExternalizerClassorg.infinispan.notifications.cachelistener.filter.ConverterAsCacheEventConverterInfinispan
DefaultCacheManagerA CacheManager is the primary mechanism for retrieving a Cache instance, and is often used as a starting point to using the Cache.Classorg.infinispan.managerInfinispan
DelegatingCacheEntryListenerInvocationA wrapper around a CacheEntryListenerInvocation that keeps a reference to the FilterIndexingServiceProvider instance that handles this invocation.Classorg.infinispan.notifications.cachelistener.filterInfinispan
EmbeddedCacheManagerEmbeddedCacheManager is an CacheManager that runs in the same JVM as the client.Interfaceorg.infinispan.managerInfinispan
EmbeddedCacheManagerStartupExceptionAn exception to encapsulate an error when starting up a cache managerSince:4.Classorg.infinispan.managerInfinispan
InternalCacheRegistryInternalCacheRegistry.Interfaceorg.infinispan.registryInfinispan
InternalCacheRegistry .FlagReturns the enum constant of this type with the specified name.Classorg.infinispan.registry.InternalCacheRegistryInfinispan
InvalidCacheUsageExceptionThrown when client makes cache usage errors.Classorg.infinispanInfinispan
KeyFilterAsCacheEventFilterCacheEventFilter that implements it's filtering solely on the use of the provided KeyFilterSince:7.Classorg.infinispan.notifications.cachelistener.filterInfinispan
KeyFilterAsCacheEventFilter .ExternalizerClassorg.infinispan.notifications.cachelistener.filter.KeyFilterAsCacheEventFilterInfinispan
KeyValueFilterAsCacheEventFilterCacheEventFilter that implements it's filtering solely on the use of the provided KeyValueFilterSince:7.Classorg.infinispan.notifications.cachelistener.filterInfinispan
KeyValueFilterAsCacheEventFilter .ExternalizerClassorg.infinispan.notifications.cachelistener.filter.KeyValueFilterAsCacheEventFilterInfinispan
MapReduceCacheLoaderTaskThis is an internal class, not intended to be used by clients.Classorg.infinispan.distexec.mapreduceInfinispan
MemcachedServerConfigurationMemcachedServerConfiguration.Classorg.infinispan.server.memcached.configurationInfinispan
MemcachedServerConfigurationBuilderMemcachedServerConfigurationBuilder.Classorg.infinispan.server.memcached.configurationInfinispan
NamedCacheNotFoundExceptionThrown when a named cache cannot be found.Classorg.infinispan.managerInfinispan
PostCacheEventFilterA Filter that only allows post events to be accepted.Classorg.infinispan.notifications.cachelistener.filterInfinispan
SecureCacheInterfaceorg.infinispan.securityInfinispan
TreeCacheThis is a tree-like facade around a Cache allowing for efficient tree-style access to cached data.Interfaceorg.infinispan.treeInfinispan
TreeCacheFactoryFactory class that contains API for users to create instances of TreeCacheAuthor:Navin SurtaniClassorg.infinispan.treeInfinispan
AuthCacheAbstract AuthScheme cache.Interfaceorg.apache.http.clientApache HttpComponents
BasicAuthCacheDefault implementation of AuthCache.Classorg.apache.http.impl.clientApache HttpComponents
RequestAuthCacheRequest interceptor that can preemptively authenticate against known hosts, if there is a cached AuthScheme instance in the localClassorg.apache.http.client.protocolApache HttpComponents
ResponseAuthCacheResponse interceptor that adds successfully completed AuthSchemes to the local AuthCache instance.Classorg.apache.http.client.protocolApache HttpComponents
AccessibleObjectCache Utility class to maintain runtime caches of Field, Method and Constructor for use by HGAtomType implementations.Classorg.hypergraphdb.utilHypergraphDb
CacheActionQueueSingleton Wrap a single instance of ActionQueueThread for use by all caches in a Author:Borislav IordanovClassorg.hypergraphdb.cacheHypergraphDb
CacheMap A simplified map interface for cache-only purposes.Interfaceorg.hypergraphdb.cacheHypergraphDb
DefaultAtomCache A default, simple implementation of a run-time cache of hypergraph atoms.Classorg.hypergraphdb.cacheHypergraphDb
HashCacheMapClassorg.hypergraphdb.cacheHypergraphDb
HGAtomCacheThe HGAtomCache interface abstracts the HyperGraph caching activities in order for different caching policies and implementationsInterfaceorg.hypergraphdbHypergraphDb
HGCache A simple generic, read-only caching interface.Interfaceorg.hypergraphdb.cacheHypergraphDb
LRUCache Implements a cache that keeps most recently used elements in memory while discarding the least recently used ones.Classorg.hypergraphdb.cacheHypergraphDb
PhantomRefAtomCacheClassorg.hypergraphdb.cacheHypergraphDb
SimpleCacheClassorg.hypergraphdb.cacheHypergraphDb
TxCacheMapClassorg.hypergraphdb.transactionHypergraphDb
TxCacheSetClassorg.hypergraphdb.transactionHypergraphDb
TxCacheSet .CacheSetTxBoxClassorg.hypergraphdb.transaction.TxCacheSetHypergraphDb
WeakRefAtomCache This cache implementation interacts with the Java garbage collector, by using the java.Classorg.hypergraphdb.cacheHypergraphDb
AccessLogValve .DateFormatCacheCache structure for formatted timestamps based on seconds.ClassTOMCAT
CacheEntryClassTOMCAT
ConcurrentCacheClassTOMCAT
ConcurrentCacheClassTOMCAT
CsrfPreventionFilter .LruCacheClassTOMCAT
DateFormatCacheCache structure for SimpleDateFormat formatted timestamps based on Millisecond formatting using S is not supported.ClassTOMCAT
MediaTypeCacheCaches the results of parsing content-type headers.ClassTOMCAT
ResourceCacheClassTOMCAT
StatementCacheInterceptor that caches PreparedStatement and/or CallableStatement instances on a connection.ClassTOMCAT
StringCacheThis class implements a String cache for ByteChunk and CharChunk.ClassTOMCAT
StringCache .ByteEntryClassTOMCAT
StringCache .CharEntryClassTOMCAT
TldLocationsCacheA container for all tag libraries that are defined "globally" for the web application.ClassTOMCAT
CachedRowSetImplCachedRowSet is an implementation of the JDBC RowSet API (javax.Classweblogic.jdbc.rowsetOracle WebLogic
CacheFilterA Filter implementation that is able to cache attributes and results from standard requests and responses.Classweblogic.cache.filterOracle WebLogic
CredentialCacheMBeanDefines methods used to get/set the configuration attributes that are required to support the credential cache.Interfaceweblogic.management.security.credentialsOracle WebLogic
GroupMembershipHierarchyCacheMBeanDefines methods used to get/set the configuration attributes that are required to support the Group Membership Hierarchy Cache.Interfaceweblogic.management.security.authenticationOracle WebLogic
SAMLUsedAssertionCacheSAMLUsedAssertionCache defines an interface for storing and checking information about consumed SAML assertions so that aInterfaceweblogic.security.providers.samlOracle WebLogic
TTLCacheFixed-size pseudo-LRU cache with per-entry TTL attributes.Classweblogic.security.aclOracle WebLogic
WLCachedRowSetWLCachedRowSet is an extension to the javax.Interfaceweblogic.jdbc.rowsetOracle WebLogic
ClassCacheA cache class for JavaClass objects, which enables us to quickly referenceAuthor:Doug Davis (dug@us.Classorg.apache.axis.utils.cacheApache Axis
JavaUtils .ConvertCacheIt the argument to the convert(.Interfaceorg.apache.axis.utils.JavaUtilsApache Axis
MethodCacheA cache for methods.Classorg.apache.axis.utils.cacheApache Axis
DefaultEntityCacheClassorg.mongodb.morphia.mapping.cacheMorphia MongoDb
DefaultEntityCacheFactoryDefault implementation of cache factory, returning the default entity cache.Classorg.mongodb.morphia.mapping.cacheMorphia MongoDb
EntityCacheA primarily internal class used by MorphiaIterator to track entities loaded from mongo to prevent multiple loads of objects when keys seen multiple times in a query result.Interfaceorg.mongodb.morphia.mapping.cacheMorphia MongoDb
EntityCacheFactoryFactory for entity caches.Interfaceorg.mongodb.morphia.mapping.cacheMorphia MongoDb
EntityCacheStatisticsClassorg.mongodb.morphia.mapping.cacheMorphia MongoDb
TransitiveGraphCacheDatastructure used to represent a closed transitive reflexive relation.Classorg.apache.jena.reasoner.transitiveReasonerApache Jena
EhcacheHCatDependencyCacheClassorg.apache.oozie.dependency.hcatApache Oozie
HCatDependencyCacheInterfaceorg.apache.oozie.dependency.hcatApache Oozie
SimpleHCatDependencyCacheClassorg.apache.oozie.dependency.hcatApache Oozie
AccumuloProxy .AsyncClient .clearLocatorCache_callClassorg.apache.accumulo.proxy.thrift.AccumuloProxy.AsyncClientApache Accumulo
AccumuloProxy .AsyncProcessor .clearLocatorCacheClassorg.apache.accumulo.proxy.thrift.AccumuloProxy.AsyncProcessorApache Accumulo
AccumuloProxy .clearLocatorCache_argsClassorg.apache.accumulo.proxy.thrift.AccumuloProxyApache Accumulo
AccumuloProxy .clearLocatorCache_args ._FieldsThe set of fields this struct contains, along with convenience methods for finding and manipulating them.Classorg.apache.accumulo.proxy.thrift.AccumuloProxy.clearLocatorCache_argsApache Accumulo
AccumuloProxy .clearLocatorCache_resultClassorg.apache.accumulo.proxy.thrift.AccumuloProxyApache Accumulo
AccumuloProxy .clearLocatorCache_result ._FieldsThe set of fields this struct contains, along with convenience methods for finding and manipulating them.Classorg.apache.accumulo.proxy.thrift.AccumuloProxy.clearLocatorCache_resultApache Accumulo
AccumuloProxy .Processor .clearLocatorCacheClassorg.apache.accumulo.proxy.thrift.AccumuloProxy.ProcessorApache Accumulo
BlockCacheBlock cache interface.Interfaceorg.apache.accumulo.core.file.blockfile.cacheApache Accumulo
CachableBlockFile .CachedBlockReadClassorg.apache.accumulo.core.file.blockfile.impl.CachableBlockFileApache Accumulo
CachedBlockRepresents an entry in the LruBlockCache.Classorg.apache.accumulo.core.file.blockfile.cacheApache Accumulo
CachedBlockQueueA memory-bound queue that will grow until an element brings total size >= maxSize.Classorg.apache.accumulo.core.file.blockfile.cacheApache Accumulo
CachedConfigurationClassorg.apache.accumulo.core.utilApache Accumulo
CacheEntryInterfaceorg.apache.accumulo.core.file.blockfile.cacheApache Accumulo
CacheTestCleanClassorg.apache.accumulo.test.functionalApache Accumulo
CacheTestReaderClassorg.apache.accumulo.test.functionalApache Accumulo
CacheTestWriterClassorg.apache.accumulo.test.functionalApache Accumulo
DistributedCacheHelperClassorg.apache.accumulo.core.client.mapreduce.lib.implApache Accumulo
LruBlockCacheA block cache implementation that is memory-aware using HeapSize, memory-bound using an LRU eviction algorithm, and concurrent: backed by a ConcurrentHashMap and with a non-blocking eviction thread giving constant-time cacheBlock(java.Classorg.apache.accumulo.core.file.blockfile.cacheApache Accumulo
LruBlockCache .CacheStatsClassorg.apache.accumulo.core.file.blockfile.cache.LruBlockCacheApache Accumulo
SimpleBlockCacheSimple one RFile soft reference cache.Classorg.apache.accumulo.core.file.blockfile.cacheApache Accumulo
ZooCacheA cache for values stored in ZooKeeper.Classorg.apache.accumulo.fate.zookeeperApache Accumulo
ZooCacheClassorg.apache.accumulo.server.zookeeperApache Accumulo
ZooCacheFactoryA factory for ZooCache instances.Classorg.apache.accumulo.fate.zookeeperApache Accumulo
ZooCachePropertyAccessorA helper object for accessing properties in a ZooCache.Classorg.apache.accumulo.server.confApache Accumulo
ReplicatorMessageSerializer .SmallCacheA cache that is designed for a small number (<= 32) of entries.Classakka.cluster.ddata.protobuf.ReplicatorMessageSerializerAkka
SimpleDnsCacheClassakka.ioAkka
SimpleDnsCache$Classakka.ioAkka
CachedBatchReadsMapClassstorm.trident.state.mapApache Storm
CachedBatchReadsMap .RetValClassstorm.trident.state.map.CachedBatchReadsMapApache Storm
CachedMapUseful to layer over a map that communicates with a database.Classstorm.trident.state.mapApache Storm
TimeCacheMapExpires keys that have not been updated in the configured number of seconds.Classbacktype.storm.utilsApache Storm
TimeCacheMap .ExpiredCallbackSkip navigation linksOverviewPackageClassUseTreeDeprecatedIndexHelpInterfacebacktype.storm.utils.TimeCacheMapApache Storm
InternalCachedBagClassorg.apache.pig.dataApache Pig
AggregateBy .CacheClasscascading.pipe.assembly.AggregateByCascading
BaseCacheFactoryBase class for all CacheFactories for creating CascadingCache instances.Classcascading.util.cacheCascading
CacheEvictionCallbackCacheEvictionCallBack is an interface to be used in conjunction with CascadingCache instances.Interfacecascading.util.cacheCascading
CascadingCacheInterface that defines a Cache.Interfacecascading.util.cacheCascading
DirectMappedCacheDirectMappedCache is an implementation of the CascadingCache interface following the semantics of http://en.Classcascading.util.cacheCascading
DirectMappedCacheFactoryConcrete sub-class of BaseCacheFactory for creating DirectMappedCache instances.Classcascading.util.cacheCascading
LRUHashMapCache evict the least recently used key.Classcascading.util.cacheCascading
LRUHashMapCacheFactoryClasscascading.util.cacheCascading
OrderedHashMapCache is used by default by Unique and AggregateBy and theirDirectMappedCacheFactory, Classcascading.util.cacheCascading
OrderedHashMapCacheFactoryClasscascading.util.cacheCascading
Unique .CacheClasscascading.pipe.assembly.UniqueCascading
CachedDNSToSwitchMappingA cached implementation of DNSToSwitchMapping that takes an raw DNSToSwitchMapping and stores the resolved network location in Classorg.apache.hadoop.netApache Hadoop
CacheFlagSpecifies semantics for CacheDirective operations.Classorg.apache.hadoop.fsApache Hadoop
DistributedCacheDistribute application-specific large, read-only files efficiently.Classorg.apache.hadoop.filecacheApache Hadoop
MetricsCacheA metrics cache for sinks that don't support sparse updates.Classorg.apache.hadoop.metrics2.utilApache Hadoop
NMTokenCacheNMTokenCache manages NMTokens required for an Application Master communicating with individual NodeManagers.Classorg.apache.hadoop.yarn.client.apiApache Hadoop
ReleaseSharedCacheResourceRequestThe request from clients to release a resource in the shared cache.Classorg.apache.hadoop.yarn.api.protocolrecordsApache Hadoop
ReleaseSharedCacheResourceResponse The response to clients from the SharedCacheManager when releasing a resource in the shared cache.Classorg.apache.hadoop.yarn.api.protocolrecordsApache Hadoop
SharedCacheChecksumInterfaceorg.apache.hadoop.yarn.sharedcacheApache Hadoop
SharedCacheChecksumFactoryClassorg.apache.hadoop.yarn.sharedcacheApache Hadoop
SharedCacheClientThis is the client for YARN's shared cache.Classorg.apache.hadoop.yarn.client.apiApache Hadoop
TokenCacheThis class provides user facing APIs for transferring secrets from the job client to the tasks.Classorg.apache.hadoop.mapreduce.securityApache Hadoop
UseSharedCacheResourceRequest The request from clients to the SharedCacheManager that claims a resource in the shared cache.Classorg.apache.hadoop.yarn.api.protocolrecordsApache Hadoop
UseSharedCacheResourceResponse The response from the SharedCacheManager to the client that indicates whether a requested resource exists in the cache.Classorg.apache.hadoop.yarn.api.protocolrecordsApache Hadoop
DistCacheProvides functions for working with Hadoop's distributed cache.Classorg.apache.crunch.utilApache Crunch
AggregateStatsCacheClassorg.apache.hadoop.hive.metastoreApache Hive
AggregateStatsCache .AggrColStatsClassorg.apache.hadoop.hive.metastore.AggregateStatsCacheApache Hive
DelegationTokenCacheClassorg.apache.hive.hcatalog.templeton.toolApache Hive
InstanceCacheCache for objects whose creation only depends on some other set of objects and therefore can be used against other equivalent versions of thoseClassorg.apache.hadoop.hive.serde2.avroApache Hive
IOPrepareCacheIOPrepareCache is used to cache pre-query io-related objects.Classorg.apache.hadoop.hive.ql.ioApache Hive
ObjectCacheObjectCache.Classorg.apache.hadoop.hive.ql.exec.mrApache Hive
ObjectCacheObjectCache.Interfaceorg.apache.hadoop.hive.ql.execApache Hive
ObjectCacheObjectCache.Classorg.apache.hadoop.hive.ql.exec.tezApache Hive
ObjectCacheFactoryClassorg.apache.hadoop.hive.ql.execApache Hive
CacheControlAn annotation which adds a constant Cache-Control header to the response produced by the annotated method.Classio.dropwizard.jersey.cachingDropWizard Jersey
CacheControlledResponseFeatureClassio.dropwizard.jersey.cachingDropWizard Jersey
DeploymentCacheA Deployer-like service which intercepts deploy/undeploy calls to MainDeployer and provides local caching of target URLs using Classorg.jboss.deployment.cacheJBoss System
DeploymentCacheMBeanFields inherited from interface org.Interfaceorg.jboss.deployment.cacheJBoss System
AbstractInstanceCacheBase class for caches of entity and stateful beans.Classorg.jboss.ejb.pluginsJBoss Server
AbstractInstanceCacheMBeanInterfaceorg.jboss.ejb.pluginsJBoss Server
BeanCacheMonitorClassorg.jboss.monitorJBoss Server
BeanCacheMonitorMBeanThe JMX management interface for the BeanCacheMonitor MBean.Interfaceorg.jboss.monitorJBoss Server
BeanCacheSnapshotClassorg.jboss.monitor.clientJBoss Server
CacheInterfaceorg.jboss.ejb.plugins.cmp.jdbc2.schemaJBoss Server
Cache .CacheLoaderInterfaceorg.jboss.ejb.plugins.cmp.jdbc2.schema.CacheJBoss Server
Cache .ListenerInterfaceorg.jboss.ejb.plugins.cmp.jdbc2.schema.CacheJBoss Server
Cache .RemoveExceptionSee Also:Serialized FormConstructor SummaryCache.Classorg.jboss.ejb.plugins.cmp.jdbc2.schema.CacheJBoss Server
CacheInvalidationConfigMetaDataManages attributes related to distributed (possibly local-only) cache invalidationsClassorg.jboss.metadataJBoss Server
CacheInvalidatorClassorg.jboss.ejb.plugins.cmp.jdbc2.schemaJBoss Server
CacheKeyCacheKey is an encapsulation of both the PrimaryKey and a cache specific key.Classorg.jboss.ejbJBoss Server
EntityBeanCacheBatchInvalidatorInterceptorThe role of this interceptor is to detect that an entity has been modified after an invocation has been performed an use the InvalidationsTxGrouperClassorg.jboss.cache.invalidation.triggersJBoss Server
EntityCacheEntityCaches can work from several keys.Interfaceorg.jboss.ejbJBoss Server
EntityInstanceCacheCache subclass for entity beans.Classorg.jboss.ejb.pluginsJBoss Server
EntityInstanceCacheMBeanInterfaceorg.jboss.ejb.pluginsJBoss Server
InstanceCacheThe plugin that gives a container a cache for bean instances.Interfaceorg.jboss.ejbJBoss Server
InvalidableEntityInstanceCacheCache implementation that registers with an InvalidationManager when in commit option A or D.Classorg.jboss.ejb.pluginsJBoss Server
JMSCacheInvalidationBridgeJMS implementation of a cache invalidation bridge Based on previous code of Bill Burke based on interceptorsClassorg.jboss.cache.invalidation.bridgesJBoss Server
JMSCacheInvalidationBridgeMBeanCache invalidation bridge based on JMS.Interfaceorg.jboss.cache.invalidation.bridgesJBoss Server
JMSCacheInvalidationMessageClassorg.jboss.cache.invalidation.bridgesJBoss Server
LRUEnterpriseContextCachePolicyLeast Recently Used cache policy for EnterpriseContexts.Classorg.jboss.ejb.pluginsJBoss Server
LRUStatefulContextCachePolicyLeast Recently Used cache policy for StatefulSessionEnterpriseContexts.Classorg.jboss.ejb.pluginsJBoss Server
ListCacheKeyListCacheKey extends CacheKey and holds info about the List that the entity belongs to, it is used with CMP 2.Classorg.jboss.ejbJBoss Server
NoPassivationCachePolicyClassorg.jboss.ejb.pluginsJBoss Server
PartitionedTableCacheClassorg.jboss.ejb.plugins.cmp.jdbc2.schemaJBoss Server
PartitionedTableCacheMBeanFields inherited from interface org.Interfaceorg.jboss.ejb.plugins.cmp.jdbc2.schemaJBoss Server
PerTxEntityInstanceCachePer transaction instance cache.Classorg.jboss.ejb.pluginsJBoss Server
ReadAheadCacheReadAheadCache stores all of the data readahead for an entity.Classorg.jboss.ejb.plugins.cmp.jdbcJBoss Server
ReadAheadCache .EntityReadAheadInfoClassorg.jboss.ejb.plugins.cmp.jdbc.ReadAheadCacheJBoss Server
StatefulSessionInstanceCacheCache for stateful session beans.Classorg.jboss.ejb.pluginsJBoss Server
TableCacheSimple LRU cache.Classorg.jboss.ejb.plugins.cmp.jdbc2.schemaJBoss Server
TableCacheMBeanFields inherited from interface org.Interfaceorg.jboss.ejb.plugins.cmp.jdbc2.schemaJBoss Server
DateCache Computes String representations of Dates and caches the results so that subsequent requests within the same secondClassorg.eclipse.jetty.utilJetty
DateCache .TickClassorg.eclipse.jetty.util.DateCacheJetty
PushCacheFilterA filter that builds a cache of secondary resources associated to primary resources.Classorg.eclipse.jetty.servletsJetty
PushSessionCacheFilterClassorg.eclipse.jetty.servletsJetty
PushSessionCacheFilter .TargetClassorg.eclipse.jetty.servlets.PushSessionCacheFilterJetty
ResourceCacheClassorg.eclipse.jetty.serverJetty
GeronimoTldLocationsCacheA container for all tag libraries that are defined "globally" for the web application.Classorg.apache.geronimo.jasperApache Geronimo
AWTGlyphGeometryCacheThis class represents a doubly indexed hash table, which holds soft references to the contained glyph geometry informations.Classorg.apache.batik.gvt.fontApache FOP Batik
AWTGlyphGeometryCache .ValueThe object that holds glyph geometry.Classorg.apache.batik.gvt.font.AWTGlyphGeometryCacheApache FOP Batik
CachedImageHandler allow caching of raster images in generated SVG content.Interfaceorg.apache.batik.svggenApache FOP Batik
CachedImageHandlerBase64EncoderThis subclass of ImageHandlerBase64Encoder implements functionality specific to the cached version of the imageClassorg.apache.batik.svggenApache FOP Batik
CachedImageHandlerJPEGEncoderGenericImageHandler which caches JPEG images.Classorg.apache.batik.svggenApache FOP Batik
CachedImageHandlerPNGEncoderGenericImageHandler which caches PNG images.Classorg.apache.batik.svggenApache FOP Batik
DefaultCachedImageHandlerThis class is a default implementation of the GenericImageHandler for handlers implementing a caching strategy.Classorg.apache.batik.svggenApache FOP Batik
FileCacheSeekableStreamA subclass of SeekableStream that may be used to wrap a regular InputStream.Classorg.apache.batik.ext.awt.image.codec.utilApache FOP Batik
ImageCacherThis class implements caching functionality for raster images.Classorg.apache.batik.svggenApache FOP Batik
ImageCacher .EmbeddedCache implementation for images embedded in the SVG file.Classorg.apache.batik.svggen.ImageCacherApache FOP Batik
ImageCacher .ExternalCache implementation for file-based images.Classorg.apache.batik.svggen.ImageCacherApache FOP Batik
LRUCacheClassorg.apache.batik.ext.awt.image.renderedApache FOP Batik
LRUCache .LRUObjInterfaceorg.apache.batik.ext.awt.image.rendered.LRUCacheApache FOP Batik
MemoryCacheSeekableStreamA subclass of SeekableStream that may be used to wrap a regular InputStream.Classorg.apache.batik.ext.awt.image.codec.utilApache FOP Batik
NamedProfileCacheThis class manages a cache of soft references to named profiles that we have already loaded.Classorg.apache.batik.ext.awt.colorApache FOP Batik
SoftReferenceCacheThis class manages a cache of soft references to objects that may take some time to load or create, such as images loaded from theClassorg.apache.batik.utilApache FOP Batik
TileCacheClassorg.apache.batik.ext.awt.image.renderedApache FOP Batik
TileCacheRedThis implementation of RenderedImage only serves to put the tiles generated by it's input into the TileCache.Classorg.apache.batik.ext.awt.image.renderedApache FOP Batik
URLImageCacheThis class manages a cache of soft references to Images that we have already loaded.Classorg.apache.batik.ext.awt.imageApache FOP Batik
InternCacheClasscom.fasterxml.jackson.core.utilFasterXML
CacheInterfaceorg.boon.cacheFastJson
CacheTypeClassorg.boon.cacheFastJson
ConcurrentLruCacheClassorg.boon.cacheFastJson
FastConcurrentReadLruLfuFifoCacheClassorg.boon.cacheFastJson
FastReaderSingleThreadedCacheClassorg.boon.cacheFastJson
FilterWithCacheClassorg.boon.datarepo.impl.decoratorsFastJson
FilterWithSimpleCacheClassorg.boon.datarepo.impl.decoratorsFastJson
SimpleCacheClassorg.boon.cacheFastJson
SimpleConcurrentCacheClassorg.boon.cacheFastJson
CachedIndexEntryClassorg.eclipse.jdt.internal.compiler.codegenECJ
CharArrayCacheClassorg.eclipse.jdt.internal.compiler.codegenECJ
DoubleCacheClassorg.eclipse.jdt.internal.compiler.codegenECJ
FloatCacheClassorg.eclipse.jdt.internal.compiler.codegenECJ
IntegerCacheClassorg.eclipse.jdt.internal.compiler.codegenECJ
LongCacheClassorg.eclipse.jdt.internal.compiler.codegenECJ
ObjectCacheClassorg.eclipse.jdt.internal.compiler.codegenECJ
AbstractJBossCacheProviderFields inherited from class org.Classorg.jboss.seam.cacheJBoss Seam
CacheProviderCacheProvider provides methods to control and manipulate the configured cacheAuthor:Sebastian Hennebrueder, Pete MuirClassorg.jboss.seam.cacheJBoss Seam
EhCacheProvider issues org.Classorg.jboss.seam.cacheJBoss Seam
JbossCache2ProviderClassorg.jboss.seam.cacheJBoss Seam
JbossCacheProviderClassorg.jboss.seam.cacheJBoss Seam
JBossELReferenceCacheConstructor SummaryJBossELReferenceCache()Methods inherited from class java.Classorg.jboss.seam.elJBoss Seam
JbossPojoCacheProviderClassorg.jboss.seam.cacheJBoss Seam
ArrayCachedClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
BigDecimalCachedClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
BigIntegerCachedClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
BooleanCachedClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
ByteCachedClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
CacheInterfacegroovy.json.internalGroovy
CachedClassClassorg.codehaus.groovy.reflectionGroovy
CachedClass .CachedMethodComparatorByNameClassorg.codehaus.groovy.reflection.CachedClassGroovy
CachedClass .CachedMethodComparatorWithStringClassorg.codehaus.groovy.reflection.CachedClassGroovy
CachedClosureClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
CachedConstructorClassorg.codehaus.groovy.reflectionGroovy
CachedFieldClassorg.codehaus.groovy.reflectionGroovy
CachedMethodClassorg.codehaus.groovy.reflectionGroovy
CachedSAMClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
CacheTypeClassgroovy.json.internalGroovy
CharacterCachedClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
DefaultCachedMethodKeyA default implementation of MethodKeyAuthor:James StrachanClassorg.codehaus.groovy.runtimeGroovy
DoubleCachedClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
FloatCachedClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
IntegerCachedClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
LongCachedClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
LRUCacheA cache backed by a Collections.Classorg.codehaus.groovy.runtime.memoizeGroovy
MemoizeCacheInterfaceorg.codehaus.groovy.runtime.memoizeGroovy
MetaMethodIndex .CacheEntryClassorg.codehaus.groovy.runtime.metaclass.MetaMethodIndexGroovy
NumberCachedClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
ObjectCachedClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
PogoMetaMethodSite .PogoCachedMethodSiteClassorg.codehaus.groovy.runtime.callsite.PogoMetaMethodSiteGroovy
PogoMetaMethodSite .PogoCachedMethodSiteNoUnwrapClassorg.codehaus.groovy.runtime.callsite.PogoMetaMethodSiteGroovy
PogoMetaMethodSite .PogoCachedMethodSiteNoUnwrapNoCoerceClassorg.codehaus.groovy.runtime.callsite.PogoMetaMethodSiteGroovy
PojoMetaMethodSite .PojoCachedMethodSiteClassorg.codehaus.groovy.runtime.callsite.PojoMetaMethodSiteGroovy
PojoMetaMethodSite .PojoCachedMethodSiteNoUnwrapClassorg.codehaus.groovy.runtime.callsite.PojoMetaMethodSiteGroovy
PojoMetaMethodSite .PojoCachedMethodSiteNoUnwrapNoCoerceClassorg.codehaus.groovy.runtime.callsite.PojoMetaMethodSiteGroovy
ReflectionCacheClassorg.codehaus.groovy.reflectionGroovy
ShortCachedClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
SimpleCacheClassgroovy.json.internalGroovy
StringCachedClassClassorg.codehaus.groovy.reflection.stdclassesGroovy
UnlimitedConcurrentCacheClassorg.codehaus.groovy.runtime.memoizeGroovy
CachedDateFormatCachedDateFormat optimizes the performance of a wrapped DateFormat.Classorg.apache.log4j.patternApache Log4j
CacheMapA fixed size hash map with LRU replacement.Classedu.stanford.nlp.utilStanford Parser
CacheParseHypothesesClassedu.stanford.nlp.parser.dvparserStanford Parser
Expressions .SimpleCachedExpressionA simple implementation of an expression that is represented by a java object of type T and which also has a cached Value stored with itClassedu.stanford.nlp.ling.tokensregex.types.ExpressionsStanford Parser
CachedDateTimeZoneImproves the performance of requesting time zone offsets and name keys by caching the results.Classorg.joda.time.tzJoda Time
CacheProviderInterfaceorg.primefaces.cachePrimeFaces
DefaultCacheProviderBasic cache provider for development purposes, should be avoided to use in production as there is no eviction and timeouts.Classorg.primefaces.cachePrimeFaces
EHCacheProviderClassorg.primefaces.cachePrimeFaces
HazelcastCacheProviderClassorg.primefaces.cachePrimeFaces
UICacheClassorg.primefaces.component.cachePrimeFaces
UICache .PropertyKeysClassorg.primefaces.component.cache.UICachePrimeFaces
UICacheRendererClassorg.primefaces.component.cachePrimeFaces
CacheBuilderClassorg.apache.ibatis.mappingMyBatis
CacheKeyClassorg.apache.ibatis.cacheMyBatis
NullCacheKeyClassorg.apache.ibatis.cacheMyBatis
CacheRefResolverClassorg.apache.ibatis.builderMyBatis
FifoCacheClassorg.apache.ibatis.cache.decoratorsMyBatis
CacheInterfaceorg.apache.ibatis.cacheMyBatis
LoggingCacheClassorg.apache.ibatis.cache.decoratorsMyBatis
LruCacheClassorg.apache.ibatis.cache.decoratorsMyBatis
PerpetualCacheClassorg.apache.ibatis.cache.implMyBatis
ScheduledCacheClassorg.apache.ibatis.cache.decoratorsMyBatis
SerializedCacheClassorg.apache.ibatis.cache.decoratorsMyBatis
SoftCacheClassorg.apache.ibatis.cache.decoratorsMyBatis
SynchronizedCacheClassorg.apache.ibatis.cache.decoratorsMyBatis
IncompleteCacheExceptionClassorg.apache.ibatis.builderMyBatis
CacheExceptionClassorg.apache.ibatis.cacheMyBatis
TransactionalCacheClassorg.apache.ibatis.cache.decoratorsMyBatis
TransactionalCacheManagerClassorg.apache.ibatis.cacheMyBatis
WeakCacheClassorg.apache.ibatis.cache.decoratorsMyBatis
CacheNamespaceRefClassorg.apache.ibatis.annotationsMyBatis
CacheNamespaceClassorg.apache.ibatis.annotationsMyBatis
EnvironmentCacheCache by a 'key' unique to the environment: - ClassLoader::groupContext::Object CacheClassorg.apache.commons.discovery.toolsApache Commons
Cache$Id: Cache.Interfaceorg.apache.commons.ognl.internalApache Commons
CacheEntryFactoryInterfaceorg.apache.commons.ognl.internal.entryApache Commons
CacheExceptionClassorg.apache.commons.ognl.internalApache Commons
CacheFactoryInterfaceorg.apache.commons.ognl.internalApache Commons
ClassCacheThis is a highly specialized map for storing values keyed by Class objects.Interfaceorg.apache.commons.ognl.internalApache Commons
ClassCacheEntryFactoryMethods inherited from interface org.Interfaceorg.apache.commons.ognl.internal.entryApache Commons
ClassCacheHandlerClassorg.apache.commons.ognl.internalApache Commons
ClassCacheImplClassorg.apache.commons.ognl.internalApache Commons
ClassCacheInspectorOptional interface that may be registered with OgnlRuntime.Interfaceorg.apache.commons.ognlApache Commons
ConcurrentHashMapCacheClassorg.apache.commons.ognl.internalApache Commons
ConcurrentHashMapCacheFactoryClassorg.apache.commons.ognl.internalApache Commons
ConcurrentHashMapClassCacheClassorg.apache.commons.ognl.internalApache Commons
DeclaredMethodCacheEntryClassorg.apache.commons.ognl.internal.entryApache Commons
DeclaredMethodCacheEntry .MethodTypeClassorg.apache.commons.ognl.internal.entry.DeclaredMethodCacheEntryApache Commons
DeclaredMethodCacheEntryFactoryClassorg.apache.commons.ognl.internal.entryApache Commons
FieldCacheEntryFactoryClassorg.apache.commons.ognl.internal.entryApache Commons
GenericMethodParameterTypeCacheEntryClassorg.apache.commons.ognl.internal.entryApache Commons
HashMapCacheClassorg.apache.commons.ognl.internalApache Commons
HashMapCacheFactoryClassorg.apache.commons.ognl.internalApache Commons
HashMapClassCacheClassorg.apache.commons.ognl.internalApache Commons
MethodAccessCacheEntryFactoryClassorg.apache.commons.ognl.internal.entryApache Commons
MethodCacheEntryClassorg.apache.commons.ognl.internal.entryApache Commons
MethodCacheEntryFactoryClassorg.apache.commons.ognl.internal.entryApache Commons
MethodPermCacheEntryFactoryClassorg.apache.commons.ognl.internal.entryApache Commons
OgnlCacheThis class takes care of all the internal caching for OGNL.Classorg.apache.commons.ognlApache Commons
ParametrizedCacheEntryFactoryInterfaceorg.apache.commons.ognl.internal.entryApache Commons
PermissionCacheEntryClassorg.apache.commons.ognl.internal.entryApache Commons
PermissionCacheEntryFactoryClassorg.apache.commons.ognl.internal.entryApache Commons
PropertyDescriptorCacheEntryFactoryClassorg.apache.commons.ognl.internal.entryApache Commons
ReentrantReadWriteLockCacheClassorg.apache.commons.ognl.internalApache Commons
ReentrantReadWriteLockCacheFactoryClassorg.apache.commons.ognl.internalApache Commons
ReentrantReadWriteLockClassCacheClassorg.apache.commons.ognl.internalApache Commons
ProxyClassCacheA cache for storing implementation classes for proxies based on a specific type of ProxyClassGenerator.Classorg.apache.commons.proxy2.implApache Commons
GroovyExtendableScriptCacheGroovyExtendableScriptCache is a general purpose and Serializable Groovy Script cache.Classorg.apache.commons.scxml2.env.groovyApache Commons
GroovyExtendableScriptCache .CompilerConfigurationFactorySerializable factory interface providing the Groovy CompilerConfiguration, needed to restore the specific CompilerConfiguration after de-serializationInterfaceorg.apache.commons.scxml2.env.groovy.GroovyExtendableScriptCacheApache Commons
GroovyExtendableScriptCache .ParentClassLoaderFactorySerializable factory interface providing the Groovy parent ClassLoader, needed to restore the specific ClassLoader after de-serializationInterfaceorg.apache.commons.scxml2.env.groovy.GroovyExtendableScriptCacheApache Commons
GroovyExtendableScriptCache .ScriptCacheElementClassorg.apache.commons.scxml2.env.groovy.GroovyExtendableScriptCacheApache Commons
GroovyExtendableScriptCache .ScriptPreProcessorInterfaceorg.apache.commons.scxml2.env.groovy.GroovyExtendableScriptCacheApache Commons
AbstractFilesCacheClassorg.apache.commons.vfs2.cacheApache Commons
CacheStrategyAn enumerated type to deal with the various cache strategies.Classorg.apache.commons.vfs2Apache Commons
DefaultFilesCacheA FilesCache implementation.Classorg.apache.commons.vfs2.cacheApache Commons
FilesCacheThe fileCache interface.Interfaceorg.apache.commons.vfs2Apache Commons
LRUFilesCacheThis implementation caches every file using LRUMap.Classorg.apache.commons.vfs2.cacheApache Commons
NullFilesCache A FilesCache implementation.Classorg.apache.commons.vfs2.cacheApache Commons
SoftRefFilesCacheThis implementation caches every file as long as it is strongly reachable by the java vm.Classorg.apache.commons.vfs2.cacheApache Commons
WeakRefFilesCacheThis implementation caches every file as long as it is strongly reachable by the java vm.Classorg.apache.commons.vfs2.cacheApache Commons
AbstractAuxiliaryCacheThis holds convenience methods used by most auxiliary caches.Classorg.apache.commons.jcs.auxiliaryApache Commons
AbstractAuxiliaryCacheAttributesThis has common attributes used by all auxiliaries.Classorg.apache.commons.jcs.auxiliaryApache Commons
AbstractAuxiliaryCacheEventLoggingAll ICacheEvents are defined as final.Classorg.apache.commons.jcs.auxiliaryApache Commons
AbstractCacheAccessThis class provides the common methods for all types of access to the cache.Classorg.apache.commons.jcs.accessApache Commons
AbstractCacheEventQueueClassorg.apache.commons.jcs.engineApache Commons
AbstractCacheEventQueue .NodeThe queue is composed of nodes.Classorg.apache.commons.jcs.engine.AbstractCacheEventQueueApache Commons
AbstractDiskCacheAbstract class providing a base implementation of a disk cache, which can be easily extended to implement a disk cache for a specific persistence mechanism.Classorg.apache.commons.jcs.auxiliary.diskApache Commons
AbstractDiskCacheAttributesThis has common attributes that any conceivable disk cache would need.Classorg.apache.commons.jcs.auxiliary.diskApache Commons
AbstractDiskCacheManagerCommon disk cache methods and properties.Classorg.apache.commons.jcs.auxiliary.diskApache Commons
AbstractDoubleLinkedListMemoryCacheThis class contains methods that are common to memory caches using the double linked list, such as the LRU, MRU, FIFO, and LIFO caches.Classorg.apache.commons.jcs.engine.memoryApache Commons
AbstractDoubleLinkedListMemoryCache .IteratorWrapperClassorg.apache.commons.jcs.engine.memory.AbstractDoubleLinkedListMemoryCacheApache Commons
AbstractDoubleLinkedListMemoryCache .MapEntryWrapperClassorg.apache.commons.jcs.engine.memory.AbstractDoubleLinkedListMemoryCacheApache Commons
AbstractMemoryCacheThis base includes some common code for memory caches.Classorg.apache.commons.jcs.engine.memoryApache Commons
AbstractRemoteAuxiliaryCacheAbstract base for remote caches.Classorg.apache.commons.jcs.auxiliary.remoteApache Commons
AbstractRemoteCacheListenerShared listener base.Classorg.apache.commons.jcs.auxiliary.remoteApache Commons
AbstractRemoteCacheNoWaitFacadeAn abstract base for the No Wait Facade.Classorg.apache.commons.jcs.auxiliary.remoteApache Commons
AbstractRemoteCacheServiceThis class contains common methods for remote cache services.Classorg.apache.commons.jcs.auxiliary.remote.http.serverApache Commons
AuxiliaryCacheTag interface for auxiliary caches.Interfaceorg.apache.commons.jcs.auxiliaryApache Commons
AuxiliaryCacheAttributesThis is a nominal interface that auxiliary cache attributes should implement.Interfaceorg.apache.commons.jcs.auxiliaryApache Commons
AuxiliaryCacheConfiguratorConfiguration util for auxiliary caches.Classorg.apache.commons.jcs.auxiliaryApache Commons
AuxiliaryCacheFactoryAll auxiliary caches must have a factory that the cache configurator can use to create instances.Interfaceorg.apache.commons.jcs.auxiliaryApache Commons
AuxiliaryCacheManagerInterfaceorg.apache.commons.jcs.auxiliaryApache Commons
BlockDiskCacheThere is one BlockDiskCache per region.Classorg.apache.commons.jcs.auxiliary.disk.blockApache Commons
BlockDiskCacheAttributesThis holds attributes for Block Disk Cache configuration.Classorg.apache.commons.jcs.auxiliary.disk.blockApache Commons
BlockDiskCacheFactoryCreates disk cache instances.Classorg.apache.commons.jcs.auxiliary.disk.blockApache Commons
BlockDiskCacheManagerCache manager for BlockDiskCaches.Classorg.apache.commons.jcs.auxiliary.disk.blockApache Commons
CacheAccessThis class provides an interface for all types of access to the cache.Classorg.apache.commons.jcs.accessApache Commons
CacheAdaptorUsed for Cache-to-Cache messaging purposes.Classorg.apache.commons.jcs.engineApache Commons
CacheConstantsConstants used throughout the JCS cache engineVersion:$Id: CacheConstants.Interfaceorg.apache.commons.jcs.engineApache Commons
CacheElementGeneric element wrapper.Classorg.apache.commons.jcs.engineApache Commons
CacheElementInfoClassorg.apache.commons.jcs.adminApache Commons
CacheElementSerializedEither serialized value or the value should be null;See Also:Serialized FormClassorg.apache.commons.jcs.engineApache Commons
CacheEventIt's returned from create and passed into log.Classorg.apache.commons.jcs.engine.loggingApache Commons
CacheEventLoggerDebugLoggerThis implementation simple logs to a commons logger at debug level, for all events.Classorg.apache.commons.jcs.engine.loggingApache Commons
CacheEventQueueAn event queue is used to propagate ordered cache events to one and only one target listener.Classorg.apache.commons.jcs.engineApache Commons
CacheEventQueueFactoryThis class hands out event Queues.Classorg.apache.commons.jcs.engineApache Commons
CacheExceptionThis is the most general exception the cache throws.Classorg.apache.commons.jcs.access.exceptionApache Commons
CacheGroupHolder for attributes specific to a group.Classorg.apache.commons.jcs.engineApache Commons
CacheInfoThis is a static variable holder for the distribution auxiliaries that need something like a vmid.Classorg.apache.commons.jcs.engineApache Commons
CacheListenersClassorg.apache.commons.jcs.engineApache Commons
CacheRegionInfoClassorg.apache.commons.jcs.adminApache Commons
CacheStatsThis class stores cache historical and statistics data for a region.Classorg.apache.commons.jcs.engine.statsApache Commons
CacheStatusClassorg.apache.commons.jcs.engineApache Commons
CacheWatchRepairableIntercepts the requests to the underlying ICacheObserver object so that the listeners can be recorded locally for remote connection recovery purposes.Classorg.apache.commons.jcs.engineApache Commons
CommonRemoteCacheAttributesAttributes common to remote cache client and server.Classorg.apache.commons.jcs.auxiliary.remoteApache Commons
CompositeCacheThis is the primary hub for a single cache/region.Classorg.apache.commons.jcs.engine.controlApache Commons
CompositeCacheAttributesThe CompositeCacheAttributes defines the general cache region settings.Classorg.apache.commons.jcs.engineApache Commons
CompositeCacheConfiguratorThis class configures JCS based on a properties object.Classorg.apache.commons.jcs.engine.controlApache Commons
CompositeCacheManagerManages a composite cache.Classorg.apache.commons.jcs.engine.controlApache Commons
FIFOMemoryCacheThe items are spooled in the order they are added.Classorg.apache.commons.jcs.engine.memory.fifoApache Commons
GroupCacheAccessClassorg.apache.commons.jcs.accessApache Commons
HSQLDiskCacheFactoryThis factory should create mysql disk caches.Classorg.apache.commons.jcs.auxiliary.disk.jdbc.hsqlApache Commons
ICacheThis is the top level interface for all cache like structures.Interfaceorg.apache.commons.jcs.engine.behaviorApache Commons
ICacheAccessICacheAccess defines the behavior for client access.Interfaceorg.apache.commons.jcs.access.behaviorApache Commons
ICacheAccessManagementICacheAccessManagement defines the methods for cache management, cleanup and shutdown.Interfaceorg.apache.commons.jcs.access.behaviorApache Commons
ICacheElementEvery item is the cache is wrapped in an ICacheElement.Interfaceorg.apache.commons.jcs.engine.behaviorApache Commons
ICacheElementSerializedThis interface defines the behavior of the serialized element wrapper.Interfaceorg.apache.commons.jcs.engine.behaviorApache Commons
ICacheEventDefines the common fields required by a cache event.Interfaceorg.apache.commons.jcs.engine.logging.behaviorApache Commons
ICacheEventLoggerThis defines the behavior for event logging.Interfaceorg.apache.commons.jcs.engine.logging.behaviorApache Commons
ICacheEventQueueInterface for a cache event queue.Interfaceorg.apache.commons.jcs.engine.behaviorApache Commons
ICacheEventQueue .QueueTypeDoes not use a thread pool.Classorg.apache.commons.jcs.engine.behavior.ICacheEventQueueApache Commons
ICacheListenerUsed to receive a cache event notification.Interfaceorg.apache.commons.jcs.engine.behaviorApache Commons
ICacheManagerInterface implemented by a specific cache.Interfaceorg.apache.commons.jcs.engine.behaviorApache Commons
ICacheObserverUsed to register interest in receiving cache changes.Interfaceorg.apache.commons.jcs.engine.behaviorApache Commons
ICacheRestoreInterfaceorg.apache.commons.jcs.engine.behaviorApache Commons
ICacheServiceUsed to retrieve and update the cache.Interfaceorg.apache.commons.jcs.engine.behaviorApache Commons
ICacheServiceAdminInterfaceorg.apache.commons.jcs.engine.behaviorApache Commons
ICacheServiceNonLocalUsed to retrieve and update non local caches, such as the remote and lateral caches.Interfaceorg.apache.commons.jcs.engine.behaviorApache Commons
ICacheStatsThis holds stat information on a region.Interfaceorg.apache.commons.jcs.engine.stats.behaviorApache Commons
ICacheTypeInterface implemented by a specific cache.Interfaceorg.apache.commons.jcs.engine.behaviorApache Commons
ICacheType .CacheTypeComposite/ memory cache type, central hub.Classorg.apache.commons.jcs.engine.behavior.ICacheTypeApache Commons
ICommonRemoteCacheAttributesThis specifies what a remote cache configuration object should look like.Interfaceorg.apache.commons.jcs.auxiliary.remote.behaviorApache Commons
ICompositeCacheAttributesThis defines the minimal behavior for the Cache Configuration settings.Interfaceorg.apache.commons.jcs.engine.behaviorApache Commons
ICompositeCacheAttributes .DiskUsagePatternItems will only go to disk when the memory limit is reached.Classorg.apache.commons.jcs.engine.behavior.ICompositeCacheAttributesApache Commons
ICompositeCacheManagerI need the interface so I can plug in mock managers for testing.Interfaceorg.apache.commons.jcs.engine.behaviorApache Commons
IDiskCacheAttributesCommon disk cache attributes.Interfaceorg.apache.commons.jcs.auxiliary.disk.behaviorApache Commons
IGroupCacheAccessInterfaceorg.apache.commons.jcs.access.behaviorApache Commons
ILateralCacheAttributesThis interface defines configuration options common to lateral cache plugins.Interfaceorg.apache.commons.jcs.auxiliary.lateral.behaviorApache Commons
ILateralCacheAttributes .TypeClassorg.apache.commons.jcs.auxiliary.lateral.behavior.ILateralCacheAttributesApache Commons
ILateralCacheListenerListens for lateral cache event notification.Interfaceorg.apache.commons.jcs.auxiliary.lateral.behaviorApache Commons
ILateralCacheManagerInterfaceorg.apache.commons.jcs.auxiliary.lateral.behaviorApache Commons
ILateralCacheObserverInterfaceorg.apache.commons.jcs.auxiliary.lateral.behaviorApache Commons
IMemoryCacheFor the framework.Interfaceorg.apache.commons.jcs.engine.memory.behaviorApache Commons
IndexedDiskCacheDisk cache that uses a RandomAccessFile with keys stored in memory.Classorg.apache.commons.jcs.auxiliary.disk.indexedApache Commons
IndexedDiskCache .PositionComparatorCompares IndexedDiskElementDescriptor based on their position.Classorg.apache.commons.jcs.auxiliary.disk.indexed.IndexedDiskCacheApache Commons
IndexedDiskCacheAttributesConfiguration class for the Indexed Disk CacheSee Also:Serialized FormClassorg.apache.commons.jcs.auxiliary.disk.indexedApache Commons
IndexedDiskCacheFactoryCreates disk cache instances.Classorg.apache.commons.jcs.auxiliary.disk.indexedApache Commons
IndexedDiskCacheManagerCache manager for IndexedDiskCaches.Classorg.apache.commons.jcs.auxiliary.disk.indexedApache Commons
IRemoteCacheAttributesThis specifies what a remote cache configuration object should look like.Interfaceorg.apache.commons.jcs.auxiliary.remote.behaviorApache Commons
IRemoteCacheClientThis defines the behavior expected of a remote cache client.Interfaceorg.apache.commons.jcs.auxiliary.remote.behaviorApache Commons
IRemoteCacheConstantsThis holds constants that are used by the remote cache.Interfaceorg.apache.commons.jcs.auxiliary.remote.behaviorApache Commons
IRemoteCacheDispatcherIn the future, this can be used as a generic dispatcher abstraction.Interfaceorg.apache.commons.jcs.auxiliary.remote.behaviorApache Commons
IRemoteCacheListenerListens for remote cache event notification ( rmi callback ).Interfaceorg.apache.commons.jcs.auxiliary.remote.behaviorApache Commons
IRemoteCacheObserverUsed to register interest in receiving remote cache changes.Interfaceorg.apache.commons.jcs.auxiliary.remote.behaviorApache Commons
IRemoteCacheServerInterface for managing Remote objectsAuthor:Thomas VandahlInterfaceorg.apache.commons.jcs.auxiliary.remote.server.behaviorApache Commons
IRemoteCacheServerAttributesThis defines the minimal behavior for the objects that are used to configure the remote cache server.Interfaceorg.apache.commons.jcs.auxiliary.remote.server.behaviorApache Commons
IRemoteHttpCacheClientIt's not entirely clear that this interface is needed.Interfaceorg.apache.commons.jcs.auxiliary.remote.http.client.behaviorApache Commons
IRemoteHttpCacheConstantsConstants used throughout the HTTP remote cache.Interfaceorg.apache.commons.jcs.auxiliary.remote.http.behaviorApache Commons
ITCPLateralCacheAttributesThis interface defines functions that are particular to the TCP Lateral Cache plugin.Interfaceorg.apache.commons.jcs.auxiliary.lateral.socket.tcp.behaviorApache Commons
JDBCDiskCacheThis is the jdbc disk cache plugin.Classorg.apache.commons.jcs.auxiliary.disk.jdbcApache Commons
JDBCDiskCacheAttributesThe configurator will set these values based on what is in the cache.Classorg.apache.commons.jcs.auxiliary.disk.jdbcApache Commons
JDBCDiskCacheFactoryThis factory should create mysql disk caches.Classorg.apache.commons.jcs.auxiliary.disk.jdbcApache Commons
JDBCDiskCacheManagerThis manages instances of the jdbc disk cache.Classorg.apache.commons.jcs.auxiliary.disk.jdbcApache Commons
JDBCDiskCacheManagerAbstractTemplateThis class serves as an abstract template for JDBCDiskCache Manager.Classorg.apache.commons.jcs.auxiliary.disk.jdbcApache Commons
JDBCDiskCachePoolAccessThis class provides access to the connection pool.Classorg.apache.commons.jcs.auxiliary.disk.jdbcApache Commons
JDBCDiskCachePoolAccessAttributesThese are used to configure the JDBCDiskCachePoolAccess class.Classorg.apache.commons.jcs.auxiliary.disk.jdbcApache Commons
JDBCDiskCachePoolAccessManagerManages JDBCDiskCachePoolAccess instances.Classorg.apache.commons.jcs.auxiliary.disk.jdbcApache Commons
LateralCacheLateral distributor.Classorg.apache.commons.jcs.auxiliary.lateralApache Commons
LateralCacheAbstractFactoryParticular lateral caches should define their own factory.Classorg.apache.commons.jcs.auxiliary.lateralApache Commons
LateralCacheAbstractManagerCreates lateral caches.Classorg.apache.commons.jcs.auxiliary.lateralApache Commons
LateralCacheAttributesThis class stores attributes for all of the available lateral cache auxiliaries.Classorg.apache.commons.jcs.auxiliary.lateralApache Commons
LateralCacheMonitorUsed to monitor and repair any failed connection for the lateral cache service.Classorg.apache.commons.jcs.auxiliary.lateralApache Commons
LateralCacheNoWaitUsed to queue up update requests to the underlying cache.Classorg.apache.commons.jcs.auxiliary.lateralApache Commons
LateralCacheNoWaitFacadeUsed to provide access to multiple services under nowait protection.Classorg.apache.commons.jcs.auxiliary.lateralApache Commons
LateralCacheRestoreUsed to repair the lateral caches managed by the associated instance of LateralCacheManager.Classorg.apache.commons.jcs.auxiliary.lateralApache Commons
LateralCacheWatchRepairableSame as CacheWatcherWrapper but implements the IRemoteCacheWatch interface.Classorg.apache.commons.jcs.auxiliary.lateralApache Commons
LateralTCPCacheFactoryConstructs a LateralCacheNoWaitFacade for the given configuration.Classorg.apache.commons.jcs.auxiliary.lateral.socket.tcpApache Commons
LateralTCPCacheManagerCreates lateral caches.Classorg.apache.commons.jcs.auxiliary.lateral.socket.tcpApache Commons
LHMLRUMemoryCacheThis is a test memory manager using the jdk1.Classorg.apache.commons.jcs.engine.memory.lruApache Commons
LRUMemoryCacheA fast reference management system.Classorg.apache.commons.jcs.engine.memory.lruApache Commons
MRUMemoryCacheThe most recently used items move to the front of the list and get spooled to disk if the cache hub is configured to use a disk cache.Classorg.apache.commons.jcs.engine.memory.mruApache Commons
MySQLDiskCacheThe MySQLDiskCache extends the core JDBCDiskCache.Classorg.apache.commons.jcs.auxiliary.disk.jdbc.mysqlApache Commons
MySQLDiskCacheAttributesThis has additional attributes that are particular to the MySQL disk cache.Classorg.apache.commons.jcs.auxiliary.disk.jdbc.mysqlApache Commons
MySQLDiskCacheFactoryThis factory should create mysql disk caches.Classorg.apache.commons.jcs.auxiliary.disk.jdbc.mysqlApache Commons
MySQLDiskCacheManagerThis manages instances of the MySQL jdbc disk cache.Classorg.apache.commons.jcs.auxiliary.disk.jdbc.mysqlApache Commons
PartitionedCacheAccessTODO: Add new methods that will allow you to provide a partition indicator for all major calls.Classorg.apache.commons.jcs.accessApache Commons
PooledCacheEventQueueAn event queue is used to propagate ordered cache events to one and only one target listener.Classorg.apache.commons.jcs.engineApache Commons
RemoteCacheClient proxy for an RMI remote cache.Classorg.apache.commons.jcs.auxiliary.remoteApache Commons
RemoteCacheAttributesThese objects are used to configure the remote cache client.Classorg.apache.commons.jcs.auxiliary.remoteApache Commons
RemoteCacheFactoryThe RemoteCacheFactory creates remote caches for the cache hub.Classorg.apache.commons.jcs.auxiliary.remoteApache Commons
RemoteCacheFailoverRunnerThe RemoteCacheFailoverRunner tries to establish a connection with a failover server, if any are defined.Classorg.apache.commons.jcs.auxiliary.remoteApache Commons
RemoteCacheListenerRegistered with RemoteCache server.Classorg.apache.commons.jcs.auxiliary.remoteApache Commons
RemoteCacheManagerAn instance of RemoteCacheManager corresponds to one remote connection of a specific host and port.Classorg.apache.commons.jcs.auxiliary.remoteApache Commons
RemoteCacheMonitorUsed to monitor and repair any failed connection for the remote cache service.Classorg.apache.commons.jcs.auxiliary.remoteApache Commons
RemoteCacheNoWaitThe RemoteCacheNoWait wraps the RemoteCacheClient.Classorg.apache.commons.jcs.auxiliary.remoteApache Commons
RemoteCacheNoWaitFacadeUsed to provide access to multiple services under nowait protection.Classorg.apache.commons.jcs.auxiliary.remoteApache Commons
RemoteCacheRequestThe basic request wrapper.Classorg.apache.commons.jcs.auxiliary.remote.valueApache Commons
RemoteCacheRequestFactoryThis creates request objects.Classorg.apache.commons.jcs.auxiliary.remote.utilApache Commons
RemoteCacheResponseThis is the response wrapper.Classorg.apache.commons.jcs.auxiliary.remote.valueApache Commons
RemoteCacheRestoreUsed to repair the remote caches managed by the associated instance of RemoteCacheManager.Classorg.apache.commons.jcs.auxiliary.remoteApache Commons
RemoteCacheServerThis class provides remote cache services.Classorg.apache.commons.jcs.auxiliary.remote.serverApache Commons
RemoteCacheServerAttributesThese attributes are used to configure the remote cache server.Classorg.apache.commons.jcs.auxiliary.remote.serverApache Commons
RemoteCacheServerFactoryProvides remote cache services.Classorg.apache.commons.jcs.auxiliary.remote.serverApache Commons
RemoteCacheServiceAdaptorThe Servlet deserializes the request object.Classorg.apache.commons.jcs.auxiliary.remote.http.serverApache Commons
RemoteCacheStartupServletThis servlet can be used to startup the JCS remote cache.Classorg.apache.commons.jcs.auxiliary.remote.serverApache Commons
RemoteCacheWatchRepairableSame as CacheWatcherWrapper but implements the IRemoteCacheWatch interface.Classorg.apache.commons.jcs.auxiliary.remoteApache Commons
RemoteHttpCacheThis uses an http client as the service.Classorg.apache.commons.jcs.auxiliary.remote.http.clientApache Commons
RemoteHttpCacheAttributesHttp client specific settings.Classorg.apache.commons.jcs.auxiliary.remote.http.clientApache Commons
RemoteHttpCacheClientThis is the service used by the remote http auxiliary cache.Classorg.apache.commons.jcs.auxiliary.remote.http.clientApache Commons
RemoteHttpCacheDispatcherClassorg.apache.commons.jcs.auxiliary.remote.http.clientApache Commons
RemoteHttpCacheFactoryThe RemoteCacheFactory creates remote caches for the cache hub.Classorg.apache.commons.jcs.auxiliary.remote.http.clientApache Commons
RemoteHttpCacheManagerThis is a very crude copy of the RMI remote manager.Classorg.apache.commons.jcs.auxiliary.remote.http.clientApache Commons
RemoteHttpCacheMonitorUpon the notification of a connection error, the monitor changes to operate in a time driven mode.Classorg.apache.commons.jcs.auxiliary.remote.http.clientApache Commons
RemoteHttpCacheServerAttributesConfiguration for the RemoteHttpCacheServer.Classorg.apache.commons.jcs.auxiliary.remote.http.serverApache Commons
RemoteHttpCacheServiceThis does the work.Classorg.apache.commons.jcs.auxiliary.remote.http.serverApache Commons
RemoteHttpCacheServletThis servlet simply reads and writes objects.Classorg.apache.commons.jcs.auxiliary.remote.http.serverApache Commons
RemoteHttpCacheSeviceFactoryClassorg.apache.commons.jcs.auxiliary.remote.http.serverApache Commons
TCPLateralCacheAttributesThis interface defines functions that are particular to the TCP Lateral Cache plugin.Classorg.apache.commons.jcs.auxiliary.lateral.socket.tcpApache Commons
ZombieCacheServiceZombie adapter for any cache service.Classorg.apache.commons.jcs.engineApache Commons
ZombieCacheServiceNonLocalZombie adapter for the non local cache services.Classorg.apache.commons.jcs.engineApache Commons
ZombieCacheServiceNonLocal .ZombieEventBase of the other events.Classorg.apache.commons.jcs.engine.ZombieCacheServiceNonLocalApache Commons
ZombieCacheWatchClassorg.apache.commons.jcs.engineApache Commons
ZombieLateralCacheWatchClassorg.apache.commons.jcs.auxiliary.lateralApache Commons
ZombieRemoteCacheWatchClassorg.apache.commons.jcs.auxiliary.remoteApache Commons
AbstractCacheThis class provides a skeletal implementation of the Cache interface to minimize the effort required to implement this interface.Classcom.google.common.cacheGoogle Guava
AbstractCache .SimpleStatsCounterA thread-safe AbstractCache.Classcom.google.common.cache.AbstractCacheGoogle Guava
AbstractCache .StatsCounterAccumulates statistics during the operation of a Cache for presentation by Cache.Interfacecom.google.common.cache.AbstractCacheGoogle Guava
AbstractLoadingCacheThis class provides a skeletal implementation of the Cache interface to minimize the effort required to implement this interface.Classcom.google.common.cacheGoogle Guava
CacheA semi-persistent mapping from keys to values.Interfacecom.google.common.cacheGoogle Guava
CacheBuilderA builder of LoadingCache and Cache instances having any combination of the following features:Classcom.google.common.cacheGoogle Guava
CacheBuilderSpecA specification of a CacheBuilder configuration.Classcom.google.common.cacheGoogle Guava
CacheLoaderComputes or retrieves values, based on a key, for use in populating a LoadingCache.Classcom.google.common.cacheGoogle Guava
CacheLoader .InvalidCacheLoadExceptionThrown to indicate that an invalid response was returned from a call to CacheLoader.Classcom.google.common.cache.CacheLoaderGoogle Guava
CacheStatsStatistics about the performance of a Cache.Classcom.google.common.cacheGoogle Guava
ForwardingCacheA cache which forwards all its method calls to another cache.Classcom.google.common.cacheGoogle Guava
ForwardingCache .SimpleForwardingCacheA simplified version of ForwardingCache where subclasses can pass in an already constructed Cache as the delegete.Classcom.google.common.cache.ForwardingCacheGoogle Guava
ForwardingLoadingCacheA cache which forwards all its method calls to another cache.Classcom.google.common.cacheGoogle Guava
ForwardingLoadingCache .SimpleForwardingLoadingCacheA simplified version of ForwardingLoadingCache where subclasses can pass in an already constructed LoadingCache as the delegete.Classcom.google.common.cache.ForwardingLoadingCacheGoogle Guava
LoadingCacheA semi-persistent mapping from keys to values.Interfacecom.google.common.cacheGoogle Guava
QNameCache QNameCache caches instances of QName for reuse both across documents and within documents.Classdom4j.treeSourceforge Dom4j
NamespaceCache NamespaceCache caches instances of DefaultNamespace for reuse both across documents and withinClassdom4j.treeSourceforge Dom4j
CachedDatasetInterfacenet.sf.jasperreports.data.cacheSourceforge Jasper Reports
ColumnCacheDataInterfacenet.sf.jasperreports.data.cacheSourceforge Jasper Reports
ColumnDataCacheHandlerReport data cache handler that collects data in column stores.Classnet.sf.jasperreports.data.cacheSourceforge Jasper Reports
DataCacheHandlerReport data cache handler.Interfacenet.sf.jasperreports.data.cacheSourceforge Jasper Reports
JasperDesignCacheClassnet.sf.jasperreports.repoSourceforge Jasper Reports
JasperDesignReportResourceCacheClassnet.sf.jasperreports.repoSourceforge Jasper Reports
JRAbstractLRUVirtualizer .CacheReferenceClassnet.sf.jasperreports.engine.fill.JRAbstractLRUVirtualizerSourceforge Jasper Reports
JRFillDataset .CacheRecordIndexCallbackInterfacenet.sf.jasperreports.engine.fill.JRFillDatasetSourceforge Jasper Reports
JRFillDataset .CacheRecordIndexChainedCallbackClassnet.sf.jasperreports.engine.fill.JRFillDatasetSourceforge Jasper Reports
JRIncrementerFactoryCacheClassnet.sf.jasperreports.engine.fillSourceforge Jasper Reports
JRSingletonCacheUtility to use as a soft cache of singleton instances.Classnet.sf.jasperreports.engine.utilSourceforge Jasper Reports
PopulatedSnapshotCacheHandlerClassnet.sf.jasperreports.data.cacheSourceforge Jasper Reports
ResetInCacheCommandClassnet.sf.jasperreports.web.commandsSourceforge Jasper Reports
StandardCachedDatasetClassnet.sf.jasperreports.data.cacheSourceforge Jasper Reports
StandardColumnCacheDataClassnet.sf.jasperreports.data.cacheSourceforge Jasper Reports
StyleCacheClassnet.sf.jasperreports.engine.export.oasisSourceforge Jasper Reports
ANDROIDBlobCacheNative bindings to the ANDROID_blob_cache extension.Classorg.lwjgl.eglLWJGL
CacheProvides fixed size, pre-allocated, least recently used replacement cache.Classopennlp.tools.utilNatural Language Processing (OpenNLP)
CachedFeatureGeneratorCaches features of the aggregated AdaptiveFeatureGenerators.Classopennlp.tools.util.featuregenNatural Language Processing (OpenNLP)
CachedPropertyNodeClassorg.apache.poi.hwpf.modelApache POI
XSSFPivotCacheClassorg.apache.poi.xssf.usermodelApache POI
XSSFPivotCacheDefinitionClassorg.apache.poi.xssf.usermodelApache POI
XSSFPivotCacheRecordsClassorg.apache.poi.xssf.usermodelApache POI
AbstractBinaryMemcacheDecoderDecoder for both BinaryMemcacheRequest and BinaryMemcacheResponse.Classio.netty.handler.codec.memcache.binaryNetty
AbstractBinaryMemcacheEncoderA MessageToByteEncoder that encodes binary memache messages into bytes.Classio.netty.handler.codec.memcache.binaryNetty
AbstractBinaryMemcacheMessageDefault implementation of a BinaryMemcacheMessage.Classio.netty.handler.codec.memcache.binaryNetty
AbstractMemcacheObjectThe default MemcacheObject implementation.Classio.netty.handler.codec.memcacheNetty
AbstractMemcacheObjectAggregatorA ChannelHandler that aggregates an MemcacheMessageand its following MemcacheContents into a single MemcacheMessage withClassio.netty.handler.codec.memcacheNetty
AbstractMemcacheObjectDecoderAbstract super class for both ascii and binary decoders.Classio.netty.handler.codec.memcacheNetty
AbstractMemcacheObjectEncoderA general purpose AbstractMemcacheObjectEncoder that encodes MemcacheMessages.Classio.netty.handler.codec.memcacheNetty
BinaryMemcacheClientCodecThe client codec that combines the proper encoder and decoder.Classio.netty.handler.codec.memcache.binaryNetty
BinaryMemcacheMessageAn interface that defines a binary Memcache message, providing common properties forBinaryMemcacheRequest and BinaryMemcacheResponse.Interfaceio.netty.handler.codec.memcache.binaryNetty
BinaryMemcacheObjectAggregatorAn object aggregator for the memcache binary protocol.Classio.netty.handler.codec.memcache.binaryNetty
BinaryMemcacheOpcodesRepresents all Opcodes that can occur in a BinaryMemcacheMessage.Classio.netty.handler.codec.memcache.binaryNetty
BinaryMemcacheRequestRepresents a full BinaryMemcacheRequest, which contains the header and optional key and extras.Interfaceio.netty.handler.codec.memcache.binaryNetty
BinaryMemcacheRequestDecoderThe decoder part which takes care of decoding the request-specific headers.Classio.netty.handler.codec.memcache.binaryNetty
BinaryMemcacheRequestEncoderThe encoder part which takes care of encoding the request headers.Classio.netty.handler.codec.memcache.binaryNetty
BinaryMemcacheResponseRepresents a full BinaryMemcacheResponse, which contains the header and optional key and extras.Interfaceio.netty.handler.codec.memcache.binaryNetty
BinaryMemcacheResponseDecoderThe decoder which takes care of decoding the response headers.Classio.netty.handler.codec.memcache.binaryNetty
BinaryMemcacheResponseEncoderThe encoder which takes care of encoding the response headers.Classio.netty.handler.codec.memcache.binaryNetty
BinaryMemcacheResponseStatusContains all possible status values a BinaryMemcacheResponse can return.Classio.netty.handler.codec.memcache.binaryNetty
BinaryMemcacheServerCodecThe full server codec that combines the correct encoder and decoder.Classio.netty.handler.codec.memcache.binaryNetty
DefaultBinaryMemcacheRequestThe default implementation of the BinaryMemcacheRequest.Classio.netty.handler.codec.memcache.binaryNetty
DefaultBinaryMemcacheResponseThe default implementation of the BinaryMemcacheResponse.Classio.netty.handler.codec.memcache.binaryNetty
DefaultFullBinaryMemcacheRequestThe default implementation of a FullBinaryMemcacheRequest.Classio.netty.handler.codec.memcache.binaryNetty
DefaultFullBinaryMemcacheResponseThe default implementation of a FullBinaryMemcacheResponse.Classio.netty.handler.codec.memcache.binaryNetty
DefaultLastMemcacheContentThe default implementation for the LastMemcacheContent.Classio.netty.handler.codec.memcacheNetty
DefaultMemcacheContentThe default MemcacheContent implementation.Classio.netty.handler.codec.memcacheNetty
FullBinaryMemcacheRequestA BinaryMemcacheRequest that also includes the content.Interfaceio.netty.handler.codec.memcache.binaryNetty
FullBinaryMemcacheResponseA BinaryMemcacheResponse that also includes the content.Interfaceio.netty.handler.codec.memcache.binaryNetty
FullMemcacheMessageCombines MemcacheMessage and LastMemcacheContent into onemessage.Interfaceio.netty.handler.codec.memcacheNetty
LastMemcacheContentThe MemcacheContent which signals the end of the content batch.Interfaceio.netty.handler.codec.memcacheNetty
MemcacheContentAn Memcache content chunk.Interfaceio.netty.handler.codec.memcacheNetty
MemcacheMessageMarker interface for both ascii and binary messages.Interfaceio.netty.handler.codec.memcacheNetty
MemcacheObjectDefines a common interface for all MemcacheObject implementations.Interfaceio.netty.handler.codec.memcacheNetty
ApplicationContext .ResourceCacheDictionaryResource cache dictionary implementation.Classorg.apache.pivot.wtk.ApplicationContextApache Pivot
CacheInterfacejavax.persistenceHibernate JPA
CacheableClassjavax.persistenceHibernate JPA
CacheRetrieveModeClassjavax.persistenceHibernate JPA
CacheStoreModeClassjavax.persistenceHibernate JPA
SharedCacheModeClassjavax.persistenceHibernate JPA
BytecodeCacheClassplay.classloadingPlay
CacheClassplay.cachePlay
CachedBoundActionMethodArgsClassplay.data.bindingPlay
CacheExceptionClassplay.exceptionsPlay
CacheForClassplay.cachePlay
CacheImplInterfaceplay.cachePlay
EhCacheImplClassplay.cachePlay
MemcachedImplClassplay.cachePlay
CacheManagerAware I n t e r f a c e i m p l e m e n t e d b y c o m p o n e n t s t h a t u t i l i z e a C a c h e M a n a g e r a n d w i s h t h a t C a c h e M a n a g e r t o b e s u p p l i e d i f T h i s i s u s e d s o i n t e r n a l s e c u r i t y c o m p o n e n t s t h a t u s e a C a c h e M a n a g e r c a n b e i n j e c t e d w i t h i t i n s t e a d o f h a v i n g Interfaceorg.apache.shiro.cacheApache Shiro
CacheManager A C a c h e M a n a g e r p r o v i d e s a n d m a i n t a i n s t h e l i f e c y c l e s o f C a c h e i n s t a n c e s . Interfaceorg.apache.shiro.cacheApache Shiro
CacheException R o o t c l a s s o f a l l S h i r o e x c e p t i o n s r e l a t e d t o c a c h i n g o p e r a t i o n s . Classorg.apache.shiro.cacheApache Shiro
Cache A C a c h e e f f i c i e n t l y s t o r e s t e m p o r a r y o b j e c t s p r i m a r i l y t o i m p r o v e a n a p p l i c a t i o n ' s p e r f o r m a n c e . Interfaceorg.apache.shiro.cacheApache Shiro
AbstractCacheManager V e r y s i m p l e a b s t r a c t C a c h e M a n a g e r i m p l e m e n t a t i o n t h a t r e t a i n s a l l c r e a t e d C a c h e i n s t a n c e s i n a n i n - m e m o r y C o n c u r r e n t M a p . Classorg.apache.shiro.cacheApache Shiro
CacheInterfaceorg.huihoo.ofbiz.smart.base.cacheGlassFish
Cache .EvictionStrategyClassorg.huihoo.ofbiz.smart.base.cache.CacheGlassFish
DefaultCacheClassorg.huihoo.ofbiz.smart.base.cacheGlassFish
SimpleCacheManagerClassorg.huihoo.ofbiz.smart.base.cacheGlassFish
SimpleCacheManagerClassorg.huihoo.ofbiz.smart.base.cacheApache OfBiz
DefaultCacheClassorg.huihoo.ofbiz.smart.base.cacheApache OfBiz
Cache .EvictionStrategyClassorg.huihoo.ofbiz.smart.base.cache.CacheApache OfBiz
CacheInterfaceorg.huihoo.ofbiz.smart.base.cacheApache OfBiz
EhCache S h i r o C a c h e i m p l e m e n t a t i o n t h a t w r a p s a n E h c a c h e i n s t a n c e . Classorg.apache.shiro.cache.ehcacheApache Shiro
EhCacheManager S h i r o C a c h e M a n a g e r i m p l e m e n t a t i o n u t i l i z i n g t h e E h c a c h e f r a m e w o r k f o r a l l c a c h e f u n c t i o n a l i t y . Classorg.apache.shiro.cache.ehcacheApache Shiro
EnterpriseCacheSessionDAO S e s s i o n D A O i m p l e m e n t a t i o n t h a t r e l i e s o n a n e n t e r p r i s e c a c h i n g p r o d u c t a s t h e E I S s y s t e m o f r e c o r d f o r a l l s e s s i o n s . Classorg.apache.shiro.session.mgt.eisApache Shiro
MapCache A M a p C a c h e i s a C a c h e i m p l e m e n t a t i o n t h a t u s e s a b a c k i n g M a p i n s t a n c e t o s t o r e a n d r e t r i e v e c a c h e d d a t a . Classorg.apache.shiro.cacheApache Shiro
MemoryConstrainedCacheManager S i m p l e m e m o r y - o n l y b a s e d C a c h e M a n a g e r i m p l e m e n t a t i o n u s a b l e i n p r o d u c t i o n e n v i r o n m e n t s . Classorg.apache.shiro.cacheApache Shiro
ActionCommandCacheClasscom.liferay.util.bridges.mvcLiferay Portal
BasePortalCacheClusterChannelClasscom.liferay.portal.kernel.cache.clusterLiferay Portal
BlockingPortalCacheClasscom.liferay.portal.kernel.cacheLiferay Portal
BufferCacheServletResponse N e s t e d C l a s s S u m m a r y N e s t e d c l a s s e s / i n t e r f a c e s i n h e r i t e d f r o m c l a s s c o m . Classcom.liferay.portal.kernel.servletLiferay Portal
CacheField Classcom.liferay.portal.modelLiferay Portal
CacheKeyGeneratorInterfacecom.liferay.portal.kernel.cache.keyLiferay Portal
CacheKeyGeneratorUtilClasscom.liferay.portal.kernel.cache.keyLiferay Portal
CacheKVPClasscom.liferay.portal.kernel.cacheLiferay Portal
CacheListenerInterfacecom.liferay.portal.kernel.cacheLiferay Portal
CacheListenerScope e n u m C a c h e L i s t e n e r S c o p e e x t e n d s E n u m < C a c h e L i s t e n e r S c o p e > E n u m C o n s t a n t S u m m a r y A L L Classcom.liferay.portal.kernel.cacheLiferay Portal
CacheModeInterfacecom.liferay.portal.kernel.dao.ormLiferay Portal
CacheModeImpl F i e l d s i n h e r i t e d f r o m i n t e r f a c e c o m . Classcom.liferay.portal.kernel.dao.ormLiferay Portal
CacheModel Interfacecom.liferay.portal.modelLiferay Portal
CacheRegistryInterfacecom.liferay.portal.kernel.cacheLiferay Portal
CacheRegistryItem Interfacecom.liferay.portal.kernel.cacheLiferay Portal
CacheRegistryUtilClasscom.liferay.portal.kernel.cacheLiferay Portal
CacheResponseData S e e A l s o : S e r i a l i z e d F o r m C o n s t r u c t o r S u m m a r y C a c h e R e s p o n s e D a t a ( ) Classcom.liferay.util.servlet.filtersLiferay Portal
CacheResponseUtilClasscom.liferay.util.servlet.filtersLiferay Portal
ConcurrentLFUCacheClasscom.liferay.portal.kernel.concurrentLiferay Portal
EntityCacheInterfacecom.liferay.portal.kernel.dao.ormLiferay Portal
EntityCacheUtilClasscom.liferay.portal.kernel.dao.ormLiferay Portal
FileCacheOutputStreamClasscom.liferay.portal.kernel.ioLiferay Portal
FinderCacheInterfacecom.liferay.portal.kernel.dao.ormLiferay Portal
FinderCacheUtilClasscom.liferay.portal.kernel.dao.ormLiferay Portal
IntrabandPortalCacheClasscom.liferay.portal.kernel.nio.intraband.cacheLiferay Portal
IntrabandPortalCacheManagerClasscom.liferay.portal.kernel.nio.intraband.cacheLiferay Portal
MetaInfoCacheServletResponseClasscom.liferay.portal.kernel.servletLiferay Portal
MetaInfoCacheServletResponse .MetaData S e e A l s o : S e r i a l i z e d F o r m C o n s t r u c t o r S u m m a r y M e t a I n f o C a c h e S e r v l e t R e s p o n s e . Classcom.liferay.portal.kernel.servlet.MetaInfoCacheServletResponseLiferay Portal
MethodCacheClasscom.liferay.portal.kernel.utilLiferay Portal
PortalCacheInterfacecom.liferay.portal.kernel.cacheLiferay Portal
PortalCacheActionType e n u m P o r t a l C a c h e A c t i o n T y p e e x t e n d s E n u m < P o r t a l C a c h e A c t i o n T y p e > E n u m C o n s t a n t S u m m a r y D E S T R O Y Classcom.liferay.portal.kernel.nio.intraband.cacheLiferay Portal
PortalCacheClusterChannelInterfacecom.liferay.portal.kernel.cache.clusterLiferay Portal
PortalCacheClusterChannelFactoryInterfacecom.liferay.portal.kernel.cache.clusterLiferay Portal
PortalCacheClusterChannelSelectorInterfacecom.liferay.portal.kernel.cache.clusterLiferay Portal
PortalCacheClusterEventClasscom.liferay.portal.kernel.cache.clusterLiferay Portal
PortalCacheClusterEventCoalesceComparatorClasscom.liferay.portal.kernel.cache.clusterLiferay Portal
PortalCacheClusterEventType e n u m P o r t a l C a c h e C l u s t e r E v e n t T y p e e x t e n d s E n u m < P o r t a l C a c h e C l u s t e r E v e n t T y p e > E n u m C o n s t a n t S u m m a r y E V I C T E D Classcom.liferay.portal.kernel.cache.clusterLiferay Portal
PortalCacheClusterException S e e A l s o : S e r i a l i z e d F o r m C o n s t r u c t o r S u m m a r y P o r t a l C a c h e C l u s t e r E x c e p t i o n ( ) Classcom.liferay.portal.kernel.cache.clusterLiferay Portal
PortalCacheClusterLinkClasscom.liferay.portal.kernel.cache.clusterLiferay Portal
PortalCacheClusterLinkUtilClasscom.liferay.portal.kernel.cache.clusterLiferay Portal
PortalCacheDatagramReceiveHandlerClasscom.liferay.portal.kernel.nio.intraband.cacheLiferay Portal
PortalCacheException S e e A l s o : S e r i a l i z e d F o r m C o n s t r u c t o r S u m m a r y P o r t a l C a c h e E x c e p t i o n ( ) Classcom.liferay.portal.kernel.cacheLiferay Portal
PortalCacheIndexerClasscom.liferay.portal.kernel.cache.indexLiferay Portal
PortalCacheManagerInterfacecom.liferay.portal.kernel.cacheLiferay Portal
PortalCacheMapSynchronizeUtilClasscom.liferay.portal.kernel.cacheLiferay Portal
PortalCacheMapSynchronizeUtil .SynchronizerInterfacecom.liferay.portal.kernel.cache.PortalCacheMapSynchronizeUtilLiferay Portal
RestrictedByteArrayCacheOutputStreamClasscom.liferay.portal.kernel.ioLiferay Portal
RestrictedByteArrayCacheOutputStream .FlushPreAction Interfacecom.liferay.portal.kernel.io.RestrictedByteArrayCacheOutputStreamLiferay Portal
RestrictedByteBufferCacheServletResponse N e s t e d C l a s s S u m m a r y N e s t e d c l a s s e s / i n t e r f a c e s i n h e r i t e d f r o m c l a s s c o m . Classcom.liferay.portal.kernel.servletLiferay Portal
ThreadLocalCacheClasscom.liferay.portal.kernel.cacheLiferay Portal
ThreadLocalCacheManagerClasscom.liferay.portal.kernel.cacheLiferay Portal
UniformPortalCacheClusterChannelSelectorClasscom.liferay.portal.kernel.cache.clusterLiferay Portal
WebCacheException S e e A l s o : S e r i a l i z e d F o r m C o n s t r u c t o r S u m m a r y W e b C a c h e E x c e p t i o n ( ) Classcom.liferay.portal.kernel.webcacheLiferay Portal
WebCacheItemInterfacecom.liferay.portal.kernel.webcacheLiferay Portal
WebCachePoolInterfacecom.liferay.portal.kernel.webcacheLiferay Portal
WebCachePoolUtilClasscom.liferay.portal.kernel.webcacheLiferay Portal
DoubleLUCacheClassJSci.maths.matricesJSCI
ComplexLUCacheClassJSci.maths.matricesJSCI
CachedObjectAn object with a timeout.Classorg.knopflerfish.utilOSGI
CacheMapTimeout version of a HashMap.Classorg.knopflerfish.utilOSGI
CacheableMetadataProviderA CacheableMetadataProvider provides simple caching methods to avoid calling MetadataProvider.Classorg.apache.felix.ipojo.manipulator.metadataApache Felix
CallableStatementCacheClassorg.mariadb.jdbc.internal.utilMariaDB
CallableStatementCacheKeyClassorg.mariadb.jdbc.internal.util.daoMariaDB
PrepareStatementCacheClassorg.mariadb.jdbc.internal.utilMariaDB
PrepareStatementCacheKeyClassorg.mariadb.jdbc.internal.util.daoMariaDB
CacheInterface hiding cache implementation.Interfaceninja-core.ninja.cacheSpark Micro Web
CacheEhCacheImplEhCache implementation.Classninja-core.ninja.cacheSpark Micro Web
CacheMemcachedImplMemcached implementation (using http://code.Classninja-core.ninja.cacheSpark Micro Web
CacheProviderA provider that determines which implementation to load as Cache based on the value of key CacheConstant#CACHE_IMPLEMENTATION inClassninja-core.ninja.cacheSpark Micro Web
HttpCacheToolkitInterfaceninja-core.ninja.utilsSpark Micro Web
HttpCacheToolkitImplClassninja-core.ninja.utilsSpark Micro Web
NinjaCacheA convenience class to access the underlaying cache implementation.Classninja-core.ninja.cacheSpark Micro Web
InstrumentedCacheInstruments the configured Ninja Cache instance for Metrics collection.Classninja-metrics.ninja.metricsSpark Micro Web
InstrumentedEhCacheClassninja-metrics.ninja.metricsSpark Micro Web
InstrumentedMemcachedClassninja-metrics.ninja.metricsSpark Micro Web
CacheInterface hiding cache implementation.Interfaceninja.cacheNinja
CacheEhCacheImplEhCache implementation.Classninja.cacheNinja
CacheMemcachedImplMemcached implementation (using http://code.Classninja.cacheNinja
CacheProviderA provider that determines which implementation to load as Cache based on the value of key CacheConstant#CACHE_IMPLEMENTATION inClassninja.cacheNinja
HttpCacheToolkitInterfaceninja.utilsNinja
HttpCacheToolkitImplClassninja.utilsNinja
NinjaCacheA convenience class to access the underlaying cache implementation.Classninja.cacheNinja
InstrumentedCacheInstruments the configured Ninja Cache instance for Metrics collection.Classninja.metricsNinja
InstrumentedEhCacheClassninja.metricsNinja
InstrumentedMemcachedClassninja.metricsNinja
LRUCacheClassdipJDIP
LookupCacheThe LookupCache interface defines the methods provided by the object created and returned by the Interfacenet.jiniApache River ( Jini )
AbstractCacheServerFactory Describe your class here .Classorg.apache.oodt.cas.filemgr.ingestApache OODT
Cache The core interface for a cache of Products (identified by a particular uniqueElement) from a File Manager.Interfaceorg.apache.oodt.cas.filemgr.ingestApache OODT
CachedIngester An extension of the StdIngester that uses a Cache to keep track of Product ingestion status.Classorg.apache.oodt.cas.filemgr.ingestApache OODT
CacheExceptionClassorg.apache.oodt.cas.filemgr.structs.exceptionsApache OODT
CacheFactoryInterfaceorg.apache.oodt.cas.filemgr.ingestApache OODT
CacheMapA cache map is a map with a built-in cache.Classorg.apache.oodt.commons.utilApache OODT
LocalCacheClassorg.apache.oodt.cas.filemgr.ingestApache OODT
LocalCacheFactoryClassorg.apache.oodt.cas.filemgr.ingestApache OODT
RemoteableCache A Java RMI Remote-able implementation of the Cache .Interfaceorg.apache.oodt.cas.filemgr.ingestApache OODT
RmiCache An RMI client to the RmiCacheServer, implementing an RMI front end .Classorg.apache.oodt.cas.filemgr.ingestApache OODT
RmiCacheFactory Constructs new RmiCaches.Classorg.apache.oodt.cas.filemgr.ingestApache OODT
RmiCacheServerClassorg.apache.oodt.cas.filemgr.ingestApache OODT
RmiCacheServerFactory Constructs new RmiCacheServers.Classorg.apache.oodt.cas.filemgr.ingestApache OODT
CacheAndWriteOutputStreamThis outputstream implementation will both write to the outputstream that is specified and cache the data at the same time.Classorg.apache.cxf.ioApache CXF
CacheCleanupListenerClassorg.apache.cxf.ws.security.cacheApache CXF
CacheControlClientReaderInterceptorClassorg.apache.cxf.jaxrs.client.cacheApache CXF
CacheControlClientRequestFilterClassorg.apache.cxf.jaxrs.client.cacheApache CXF
CacheControlFeatureClassorg.apache.cxf.jaxrs.client.cacheApache CXF
CacheControlHeaderProviderClassorg.apache.cxf.jaxrs.implApache CXF
CachedClassClassorg.apache.cxf.common.utilApache CXF
CachedOutputStreamClassorg.apache.cxf.ioApache CXF
CachedOutputStreamCallbackInterfaceorg.apache.cxf.ioApache CXF
CachedWriterClassorg.apache.cxf.ioApache CXF
CachedWriterCallbackInterfaceorg.apache.cxf.ioApache CXF
CacheMap but strongly references the data.Classorg.apache.cxf.common.utilApache CXF
CacheSizeExceededExceptionClassorg.apache.cxf.ioApache CXF
CacheUtilsClassorg.apache.cxf.sts.cacheApache CXF
CXFEHCacheReplayCacheWrap the default WSS4J EHCacheReplayCache in a BusLifeCycleListener, to make sure that the cache is shutdown correctly.Classorg.apache.cxf.ws.security.cacheApache CXF
DefaultEHCacheCodeDataProviderClassorg.apache.cxf.rs.security.oauth2.grants.codeApache CXF
DefaultEHCacheOAuthDataProviderClassorg.apache.cxf.rs.security.oauth2.providerApache CXF
DefaultMessageIdCacheAn implementation that uses a simple set to store received message IDs.Classorg.apache.cxf.ws.addressing.implApache CXF
EHCacheIdentityCacheA EH-Cache based cache to cache identities in different realms where the relationship is of type FederateIdentity.Classorg.apache.cxf.sts.cacheApache CXF
EHCacheSPStateManagerAn in-memory EHCache implementation of the SPStateManager interface.Classorg.apache.cxf.rs.security.saml.sso.stateApache CXF
EHCacheTokenReplayCacheAn in-memory EHCache implementation of the TokenReplayCache interface.Classorg.apache.cxf.rs.security.saml.ssoApache CXF
EHCacheTokenStoreAn in-memory EHCache implementation of the TokenStore interface.Classorg.apache.cxf.ws.security.tokenstoreApache CXF
EHCacheTokenStoreFactoryA factory to return an EHCacheTokenStore instance.Classorg.apache.cxf.ws.security.tokenstoreApache CXF
EHCacheUtilClassorg.apache.cxf.rs.security.oauth2.utilsApache CXF
EHCacheUtilClassorg.apache.cxf.rs.security.saml.ssoApache CXF
EHCacheUtilClassorg.apache.cxf.xkms.cacheApache CXF
EHCacheUtilsClassorg.apache.cxf.ws.security.cacheApache CXF
EHCacheXKMSClientCacheAn in-memory EHCache implementation of the XKMSClientCache interface.Classorg.apache.cxf.xkms.cacheApache CXF
IdentityCacheInterfaceorg.apache.cxf.sts.cacheApache CXF
JAXBContextCacheClassorg.apache.cxf.common.jaxbApache CXF
JAXBContextCache .CachedContextAndSchemasReturn holder of the context, classes, etc.Classorg.apache.cxf.common.jaxbApache CXF
MemoryIdentityCacheA simple in-memory HashMap based cache to cache identities in different realms where the relationship is of type FederateIdentity.Classorg.apache.cxf.sts.cacheApache CXF
MemoryIdentityCacheStatisticsClassorg.apache.cxf.sts.cacheApache CXF
MessageIdCacheInterface abstracting various ID caches for enforcement of ID uniqueness.Interfaceorg.apache.cxf.ws.addressingApache CXF
PhaseChainCacheThe PhaseChainCache provides default interceptor chains for SOAP requests and responses, both from the client and web service side.Classorg.apache.cxf.phaseApache CXF
TokenReplayCacheInterfaceorg.apache.cxf.rs.security.saml.ssoApache CXF
TypeMapCacheClassorg.apache.cxf.binding.corbaApache CXF
XKMSCacheTokenClassorg.apache.cxf.xkms.cacheApache CXF
XKMSClientCacheInterfaceorg.apache.cxf.xkms.cacheApache CXF
XSLTOutInterceptor .XSLTCachedOutputStreamCallbackClassorg.apache.cxf.feature.transformApache CXF
XSLTOutInterceptor .XSLTCachedWriterClassorg.apache.cxf.feature.transformApache CXF
AbstractCacheAbstract base class for managed Caches.Classorg.apache.jackrabbit.core.cacheApache JackRabbit
BitSetENTCacheImpl information about participating node types in a set.Classorg.apache.jackrabbit.core.nodetypeApache JackRabbit
Cache A cache must call CacheManager.Interfaceorg.apache.jackrabbit.core.cacheApache JackRabbit
CacheAccessListenerThe cache access listener can be registered to a class.Interfaceorg.apache.jackrabbit.core.cacheApache JackRabbit
CacheBehaviourCacheBehaviour defines constants for the various cache maintenance strategies.Classorg.apache.jackrabbit.jcr2spi.configApache JackRabbit
CacheManagerThis class manages the size of the caches used in Jackrabbit.Classorg.apache.jackrabbit.core.cacheApache JackRabbit
CacheManager .CacheInfoInternal copy of the cache information.Classorg.apache.jackrabbit.core.cacheApache JackRabbit
ConcurrentCacheConcurrent cache implementation that uses cache segments to minimize the chance of lock contention.Classorg.apache.jackrabbit.core.cacheApache JackRabbit
EffectiveNodeTypeCacheEffectiveNodeTypeCache defines the interface for a cache for effective node types.Interfaceorg.apache.jackrabbit.core.nodetypeApache JackRabbit
EffectiveNodeTypeCacheEffectiveNodeTypeCache defines the interface for a cache for effective node types.Interfaceorg.apache.jackrabbit.jcr2spi.nodetypeApache JackRabbit
EffectiveNodeTypeCache .KeyAn ENTKey uniquely identifies a combination (i.Interfaceorg.apache.jackrabbit.core.nodetypeApache JackRabbit
EffectiveNodeTypeCache .KeyAn ENTKey uniquely identifies a combination (i.Interfaceorg.apache.jackrabbit.jcr2spi.nodetypeApache JackRabbit
EffectiveNodeTypeCacheImplEffectiveNodeTypeCache implementation that uses an array of node type names as key for caching the effective node types.Classorg.apache.jackrabbit.core.nodetypeApache JackRabbit
HashCacheSimple utility class that implements a fixed-size and thread-safe (non-blocking) cache of objects.Classorg.apache.jackrabbit.spi.commons.nameApache JackRabbit
ItemCacheInterfaceorg.apache.jackrabbit.jcr2spiApache JackRabbit
ItemCacheImplClassorg.apache.jackrabbit.jcr2spiApache JackRabbit
ItemInfoCacheItemInfoCache instances are responsible for caching ItemInfos along with an opaque generation counter.Interfaceorg.apache.jackrabbit.spiApache JackRabbit
ItemInfoCache .EntryThis class represents a cache entry.Classorg.apache.jackrabbit.spiApache JackRabbit
ItemInfoCacheImplThis implementation of ItemInfoCache has a default size of 5000 items.Classorg.apache.jackrabbit.spi.commonsApache JackRabbit
ItemStateCacheInterfaceorg.apache.jackrabbit.core.stateApache JackRabbit
ItemStateCacheFactoryAn item state cache factory to construct new item state caches.Interfaceorg.apache.jackrabbit.core.stateApache JackRabbit
ItemStateReferenceCacheItemStateReferenceCache internally consists of 2 components: an ItemStateReferenceMap serving as the primary (or main)Classorg.apache.jackrabbit.core.stateApache JackRabbit
ManagedMLRUItemStateCacheFactoryThis class constructs new MLRUItemStateCache.Classorg.apache.jackrabbit.core.stateApache JackRabbit
MembershipCacheClassorg.apache.jackrabbit.core.security.userApache JackRabbit
MLRUItemStateCacheAn ItemStateCache implementation that internally uses a LinkedMap to maintain a cache of ItemState objects.Classorg.apache.jackrabbit.core.stateApache JackRabbit
NodeTypeCacheClassorg.apache.jackrabbit.jcr2spi.nodetypeApache JackRabbit
SharedFieldCache The lucene FieldCache class has some sort of support for custom comparators but it only works on the basis of a field name.Classorg.apache.jackrabbit.core.query.luceneApache JackRabbit
SharedFieldCache .ValueIndexExpert: Stores term text values and document ordering data.Classorg.apache.jackrabbit.core.query.luceneApache JackRabbit
StringCacheA few String utility functions.Classorg.apache.jackrabbit.spi.commons.utilApache JackRabbit
TermDocsCacheClassorg.apache.jackrabbit.core.query.luceneApache JackRabbit
CachedAtomicIntegerClassorg.apache.curator.framework.recipes.atomicApache Curator
CachedAtomicLongClassorg.apache.curator.framework.recipes.atomicApache Curator
DefaultTreeCacheSelectorClassorg.apache.curator.framework.recipes.cacheApache Curator
NodeCacheA utility that attempts to keep the data from a node locally cached.Classorg.apache.curator.framework.recipes.cacheApache Curator
NodeCacheListenerCalled when a change has occurred throws ExceptionInterfaceorg.apache.curator.framework.recipes.cacheApache Curator
NodeCacheProjectionClassorg.apache.curator.x.rpc.idl.structsApache Curator
PathCacheExampleAn example of the PathChildrenCache.ClasscacheApache Curator
PathChildrenCacheA utility that attempts to keep all data from all children of a ZK path locally cached.Classorg.apache.curator.framework.recipes.cacheApache Curator
PathChildrenCache .StartModeMethod of priming cache on PathChildrenCache.Classorg.apache.curator.framework.recipes.cacheApache Curator
PathChildrenCacheEventClassorg.apache.curator.framework.recipes.cacheApache Curator
PathChildrenCacheEvent .TypeA child was added to the pathA child was removed from the pathClassorg.apache.curator.framework.recipes.cacheApache Curator
PathChildrenCacheListenerInterfaceorg.apache.curator.framework.recipes.cacheApache Curator
PathChildrenCacheModeenum PathChildrenCacheModeControls which data is cachedClassorg.apache.curator.framework.recipes.cacheApache Curator
PathChildrenCacheProjectionClassorg.apache.curator.x.rpc.idl.structsApache Curator
PathChildrenCacheStartModeenum PathChildrenCacheStartModeEnum Constant SummaryClassorg.apache.curator.x.rpc.idl.structsApache Curator
RpcPathChildrenCacheEventClassorg.apache.curator.x.rpc.idl.structsApache Curator
RpcPathChildrenCacheEventTypeenum RpcPathChildrenCacheEventTypeEnum Constant SummaryClassorg.apache.curator.x.rpc.idl.structsApache Curator
ServiceCacheReturn the current list of instances.Interfaceorg.apache.curator.x.discoveryApache Curator
ServiceCacheBuilderInterfaceorg.apache.curator.x.discoveryApache Curator
ServiceCacheImplAdd the given listener.Classorg.apache.curator.x.discovery.detailsApache Curator
ServiceCacheListenerListener for changes to a service cacheCalled when the cache has changed (instances added/deleted, etc.Interfaceorg.apache.curator.x.discovery.detailsApache Curator
TreeCacheA utility that attempts to keep all data from all children of a ZK path locally cached.Classorg.apache.curator.framework.recipes.cacheApache Curator
TreeCache .BuilderBuilds the TreeCache based on configured values.Classorg.apache.curator.framework.recipes.cacheApache Curator
TreeCacheEventClassorg.apache.curator.framework.recipes.cacheApache Curator
TreeCacheEvent .TypeCalled when the connection has changed to ConnectionState.Classorg.apache.curator.framework.recipes.cacheApache Curator
TreeCacheListenerInterfaceorg.apache.curator.framework.recipes.cacheApache Curator
TreeCacheSelector Controls which nodes a TreeCache processes.Interfaceorg.apache.curator.framework.recipes.cacheApache Curator
CachedBufferAllocatorAn IoBufferAllocator that caches the buffers which are likely to be reused during auto-expansion of the buffers.Classorg.apache.mina.core.bufferApache Mina
LazyInitializedCacheMapThis map is specially useful when reads are much more frequent than writes and if the cost of instantiating the values is high like allocating an Classorg.apache.mina.utilApache Mina
MapQueryCacheA default implementation of the QueryCache interface that stores data in a non-expiring LRUMap.Classorg.apache.cayenne.cacheApache Cayenne
MapQueryCacheFactoryClassorg.apache.cayenne.cacheApache Cayenne
NestedQueryCacheA QueryCache wrapper that introduces a key namespace on top of a delegate shared cache.Classorg.apache.cayenne.cacheApache Cayenne
OSQueryCacheA QueryCache implementation based on OpenSymphony OSCache.Classorg.apache.cayenne.cacheApache Cayenne
OSQueryCacheFactoryA factory for the OSCache factory.Classorg.apache.cayenne.cacheApache Cayenne
QueryCacheAn interface that defines generic QueryCache.Interfaceorg.apache.cayenne.cacheApache Cayenne
QueryCacheEntryFactoryA factory that is used by the cache to rebuild expired entries.Interfaceorg.apache.cayenne.cacheApache Cayenne
QueryCacheFactoryInterfaceorg.apache.cayenne.cacheApache Cayenne
QueryCacheStrategyenum QueryCacheStrategyextends EnumDefines query result caching policy.Classorg.apache.cayenne.queryApache Cayenne
DefaultReflectionCacheClassorg.jboss.weld.resourcesJBoss Weld
HotspotReflectionCacheClassorg.jboss.weld.resourcesJBoss Weld
LoadingCacheUtilsClassorg.jboss.weld.util.cacheJBoss Weld
ProtectionDomainCacheClassorg.jboss.weld.bean.proxyJBoss Weld
ReflectionCacheInterfaceorg.jboss.weld.resourcesJBoss Weld
ReflectionCacheFactoryClassorg.jboss.weld.resourcesJBoss Weld
RequestScopedCacheClassorg.jboss.weld.context.cacheJBoss Weld
SharedObjectCacheClassorg.jboss.weld.resourcesJBoss Weld
FilterCacheA cache for filters.Interfaceorg.apache.lucene.searchApache Lucene
FilterCachingPolicy .CacheOnLargeSegmentsA simple policy that only caches on the largest segments of an index.Classorg.apache.lucene.search.FilterCachingPolicyApache Lucene
LRUFilterCacheA FilterCache that evicts filters using a LRU (least-recently-used) eviction policy in order to remain under a given maximum size and number ofClassorg.apache.lucene.searchApache Lucene
LRUQueryCacheA QueryCache that evicts queries using a LRU (least-recently-used) eviction policy in order to remain under a given maximum size and number ofClassorg.apache.lucene.searchApache Lucene
QueryCacheA cache for queries.Interfaceorg.apache.lucene.searchApache Lucene
QueryCachingPolicy .CacheOnLargeSegmentsA simple policy that only caches on the largest segments of an index.Classorg.apache.lucene.search.QueryCachingPolicyApache Lucene
CachedOrdinalsReaderA per-segment cache of documents' facet ordinals.Classorg.apache.lucene.facet.taxonomyApache Lucene
CachedOrdinalsReader .CachedOrdsHolds the cached ordinals in two parallel int[] arrays.Classorg.apache.lucene.facet.taxonomy.CachedOrdinalsReaderApache Lucene
Cl2oTaxonomyWriterCacheTaxonomyWriterCache using CompactLabelToOrdinal.Classorg.apache.lucene.facet.taxonomy.writercacheApache Lucene
LruTaxonomyWriterCacheLRU TaxonomyWriterCache - good choice for huge taxonomies.Classorg.apache.lucene.facet.taxonomy.writercacheApache Lucene
LruTaxonomyWriterCache .LRUTypeDetermines cache type.Classorg.apache.lucene.facet.taxonomy.writercache.LruTaxonomyWriterCacheApache Lucene
NameHashIntCacheLRUAn an LRU cache of mapping from name to int.Classorg.apache.lucene.facet.taxonomy.writercacheApache Lucene
TaxonomyWriterCacheTaxonomyWriterCache is a relatively simple interface for a cache of category->ordinal mappings, used in TaxonomyWriter implementations (such asInterfaceorg.apache.lucene.facet.taxonomy.writercacheApache Lucene
FieldCacheSourceA base class for ValueSource implementations that retrieve values for a single field from DocValues.Classorg.apache.lucene.queries.function.valuesourceApache Lucene
CachedFilterBuilderFilters are cached in an LRU Cache keyed on the contained query or filter object.Classorg.apache.lucene.queryparser.xml.buildersApache Lucene
PointPrefixTreeFieldCacheProvider (AND ONLY POINTS!).Classorg.apache.lucene.spatial.prefixApache Lucene
ShapeFieldCacheBounded Cache of Shapes associated with docIds.Classorg.apache.lucene.spatial.utilApache Lucene
ShapeFieldCacheDistanceValueSourceAn implementation of the Lucene ValueSource that returns the spatial distance between an input point and a document's points inClassorg.apache.lucene.spatial.utilApache Lucene
ShapeFieldCacheProviderProvides access to a ShapeFieldCache for a given LeafReader.Classorg.apache.lucene.spatial.utilApache Lucene
CacheThe Cache interface is used to represent a cache that will store key value pairs.Interfaceorg.simpleframework.xml.utilSimple
ConcurrentCacheThe ConcurrentCache interface is used to represent a cache that will store key value pairs.Classorg.simpleframework.xml.utilSimple
LimitedCacheThe LimitedCache interface is used to represent a cache that will store key value pairs.Classorg.simpleframework.xml.utilSimple
WeakCacheThe WeakCache object is an implementation of a cache that holds on to cached items only if the key remains in memory.Classorg.simpleframework.xml.utilSimple
AbstractCacheAdapterAbstract implementation of the Cache interface which makes it easier to implement Adapters.Classorg.axonframework.cacheAxon
CacheAbstraction for a Caching mechanism.Interfaceorg.axonframework.cacheAxon
Cache .EntryListenerInterfaceorg.axonframework.cache.CacheAxon
Cache .EntryListenerAdapterAdapter implementation for the EntryListener, allowing for overriding only specific callback methods.Classorg.axonframework.cache.CacheAxon
EhCacheAdapterCache implementation that delegates all calls to an EhCache instance.Classorg.axonframework.cacheAxon
JCacheAdapterCache adapter implementation that allows providers implementing the JCache abstraction to be used.Classorg.axonframework.cacheAxon
NoCacheCache implementation that does absolutely nothing.Classorg.axonframework.cacheAxon
WeakReferenceCacheCache implementation that keeps values in the cache until the garbage collector has removed them.Classorg.axonframework.cacheAxon
CachedRenderA set of rendering that is cached onto the graphics card and hopefully is quicker to render.Classorg.newdawn.slickSlick
CachedRenderTestA simple test to show performance gains from cache operations in situtations where rendering is static and heavyClassorg.newdawn.slick.testsSlick
OAbstractMapCacheClasscom.orientechnologies.orient.core.cacheOrientdb
OAbstractRecordCacheCache of documents.Classcom.orientechnologies.orient.core.cacheOrientdb
OAllCacheEntriesAreUsedExceptionClasscom.orientechnologies.orient.core.exceptionOrientdb
OCacheGeneric cache interface that should be implemented in order to plug-in custom cache.Interfacecom.orientechnologies.orient.core.cacheOrientdb
OCacheEntryClasscom.orientechnologies.orient.core.index.hashindex.local.cacheOrientdb
OCacheLevelOneLocatorInterfacecom.orientechnologies.orient.core.cacheOrientdb
OCacheLevelOneLocatorImplClasscom.orientechnologies.orient.core.cacheOrientdb
OCacheLevelTwoLocatorInterfacecom.orientechnologies.orient.core.cacheOrientdb
OCachePointerClasscom.orientechnologies.orient.core.index.hashindex.local.cacheOrientdb
ODirectMemoryOnlyDiskCacheClasscom.orientechnologies.orient.core.storage.impl.memoryOrientdb
ODiskCacheThis class is heart of OrientDB storage model it presents disk backed data cache which works with direct memory.Interfacecom.orientechnologies.orient.core.index.hashindex.local.cacheOrientdb
OIntentNoCacheDisable cache.Classcom.orientechnologies.orient.core.intentOrientdb
OLocalRecordCacheLocal cache.Classcom.orientechnologies.orient.core.cacheOrientdb
OReadWriteDiskCacheClasscom.orientechnologies.orient.core.index.hashindex.local.cacheOrientdb
OUnboundedWeakCacheClasscom.orientechnologies.orient.core.cacheOrientdb
OWOWCacheClasscom.orientechnologies.orient.core.index.hashindex.local.cacheOrientdb
OWOWCache .LowDiskSpaceListenerInterfacecom.orientechnologies.orient.core.index.hashindex.local.cache.OWOWCacheOrientdb
CacheMapA fixed size hash map with LRU replacement.Classedu.stanford.nlp.utilJavaNlp
CacheParseHypothesesClassedu.stanford.nlp.parser.dvparserJavaNlp
Expressions .SimpleCachedExpressionA simple implementation of an expression that is represented by a java object of type T and which also has a cached Value stored with itClassedu.stanford.nlp.ling.tokensregex.types.ExpressionsJavaNlp
ConfigCacheUpdaterThread which runs forever.Classcom.konakart.alKonaKart
NoCacheInterceptorTo stop pages being cached by the browserSee Also:Serialized FormClasscom.konakart.actions.interceptorsKonaKart
CacheKeyHelperClasscom.konakart.blKonaKart
CacheMgrClasscom.konakart.blKonaKart
CacheMgrIf Interface which an implementation of this manager must adhere to.Interfacecom.konakart.blifKonaKart
EngineConfigCacheUpdaterThread which runs forever.Classcom.konakart.blKonaKart
CachedDataClasscom.codename1.io.servicesCodeName One
CachedDataServiceSimple service that allows downloading and caching data locally.Classcom.codename1.io.servicesCodeName One
CacheMapA cache map is essentially a hashtable that indexes entries based on age and is limited to a fixed size.Classcom.codename1.ioCodeName One
AbstractCachedAuthorityFactoryAn authority factory that consults (a possibly shared) cache before generating The behavior of the createFoo(String) methods first looks if aClassorg.geotools.referencing.factoryGeoTools
CachedAuthorityDecoratorAn authority factory that caches all objects created by delegate factories.Classorg.geotools.referencing.factoryGeoTools
CachedCRSAuthorityDecoratorAn authority factory that caches all objects created by the delegate CRSAuthorityFactory.Classorg.geotools.referencing.factoryGeoTools
CachedQuadTreeAn experimental QIX in memory index cache.Classorg.geotools.data.shapefile.indexGeoTools
FeatureTypeCacheHolds a cache of FeatureTypes by Name.Classorg.geotools.gml2GeoTools
FontCacheLookup and caches font definitions for faster retrievalAuthor:Andrea Aime - TOPPClassorg.geotools.renderer.styleGeoTools
ImageCacheA singleton cache for images.Classorg.geotools.swt.utilsGeoTools
LabelCacheUsed to cache labels prior to their being drawn on the screen.Interfaceorg.geotools.renderer.liteGeoTools
LabelCacheImplDefault LabelCache Implementation.Classorg.geotools.renderer.labelGeoTools
LabelCacheImpl .LabelRenderingModeDraws all diagonal lines in OUTLINE model, but horizontal ones in STRING mode.Classorg.geotools.renderer.label.LabelCacheImplGeoTools
LabelCacheItemThe Labelling information that is put in the label cache.Classorg.geotools.renderer.labelGeoTools
LabelCacheItem .GraphicResizeReturns the enum constant of this type with the specified name.Classorg.geotools.renderer.label.LabelCacheItemGeoTools
ObjectCacheA cache for arbitrary objects.Interfaceorg.geotools.utilGeoTools
ObjectCachesThis is facade around several constructs used by GeoTools for internal caching.Classorg.geotools.utilGeoTools
SchemaCacheCache containing XML schemas.Classorg.geotools.xml.resolverGeoTools
SynchronizedLabelCacheAllow multiple thread to modify LabelCache.Classorg.geotools.renderer.liteGeoTools
CacheGeneral purpose cache.Interfaceorg.jivesoftware.util.cacheOpenFire
CacheableInterface that defines the necessary behavior for objects added to a Cache.Interfaceorg.jivesoftware.util.cacheOpenFire
CachedPreparedStatementAllows PreparedStatement information to be cached.Classorg.jivesoftware.databaseOpenFire
CacheFactoryCreates Cache objects.Classorg.jivesoftware.util.cacheOpenFire
CacheFactoryStrategyInterfaceorg.jivesoftware.util.cacheOpenFire
CacheInfoConfiguration to use when creating caches.Classorg.jivesoftware.openfire.containerOpenFire
CacheInfo .TypeAn distributed-scheme defines caches where the storage for entries is partitioned across cluster nodes.Classorg.jivesoftware.openfire.container.CacheInfoOpenFire
CacheSizesUtility class for determining the sizes in bytes of commonly used objects.Classorg.jivesoftware.util.cacheOpenFire
CacheWrapperActs as a proxy for a Cache implementation.Classorg.jivesoftware.util.cacheOpenFire
ComponentCacheWrapperThis specialized wrapper is used for the Components cache, which should not be purged.Classorg.jivesoftware.util.cacheOpenFire
DefaultCacheDefault, non-distributed implementation of the Cache interface.Classorg.jivesoftware.util.cacheOpenFire
DefaultLocalCacheStrategyCacheFactoryStrategy for use in Openfire.Classorg.jivesoftware.util.cacheOpenFire
PluginCacheConfiguratorA helper class to read cache configuration data for a plugin and register the defined caches with the cache factory.Classorg.jivesoftware.openfire.containerOpenFire
PluginCacheRegistryA simple registry of cache configuration data for plugins.Classorg.jivesoftware.openfire.containerOpenFire
AbstractCacheWriterA convenience abstract base class that implements all CacheWriter methods.Classnet.sf.ehcache.writerEHCache
AbstractFromLargestCachePoolEvictorAbstract pool evictor which always evicts from the store consuming the most resources.Classnet.sf.ehcache.pool.implEHCache
AggregateCacheRegionStatsClassnet.sf.ehcache.hibernate.management.implEHCache
BlockingCacheA blocking decorator for an Ehcache, backed by a Ehcache.Classnet.sf.ehcache.constructs.blockingEHCache
BootstrapCacheLoaderInterfacenet.sf.ehcache.bootstrapEHCache
BootstrapCacheLoaderFactoryAn abstract factory for creating BootstrapCacheLoader instances.Classnet.sf.ehcache.bootstrapEHCache
CacheCache is the central class in ehcache.Classnet.sf.ehcacheEHCache
CacheA JMX MBean implementation for CacheSince:1.Classnet.sf.ehcache.managementEHCache
CacheClusterAllows you to explore the Terracotta cluster nodes and register for events about the cluster.Interfacenet.sf.ehcache.clusterEHCache
CacheConfigErrorClassnet.sf.ehcache.configEHCache
CacheConfigurationA value object used to represent cache configuration.Classnet.sf.ehcache.configEHCache
CacheConfigurationA JMX MBean implementation and decorator to net.Classnet.sf.ehcache.managementEHCache
CacheConfiguration .BootstrapCacheLoaderFactoryConfigurationConfiguration for the BootstrapCacheLoaderFactoryConfiguration.Classnet.sf.ehcache.config.CacheConfigurationEHCache
CacheConfiguration .CacheDecoratorFactoryConfigurationConfiguration for the CacheDecoratorFactoryConfiguration.Classnet.sf.ehcache.config.CacheConfigurationEHCache
CacheConfiguration .CacheEventListenerFactoryConfigurationConfiguration for the CacheEventListenerFactory.Classnet.sf.ehcache.config.CacheConfigurationEHCache
CacheConfiguration .CacheExceptionHandlerFactoryConfigurationConfiguration for the BootstrapCacheLoaderFactoryConfiguration.Classnet.sf.ehcache.config.CacheConfigurationEHCache
CacheConfiguration .CacheExtensionFactoryConfigurationConfiguration for the CacheExtensionFactoryConfiguration.Classnet.sf.ehcache.config.CacheConfigurationEHCache
CacheConfiguration .CacheLoaderFactoryConfigurationConfiguration for the CacheLoaderFactoryConfiguration.Classnet.sf.ehcache.config.CacheConfigurationEHCache
CacheConfiguration .TransactionalModeRepresents whether the Cache is transactional or not.Classnet.sf.ehcache.config.CacheConfigurationEHCache
CacheConfigurationElementElement representing the CacheConfigurationAuthor:Abhishek SanoujamClassnet.sf.ehcache.config.generator.model.elementsEHCache
CacheConfigurationListenerInstances of CacheConfigurationListener can be registered with CacheConfiguration instances in order to receive notification when any of the dynamic properties ofInterfacenet.sf.ehcache.configEHCache
CacheConfigurationMBeanA JMX MBean interface for the configuration of a cacheSince:1.Interfacenet.sf.ehcache.managementEHCache
CacheDecoratorFactoryAn abstract factory for creating decorated Ehcache instances.Classnet.sf.ehcache.constructsEHCache
CacheEntryHelper class to tie a key to an element.Classnet.sf.ehcacheEHCache
CacheEntryFactoryCreates objects to populate the cache.Interfacenet.sf.ehcache.constructs.blockingEHCache
CacheEventListenerAllows implementers to register callback methods that will be executed when a cache event The events include:Interfacenet.sf.ehcache.eventEHCache
CacheEventListenerAdapterAn adapter to simplify cache event listeners that do not need all events defined on the CacheEventListener interface.Classnet.sf.ehcache.eventEHCache
CacheEventListenerFactoryAn abstract factory for creating listeners.Classnet.sf.ehcache.eventEHCache
CacheExceptionA runtime Cache Exception.Classnet.sf.ehcacheEHCache
CacheExceptionHandlerA handler which may be registered with an Ehcache, to handle exceptions on Cache operations.Interfacenet.sf.ehcache.exceptionhandlerEHCache
CacheExceptionHandlerFactoryAn abstract factory for creating CacheExceptionHandlers at configuration time, in ehcache.Classnet.sf.ehcache.exceptionhandlerEHCache
CacheExtensionThis is a general purpose mechanism to allow generic extensions to a Cache.Interfacenet.sf.ehcache.extensionEHCache
CacheExtensionFactoryAn abstract factory for creating CacheExtensions.Classnet.sf.ehcache.extensionEHCache
CacheInitializationHelperHelper class to initialize an Ehcache with a CacheManager without adding the Ehcache to the CacheManager.Classnet.sf.ehcacheEHCache
CacheKeySetA Set of keys that will encapsulate keys present in a Cache.Classnet.sf.ehcache.storeEHCache
CacheLoader This interface has exactly the same interface as in the JCache module.Interfacenet.sf.ehcache.loaderEHCache
CacheLoaderFactoryAn abstract factory for creating cache loaders.Classnet.sf.ehcache.loaderEHCache
CacheLockProviderInterfacenet.sf.ehcache.concurrentEHCache
CacheManagerA container for Ehcaches that maintain all aspects of their lifecycle.Classnet.sf.ehcacheEHCache
CacheManagerAn MBean implementation for those attributes and operations we wish to expose on net.Classnet.sf.ehcache.managementEHCache
CacheManagerEventListenerAllows implementers to register callback methods that will be executed when a CacheManager event occurs.Interfacenet.sf.ehcache.eventEHCache
CacheManagerEventListenerFactoryAn abstract factory for creating CacheManagerEventListeners.Classnet.sf.ehcache.eventEHCache
CacheManagerEventListenerRegistryRegistered listeners for registering and unregistering CacheManagerEventListeners and sending notifications to registrants.Classnet.sf.ehcache.eventEHCache
CacheManagerExecutorServiceFactoryNonstopExecutorServiceFactory that creates and maintains one per CacheManagerAuthor:Abhishek SanoujamClassnet.sf.ehcache.constructs.nonstopEHCache
CacheManagerMBeanAn MBean interface for those attributes and operations we wish to expose on net.Interfacenet.sf.ehcache.managementEHCache
CacheManagerPeerListenerA listener for updates, which controls remote cache peers.Interfacenet.sf.ehcache.distributionEHCache
CacheManagerPeerListenerFactoryAn abstract factory for creating cache manager peer listeners.Classnet.sf.ehcache.distributionEHCache
CacheManagerPeerProviderProvides a discovery service to locate CachePeer listener peers for a Cache.Interfacenet.sf.ehcache.distributionEHCache
CacheManagerPeerProviderFactoryAn abstract factory for creating peers.Classnet.sf.ehcache.distributionEHCache
CacheManagerSamplerAn abstraction for sampled cache manager usage statistics.Interfacenet.sf.ehcache.management.sampledEHCache
CacheManagerSamplerImplAn implementation of CacheManagerSamplerAuthor:Abhishek Sanoujam, byouksteClassnet.sf.ehcache.management.sampledEHCache
CacheMBeanA management bean for a cacheSince:1.Interfacenet.sf.ehcache.managementEHCache
CacheOperationUnderExplicitLockCallableCallable used with nonstop when explicit lock has been acquiredAuthor:Abhishek SanoujamClassnet.sf.ehcache.constructs.nonstop.concurrencyEHCache
CachePeerAn interface for a cache peer to which updates are made remotely.Interfacenet.sf.ehcache.distributionEHCache
CacheRegionStatsClassnet.sf.ehcache.hibernate.management.implEHCache
CacheRegionUtilsClassnet.sf.ehcache.hibernate.management.implEHCache
CacheReplicatorReplicates cache entries to peers of the CacheManagerVersion:$Id: CacheReplicator.Interfacenet.sf.ehcache.distributionEHCache
CacheSamplerAn interface for exposing cache statistics.Interfacenet.sf.ehcache.management.sampledEHCache
CacheSamplerImplAn implementation of CacheSamplerAuthor:Abhishek Sanoujam, byouksteClassnet.sf.ehcache.management.sampledEHCache
CacheStatisticsA JMX CacheStatistics decorator for an ehcache Statistics class.Classnet.sf.ehcache.managementEHCache
CacheStatisticsMBeanInterfacenet.sf.ehcache.managementEHCache
CacheStatisticsSamplerAn interface for statistic samplers that expose the counters that track the actual sampled cache statistics.Interfacenet.sf.ehcache.statistics.sampledEHCache
CacheStoreHelperA helper class to get the internal Store from a CacheAuthor:Abhishek SanoujamClassnet.sf.ehcacheEHCache
CacheTransactionHelperA collection of utility methods helping controlling transactions for managed operations which may require them.Classnet.sf.ehcache.utilEHCache
CacheUsageListenerInterface for listeners to any change in usage statistics of an Implementations of this interface should implement the Object.Interfacenet.sf.ehcache.statisticsEHCache
CacheWriterA CacheWriter is an interface used for write-through and write-behind caching to a underlying resource.Interfacenet.sf.ehcache.writerEHCache
CacheWriterConfigurationClass to hold the CacheWriterManager configurationVersion:$Id: CacheWriterConfiguration.Classnet.sf.ehcache.configEHCache
CacheWriterConfiguration .CacheWriterFactoryConfigurationConfiguration for the CacheWriterFactoryConfiguration.Classnet.sf.ehcache.config.CacheWriterConfigurationEHCache
CacheWriterConfiguration .WriteModeClassnet.sf.ehcache.config.CacheWriterConfigurationEHCache
CacheWriterConfigurationElementElement representing the CacheWriterConfigurationAuthor:Abhishek SanoujamClassnet.sf.ehcache.config.generator.model.elementsEHCache
CacheWriterFactoryAn abstract factory for creating cache writers.Classnet.sf.ehcache.writerEHCache
CacheWriterManagerA CacheWriterManager coordinates how element are written to a back-end store.Interfacenet.sf.ehcache.writerEHCache
CacheWriterManagerExceptionAn exception specifically for throwing exceptions that happen with a CacheWriterManager implementation.Classnet.sf.ehcache.writerEHCache
ClassLoaderAwareCacheA cache decorator that adjusts the Thread context classloader (TCCL) for every cache operation.Classnet.sf.ehcache.constructs.classloaderEHCache
ComprehensiveCacheSamplerInterfacenet.sf.ehcache.management.sampledEHCache
ComprehensiveCacheSamplerImplThe default implementation of ComprehensiveCacheSampler.Classnet.sf.ehcache.management.sampledEHCache
DefaultCacheConfigurationElementNodeElement representing the CacheConfiguration of the "defaultCache"Author:Abhishek SanoujamClassnet.sf.ehcache.config.generator.model.elementsEHCache
DiskStoreBootstrapCacheLoaderClassnet.sf.ehcache.storeEHCache
DiskStoreBootstrapCacheLoaderFactoryFactory class to create DiskStoreBootstrapCacheLoader instances.Classnet.sf.ehcache.storeEHCache
EhcacheAn interface for Ehcache.Interfacenet.sf.ehcacheEHCache
EhCacheEHCache plugin for Hibernate.Classnet.sf.ehcache.hibernateEHCache
EhcacheAccessStrategyFactoryFactory to create EntityRegionAccessStrategyAuthor:Abhishek SanoujamInterfacenet.sf.ehcache.hibernate.strategyEHCache
EhcacheAccessStrategyFactoryImplClass implementing EhcacheAccessStrategyFactoryAuthor:Abhishek SanoujamClassnet.sf.ehcache.hibernate.strategyEHCache
EhcacheCollectionRegionA collection region specific wrapper around an Ehcache instance.Classnet.sf.ehcache.hibernate.regionsEHCache
EhcacheCoreInitEhcache core init service implConstructor SummaryEhcacheCoreInit()Classnet.sf.ehcacheEHCache
EhcacheDataRegionAn Ehcache specific data region implementation.Classnet.sf.ehcache.hibernate.regionsEHCache
EhcacheDecoratorAdapterAdapter class for Ehcache interface decorators.Classnet.sf.ehcache.constructsEHCache
EhcacheEntityRegionAn entity region specific wrapper around an Ehcache instance.Classnet.sf.ehcache.hibernate.regionsEHCache
EhcacheHibernateClassnet.sf.ehcache.hibernate.management.implEHCache
EhcacheHibernateMBeanMBean interface for hibernate statistics of session-factoriesAuthor:Abhishek SanoujamInterfacenet.sf.ehcache.hibernate.management.apiEHCache
EhcacheHibernateMbeanNamesUtility class used for getting ObjectName's for ehcache hibernate MBeansSince:1.Classnet.sf.ehcache.hibernate.management.implEHCache
EhcacheHibernateMBeanRegistrationInterface for helping registering mbeans for ehcache backed hibernate second-level cacheAuthor:Abhishek SanoujamInterfacenet.sf.ehcache.hibernate.management.implEHCache
EhcacheHibernateMBeanRegistrationImpl Also implements CacheManagerEventListener.Classnet.sf.ehcache.hibernate.management.implEHCache
EhcacheInitInterfacenet.sf.ehcacheEHCache
EhcacheJtaTransactionManagerLookupHibernate TransactionManagerLookup which also is a Ehcache transaction manager lookup.Classnet.sf.ehcache.hibernateEHCache
EhcacheNonstrictReadWriteCacheEhcache specific non-strict read/write cache concurrency strategy.Classnet.sf.ehcache.hibernate.ccsEHCache
EhCacheProviderCache Provider plugin for Hibernate 3.Classnet.sf.ehcache.hibernateEHCache
EhcacheQueryResultsRegionA query results region specific wrapper around an Ehcache instance.Classnet.sf.ehcache.hibernate.regionsEHCache
EhcacheReadOnlyCacheEhcache specific read-only cache concurrency strategy.Classnet.sf.ehcache.hibernate.ccsEHCache
EhcacheReadWriteCacheEhcache specific read/write cache concurrency strategy.Classnet.sf.ehcache.hibernate.ccsEHCache
EhCacheRegionFactoryA non-singleton EhCacheRegionFactory implementation.Classnet.sf.ehcache.hibernateEHCache
EhcacheStatsInterface for ehcache related statistics of hibernate second level cacheAuthor:Abhishek SanoujamInterfacenet.sf.ehcache.hibernate.management.apiEHCache
EhcacheStatsImplClassnet.sf.ehcache.hibernate.management.implEHCache
EhcacheTimestampsRegionA timestamps region specific wrapper around an Ehcache instance.Classnet.sf.ehcache.hibernate.regionsEHCache
EhcacheTransactionalDataRegionAn Ehcache specific TransactionalDataRegion.Classnet.sf.ehcache.hibernate.regionsEHCache
EhcacheXAExceptionSmall extension to the XAException defined in the JTA specification, to that the errorCode is provided when instantiating the Exception thrownClassnet.sf.ehcache.transaction.xaEHCache
EhcacheXAResourceEhcacheXAResource represents an Ehcache instance.Interfacenet.sf.ehcache.transaction.xaEHCache
EhcacheXAResourceImplThe EhcacheXAResource implementationAuthor:Ludovic OrbanClassnet.sf.ehcache.transaction.xaEHCache
ExceptionHandlingDynamicCacheProxyA dynamic proxy which provides CacheException handling.Classnet.sf.ehcache.exceptionhandlerEHCache
FromLargestCacheOnDiskPoolEvictorPool evictor which always evicts from the store consuming the most disk resources.Classnet.sf.ehcache.pool.implEHCache
FromLargestCacheOnHeapPoolEvictorPool evictor which always evicts from the store consuming the most heap resources.Classnet.sf.ehcache.pool.implEHCache
FrontEndCacheTierAbstract class for stores which combine two other stores, one caching the other (aka authority)'s elements.Classnet.sf.ehcache.storeEHCache
HibernateNonstopCacheExceptionHandlerClass that takes care of NonStopCacheException that happens in hibernate moduleAuthor:Abhishek SanoujamClassnet.sf.ehcache.hibernate.nonstopEHCache
InternalClassLoaderAwareCacheExtension of Class Loader Aware cache to accommodate the removeAndReturnElement method.Classnet.sf.ehcache.constructs.classloaderEHCache
InternalEhcacheThis is an extension of the Ehcache interface to allow addition of new methods to Cache without breaking the public contract.Interfacenet.sf.ehcache.terracottaEHCache
LiveCacheStatisticsInterface for usage statistics of a Cache.Interfacenet.sf.ehcache.statisticsEHCache
LiveCacheStatisticsDataInterface that classes storing usage statistics of a Cache will implementSince:1.Interfacenet.sf.ehcache.statisticsEHCache
LiveCacheStatisticsImplClassnet.sf.ehcache.statisticsEHCache
LiveCacheStatisticsWrapperAn implementation of LiveCacheStatistics and also implements LiveCacheStatisticsData.Classnet.sf.ehcache.statisticsEHCache
ManagedCacheManagerPeerProviderInterfacenet.sf.ehcache.managementEHCache
ManualRMICacheManagerPeerProviderA provider of Peer RMI addresses based off manual configuration.Classnet.sf.ehcache.distributionEHCache
MemoryLimitedCacheLoaderAbstract 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)Classnet.sf.ehcache.storeEHCache
MulticastRMICacheManagerPeerProviderA peer provider which discovers peers using Multicast.Classnet.sf.ehcache.distributionEHCache
MulticastRMICacheManagerPeerProvider .CachePeerEntryEntry containing a looked up CachePeer and dateConstructor SummaryMulticastRMICacheManagerPeerProvider.Classnet.sf.ehcache.distribution.MulticastRMICacheManagerPeerProviderEHCache
NonstopCacheEventListenerA CacheEventListener implementation that uses nonstop featureAuthor:Abhishek SanoujamClassnet.sf.ehcache.eventEHCache
NonStopCacheExceptionException type thrown for NonStopCache operationsAuthor:Abhishek SanoujamSee Also:Serialized FormClassnet.sf.ehcache.constructs.nonstopEHCache
NonStopCacheKeySetFields inherited from class java.Classnet.sf.ehcache.constructs.nonstop.concurrencyEHCache
NonstopCacheLockProviderClass implementing CacheLockProvider with nonstop featureAuthor:Abhishek SanoujamClassnet.sf.ehcache.constructs.nonstop.concurrencyEHCache
NonStrictReadWriteEhcacheCollectionRegionAccessStrategyClassnet.sf.ehcache.hibernate.strategyEHCache
NonStrictReadWriteEhcacheEntityRegionAccessStrategyClassnet.sf.ehcache.hibernate.strategyEHCache
NoopCacheClusterThis is a dummy implementation of the CacheCluster (Null Object Pattern).Classnet.sf.ehcache.clusterEHCache
NullLiveCacheStatisticsDataA no-op implementation which can be used both as a LiveCacheStatistics and LiveCacheStatisticsDataSince:1.Classnet.sf.ehcache.statisticsEHCache
NullSampledCacheStatisticsA no-op implementation of SampledCacheStatisticsSince:1.Classnet.sf.ehcache.statistics.sampledEHCache
ReadOnlyEhcacheCollectionRegionAccessStrategyClassnet.sf.ehcache.hibernate.strategyEHCache
ReadOnlyEhcacheEntityRegionAccessStrategyClassnet.sf.ehcache.hibernate.strategyEHCache
ReadWriteEhcacheCollectionRegionAccessStrategyClassnet.sf.ehcache.hibernate.strategyEHCache
ReadWriteEhcacheEntityRegionAccessStrategyClassnet.sf.ehcache.hibernate.strategyEHCache
RemoteCacheExceptionA Cache Exception in the distribution mechanism.Classnet.sf.ehcache.distributionEHCache
RMIAsynchronousCacheReplicatorListens to CacheManager and Cache events and propagates those to CachePeer peers of the Cache asynchronously.Classnet.sf.ehcache.distributionEHCache
RMIBootstrapCacheLoaderLoads Elements from a random Cache PeerVersion:$Id: RMIBootstrapCacheLoader.Classnet.sf.ehcache.distributionEHCache
RMIBootstrapCacheLoaderFactoryA factory to create a configured RMIBootstrapCacheLoaderVersion:$Id: RMIBootstrapCacheLoaderFactory.Classnet.sf.ehcache.distributionEHCache
RMICacheManagerPeerListenerA cache server which exposes available cache operations remotely through RMI.Classnet.sf.ehcache.distributionEHCache
RMICacheManagerPeerListenerFactoryBuilds a listener based on RMI.Classnet.sf.ehcache.distributionEHCache
RMICacheManagerPeerProviderA provider of Peer RMI addresses.Classnet.sf.ehcache.distributionEHCache
RMICacheManagerPeerProviderFactoryBuilds a factory based on RMIVersion:$Id: RMICacheManagerPeerProviderFactory.Classnet.sf.ehcache.distributionEHCache
RMICachePeerAn RMI based implementation of CachePeer.Classnet.sf.ehcache.distributionEHCache
RMICacheReplicatorFactoryCreates an RMICacheReplicator using properties.Classnet.sf.ehcache.distributionEHCache
RMISynchronousCacheReplicatorListens to CacheManager and Cache events and propagates those to CachePeer peers of the Cache.Classnet.sf.ehcache.distributionEHCache
SampledCacheAn implementation of SampledCacheMBeanAuthor:Abhishek Sanoujam, byouksteClassnet.sf.ehcache.management.sampledEHCache
SampledCacheManagerAn implementation of SampledCacheManagerMBeanAuthor:Abhishek Sanoujam, byouksteClassnet.sf.ehcache.management.sampledEHCache
SampledCacheManagerMBeanAn MBean for CacheManager exposing sampled cache usage statisticsAuthor:Abhishek SanoujamInterfacenet.sf.ehcache.management.sampledEHCache
SampledCacheMBeanAn MBean for Cache exposing cache statistics.Interfacenet.sf.ehcache.management.sampledEHCache
SampledCacheStatisticsInterface for sampled usage statistics of a CacheSince:1.Interfacenet.sf.ehcache.statistics.sampledEHCache
SampledCacheStatisticsImplAn implementation of SampledCacheStatistics This also implements CacheUsageListener and depends on these to update the statsClassnet.sf.ehcache.statistics.sampledEHCache
SampledCacheStatisticsWrapperAn implementation of SampledCacheStatistics and also implements CacheUsageListener and depends on the notification these to update the stats.Classnet.sf.ehcache.statistics.sampledEHCache
SampledEhcacheMBeansUtility class used for getting ObjectName's for sampled MBeansSince:1.Classnet.sf.ehcache.management.sampledEHCache
SelfPopulatingCacheA selfpopulating decorator for Ehcache that creates entries on demand.Classnet.sf.ehcache.constructs.blockingEHCache
SingletonEhCacheProviderSingleton cache Provider plugin for Hibernate 3.Classnet.sf.ehcache.hibernateEHCache
SingletonEhCacheRegionFactoryA singleton EhCacheRegionFactory implementation.Classnet.sf.ehcache.hibernateEHCache
TerracottaBootstrapCacheLoaderA BootstrapCacheLoader that will load Elements into a Terracotta clustered cache, based on a previously snapshotted key set.Classnet.sf.ehcache.terracottaEHCache
TerracottaBootstrapCacheLoaderFactoryFields inherited from class net.Classnet.sf.ehcache.terracottaEHCache
TerracottaCacheClusterCacheCluster implementation that delegates to an underlying cache cluster.Classnet.sf.ehcache.terracottaEHCache
TerracottaCacheEventReplicationCreates a wrapper for sending out cache events through the Terracotta clusterVersion:$Id: TerracottaCacheEventReplication.Classnet.sf.ehcache.eventEHCache
TerracottaCacheEventReplicationFactoryFactory for TerracottaCacheEventReplication instancesVersion:$Id: TerracottaCacheEventReplicationFactory.Classnet.sf.ehcache.eventEHCache
TransactionalEhcacheCollectionRegionAccessStrategyJTA CollectionRegionAccessStrategy.Classnet.sf.ehcache.hibernate.strategyEHCache
TransactionalEhcacheEntityRegionAccessStrategyJTA EntityRegionAccessStrategy.Classnet.sf.ehcache.hibernate.strategyEHCache
TransactionalRMICachePeerAn RMI based implementation of CachePeer supporting transactions.Classnet.sf.ehcache.distributionEHCache
UpdatingCacheEntryFactoryA CacheEntryFactory with one additional method, updateEntryValue((Serializable key, Serializable value) which allows the cache entry to updated rather than replaced.Interfacenet.sf.ehcache.constructs.blockingEHCache
UpdatingSelfPopulatingCacheA Cache backed cache that creates entries on demand.Classnet.sf.ehcache.constructs.blockingEHCache
AsciiMemcachedNodeImplMemcached node for the ASCII protocol.Classnet.spy.memcached.protocol.asciiSpyMemCached
BaseCacheMapBase class for a Map interface to memcached.Classnet.spy.memcachedSpyMemCached
BinaryMemcachedNodeImplFields inherited from class net.Classnet.spy.memcached.protocol.binarySpyMemCached
CachedDataCached data with its attributes.Classnet.spy.memcachedSpyMemCached
CacheLoaderCacheLoader provides efficient mechanisms for storing lots of data.Classnet.spy.memcached.utilSpyMemCached
CacheLoader .StorageListenerInterfacenet.spy.memcached.util.CacheLoaderSpyMemCached
CacheMapA Map interface to memcached.Classnet.spy.memcachedSpyMemCached
MemcachedClientClient to a memcached server.Classnet.spy.memcachedSpyMemCached
MemcachedClientIFThis interface is provided as a helper for testing clients of the MemcachedClient.Interfacenet.spy.memcachedSpyMemCached
MemcachedConnectionConnection to a cluster of memcached servers.Classnet.spy.memcachedSpyMemCached
MemcachedNodeInterface defining a connection to a memcached server.Interfacenet.spy.memcachedSpyMemCached
TCPMemcachedNodeImplClassnet.spy.memcached.protocolSpyMemCached
CachedDotTransitionIteratorTransitionIterator that caches dot products.Classcc.mallet.fst.semi_supervised.prMallet
CachedMetricStores a hash for each object being compared for efficient computation.Interfacecc.mallet.typesMallet
CacheStaleIndicatorIndicates when the value/gradient during training becomes stale.Interfacecc.mallet.fstMallet
CRFCacheStaleIndicatorIndicates when the value/gradient becomes stale based on updates to CRF'sAuthor:Gaurav ChandaliaClasscc.mallet.fstMallet
SumLatticeDefaultCachedDotClasscc.mallet.fst.semi_supervised.prMallet
BandElementCacheA cache for BandElement objects - this avoids having to construct/destruct objects in algorithms that do frequent allocations/deallocations of thisClasslevelsets.algorithmFiji
CacheThis is the part of the VolatileGlobalCellCache interface that is exposed to the renderer directly (that is, not via images).Interfacebdv.img.cacheFiji
CacheAccess is not synchronized, that is your duty.Classini.trakem2.persistenceFiji
Cache .DummyClassbdv.img.cache.CacheFiji
CacheArrayLoaderInterfacebdv.img.cacheFiji
CachedCellImgClassbdv.img.cacheFiji
CacheFSInfoCaching implementation of FSInfo.Classcom.sun.tools.javac.fileFiji
CacheHintsHints to the cache on how to handle cell requests.Classbdv.img.cacheFiji
CacheIoTimingUtilities for per ThreadGroup measuring and budgeting of time spentAuthor:Tobias Pietzsch Classbdv.img.cacheFiji
CacheIoTiming .IoStatisticsClassbdv.img.cache.CacheIoTimingFiji
CacheIoTiming .IoTimeBudgetBudget of time that can be spent in blocking IO.Classbdv.img.cache.CacheIoTimingFiji
SetCacheHintsInterfacebdv.viewer.renderFiji
ShapeListCacheClassmpicbg.imglib.cursor.shapelistFiji
ShapeListCachedClassmpicbg.imglib.container.shapelistFiji
ShapeListCachedLocalizableByDimCursorClassmpicbg.imglib.cursor.shapelistFiji
ShapeListCachedLocalizableByDimOutOfBoundsCursorClassmpicbg.imglib.cursor.shapelistFiji
ShapeListCachedLocalizablePlaneCursorClassmpicbg.imglib.cursor.shapelistFiji
ShapeListCacheFIFOClassmpicbg.imglib.cursor.shapelistFiji
VolatileGlobalCellCacheClassbdv.img.cacheFiji
VolatileImgCells .CellCacheInterfacebdv.img.cache.VolatileImgCellsFiji
CacheNodeFactoryClassorg.knime.base.node.util.cacheKNIME
CacheNodeModelClassorg.knime.base.node.util.cacheKNIME
FileStoresInLoopCacheClassorg.knime.core.data.filestore.internalKNIME
LRUCacheUnsynchronized last recently used cache.Classorg.knime.core.utilKNIME
CmsADECacheCache object instance for simultaneously cache online and offline items.Classorg.opencms.xml.containerpageOpenCMS
CmsADECacheSettingsThe cache settings for ADE.Classorg.opencms.xml.containerpageOpenCMS
CmsADEConfigCacheStateAn immutable object which represents the complete ADE configuration (sitemap and module configurations) at a certain instant in time.Classorg.opencms.ade.configurationOpenCMS
CmsADESessionCacheADE's session cache.Classorg.opencms.xml.containerpageOpenCMS
CmsCacheKeyGenerates the cache keys for the user and permission caches.Classorg.opencms.dbOpenCMS
CmsCacheSettingsThe settings of the OpenCms memory monitor.Classorg.opencms.dbOpenCMS
CmsContainerConfigurationCacheA cache class for storing inherited container configurations.Classorg.opencms.ade.containerpage.inheritedOpenCMS
CmsDetailNameCacheA cache which stores structure ids for URL names.Classorg.opencms.ade.configurationOpenCMS
CmsExtractionResultCache This cache operates on resource file names, plus a hash code calculated from CmsResource.Classorg.opencms.search.documentsOpenCMS
CmsFlexCacheThis class implements the FlexCache.Classorg.opencms.flexOpenCMS
CmsFlexCache .CmsFlexCacheVariationA simple data container class for the FlexCache variations.Classorg.opencms.flexOpenCMS
CmsFlexCacheConfigurationFlex Cache configuration class.Classorg.opencms.flexOpenCMS
CmsFlexCacheEntryContains the contents of a cached resource.Classorg.opencms.flexOpenCMS
CmsFlexCacheExceptionSignals an error of the Flex cache.Classorg.opencms.flexOpenCMS
CmsFlexCacheKeyKey used to describe the caching behaviour of a specific resource.Classorg.opencms.flexOpenCMS
CmsFormatterConfigurationCacheA cache object which holds a collection of formatter configuration beans read from the VFS.Classorg.opencms.ade.configuration.formattersOpenCMS
CmsFormatterConfigurationCacheStateRepresents the currently cached collection of all formatter beans extracted from formatter configuration files.Classorg.opencms.ade.configuration.formattersOpenCMS
CmsGlobalConfigurationCacheEventHandlerThis event handler manages cache instances which are instances of the interface I_CmsGlobalConfigurationCache.Classorg.opencms.ade.configurationOpenCMS
CmsImageCacheCleanupJobA schedulable OpenCms job that clear the image cache for the scaled images created by the CmsImageLoader.Classorg.opencms.scheduler.jobsOpenCMS
CmsJspTagNoCacheA tag to prevent caching by the browser.Classorg.opencms.jspOpenCMS
CmsLruCache The idea of this cache is to separate the caching policy from the data structure where the cached objects are stored.Classorg.opencms.cacheOpenCMS
CmsMemoryMonitor .CacheTypeAccess Control Lists cache.Classorg.opencms.monitorOpenCMS
CmsMemoryObjectCacheA singleton memory cache, that stores objects related with keys.Classorg.opencms.cacheOpenCMS
CmsPdfCacheCache class for storing generated PDFs in the RFS.Classorg.opencms.pdftoolsOpenCMS
CmsPdfThumbnailCacheCache for PDF thumbnails.Classorg.opencms.pdftoolsOpenCMS
CmsSitemapSessionCacheSitemap session cache.Classorg.opencms.ade.sitemapOpenCMS
CmsVfsCacheConfigurable VFS based cache, for caching objects related to offline/online resources.Classorg.opencms.cacheOpenCMS
CmsVfsDiskCache providing a cache for the "online" and another for the "offline" project.Classorg.opencms.cacheOpenCMS
CmsVfsMemoryObjectCache providing a cache for the "online" and another for the "offline" project.Classorg.opencms.cacheOpenCMS
CmsVfsNameBasedDiskCache This RFS cache operates on file names, plus a hash code calculated from CmsResource.Classorg.opencms.cacheOpenCMS
I_CmsCacheKeyDescribes the cache key generating methods.Interfaceorg.opencms.dbOpenCMS
I_CmsFlexCacheEnabledLoaderResource loaders that implement this interface are flex cache enabled.Interfaceorg.opencms.loaderOpenCMS
I_CmsGlobalConfigurationCacheThis is interface is intended to be used in combination with the CmsGlobalConfigurationCacheEventHandler class.Interfaceorg.opencms.ade.configurationOpenCMS
I_CmsLruCacheObjectDefines the methods which an object being cached by CmsFlexLruCache must implement.Interfaceorg.opencms.cacheOpenCMS
CmsCacheAdminToolHandlerCache administration tool handler that hides the tool if the current user has not the needed privileges.Classorg.opencms.workplace.tools.cacheOpenCMS
CmsFlexCacheClearDialogThe flex cache clear dialog.Classorg.opencms.workplace.tools.cacheOpenCMS
CmsFlexCacheListFlex Cache content view.Classorg.opencms.workplace.tools.cacheOpenCMS
CmsFlexCacheOverviewDialogThe flex cache overview dialog.Classorg.opencms.workplace.tools.cacheOpenCMS
CmsImageCacheClearDialogThe image cache clear dialog.Classorg.opencms.workplace.tools.cacheOpenCMS
CmsImageCacheHelperClassorg.opencms.workplace.tools.cacheOpenCMS
CmsImageCacheListImage Cache content view.Classorg.opencms.workplace.tools.cacheOpenCMS
CmsImageCacheOverviewDialogThe image cache overview dialog.Classorg.opencms.workplace.tools.cacheOpenCMS
CmsXmlUpdateFlexcacheUpdate default Flexcache capacities.Classorg.opencms.setup.xml.v8OpenCMS
InspectableFileCachedInputStreamA repositionable MeasurableInputStream based on cached data received by a WritableByteChannel whose first bytes can be inspected directly.Classit.unimi.dsi.fastutil.ioFastUtil
DrawingsCacheSee Also:Serialized FormConstructor SummaryDrawingsCache()Classcom.eclipsesource.tabris.internalTabris
CachedFileStoreFile store implementation.ClassquickfixQuickFix
CachedFileStoreFactoryCreates a message store that stores messages in a file.ClassquickfixQuickFix
IvyCacheTaskClassapi.org.apache.ivy.antIvy
IvyCacheFilesetClassapi.org.apache.ivy.antIvy
IvyCachePathClassapi.org.apache.ivy.antIvy
IvyCleanCacheClassapi.org.apache.ivy.antIvy
RepositoryCacheManagerInterfaceapi.org.apache.ivy.core.cacheIvy
ResolutionCacheManagerInterfaceapi.org.apache.ivy.core.cacheIvy
CacheDownloadOptionsClassapi.org.apache.ivy.core.cacheIvy
CacheMetadataOptionsClassapi.org.apache.ivy.core.cacheIvy
CacheUtilClassapi.org.apache.ivy.core.cacheIvy
DefaultRepositoryCacheManagerClassapi.org.apache.ivy.core.cacheIvy
DefaultRepositoryCacheManager$BackupResourceDownloaderClassapi.org.apache.ivy.core.cacheIvy
DefaultRepositoryCacheManager$MyModuleDescriptorProviderClassapi.org.apache.ivy.core.cacheIvy
DefaultResolutionCacheManagerClassapi.org.apache.ivy.core.cacheIvy
ModuleDescriptorMemoryCacheClassapi.org.apache.ivy.core.cacheIvy
ModuleDescriptorMemoryCache$CacheEntryClassapi.org.apache.ivy.core.cacheIvy
SshCacheClassapi.org.apache.ivy.plugins.repository.sshIvy
SshCache$CfUserInfoClassapi.org.apache.ivy.plugins.repository.sshIvy
SshCache$EntryClassapi.org.apache.ivy.plugins.repository.sshIvy
CacheResolverClassapi.org.apache.ivy.plugins.resolverIvy
PackagerCacheEntryClassapi.org.apache.ivy.plugins.resolver.packagerIvy
CacheA fixed size, most recently used object cache.Classwt.utilWindChill
CacheManagerA multi-level cache manager service.Classwt.cacheWindChill
CoInstanceCacheThe class implementing the cache of Info*Engine elements wrapped in CoInstances.Classcom.ptc.core.ca.co.client.cacheWindChill
IconCacheSee Also:Serialized FormMethods inherited from class java.Classwt.clients.utilWindChill
IconCacheIFInterfacewt.clients.utilWindChill
LiteIconCacheManagerAll requests for objects from classes that do not participate in the Cache Management pattern are presented to a CachManager object.Classcom.ptc.core.ca.generic.icon.commonWindChill
PagingSessionCacheTimeOutExceptionThis exception captures errors when attempting to fetch pages from a paging session that has timed out.Classwt.pomWindChill
SingletonLiteIconCacheFactoryInterfacecom.ptc.core.ca.generic.icon.commonWindChill
SingletonLiteIconCacheWrapperA wrapper for the wt.Classcom.ptc.core.ca.generic.icon.commonWindChill
WebInstanceCacheSee Also:Serialized FormMethods inherited from class com.Classcom.ptc.core.ca.web.client.cacheWindChill
InternalsNoCacheClassuk.ac.manchester.cs.owl.owlapiOwlApi
WeakCacheA weakly linked cache - elements in the cache can be garbage collectedSee Also:Serialized FormClassorg.semanticweb.owlapi.utilOwlApi
WeakIndexCacheA weakly linked cache - elements in the cache can be garbage collectedSee Also:Serialized FormClassorg.semanticweb.owlapi.utilOwlApi
DiskCacheAn interface for writing to and reading from a disk cache.Interfacecom.bumptech.glide.load.engine.cacheGlide
DiskCache .FactoryAn interface for lazily creating a disk cache.Interfacecom.bumptech.glide.load.engine.cacheGlide
DiskCache .WriterAn interface to actually write data to a key in the disk cache.Interfacecom.bumptech.glide.load.engine.cacheGlide
DiskCacheAdapterA simple class that returns null for all gets and ignores all writes.Classcom.bumptech.glide.load.engine.cacheGlide
DiskCacheStrategyenum DiskCacheStrategyextends EnumSet of available caching strategies for media.Classcom.bumptech.glide.load.engineGlide
DiskLruCacheA cache that uses a bounded amount of space on a filesystem.Classcom.bumptech.glide.disklrucacheGlide
DiskLruCacheFactoryCreates an DiskLruCache based disk cache in the specified disk cache If you need to make I/O access before returning the cache directory useClasscom.bumptech.glide.load.engine.cacheGlide
DiskLruCacheFactory .CacheDirectoryGetterInterfacecom.bumptech.glide.load.engine.cacheGlide
DiskLruCacheWrapperThe default DiskCache implementation.Classcom.bumptech.glide.load.engine.cacheGlide
ExternalCacheDiskCacheFactoryCreates an DiskLruCache based disk cache in the external disk cache Images can be read by everyone when using external disk cache.Classcom.bumptech.glide.load.engine.cacheGlide
InternalCacheDiskCacheFactoryClasscom.bumptech.glide.load.engine.cacheGlide
LruCacheA general purpose size limited cache that evicts items using an LRU algorithm.Classcom.bumptech.glide.utilGlide
LruResourceCacheAn LRU in memory cache for Resources.Classcom.bumptech.glide.load.engine.cacheGlide
MemoryCacheAn interface for adding and removing resources from an in memory cache.Interfacecom.bumptech.glide.load.engine.cacheGlide
MemoryCache .ResourceRemovedListenerAn interface that will be called whenever a bitmap is removed from the cache.Interfacecom.bumptech.glide.load.engine.cacheGlide
MemoryCacheAdapterA simple class that ignores all puts and returns null for all gets.Classcom.bumptech.glide.load.engine.cacheGlide
ModelCacheA simple cache that can be used by ModelLoader and ModelLoaderFactory to cache some data for a given model, width and height.Classcom.bumptech.glide.load.modelGlide
DiskCacheThis is a general purpose utility for determining a place to write files and cache them, eg for uncompressing files.Classucar.nc2.utilNetCDF
DiskCache2Manages a place on disk to persistently cache files, which are deleted when the last modified date exceeds a certain time.Classucar.nc2.utilNetCDF
DiskCache2 .CachePathPolicyClassucar.nc2.utilNetCDF
Variable .CacheClassucar.nc2NetCDF
CachesClassorg.mapdbMapDB
Caches .HardRefCache created objects using hard reference.Classorg.mapdbMapDB
Caches .HashTableFixed size cache which uses hash table.Classorg.mapdbMapDB
Caches .LRULeast Recently Used cache.Classorg.mapdbMapDB
Caches .WeakSoftRefClassorg.mapdbMapDB
Caches .WeakSoftRef .CacheItemInterfaceorg.mapdbMapDB
Caches .WeakSoftRef .CacheSoftItemClassorg.mapdbMapDB
Caches .WeakSoftRef .CacheWeakItemClassorg.mapdbMapDB
IndexPageCacheManager of the index pages for a IndexData.Classcom.healthmarketscience.jackcess.implJackCess
AnnotationCacheClasscom.basho.riak.client.api.convert.reflectionRiak
AbstractIndexCacheAbstract base class providing caching for IIndex like objects.Classcom.bigdata.serviceBlazeGraph
AbstractScaleOutClient .MetadataIndexCachePolicyPolicy options for caching PartitionLocators for an Warning: This feature is expected to evolve.Classcom.bigdata.serviceBlazeGraph
CacheConnectionFactoryA factory pattern for the ICacheConnection.Classcom.bigdata.rdf.sparql.ast.cacheBlazeGraph
CacheConnectionImplA connection to a local, remote, or distributed caching layer.Classcom.bigdata.rdf.sparql.ast.cacheBlazeGraph
CacheOnceMetadataIndex useful for read-historical index views since locators can not become stale for a historical view.Classcom.bigdata.serviceBlazeGraph
CacheValueFilterCache the BigdataValue on the IV (create a cross linkage).Classcom.bigdata.rdf.lexiconBlazeGraph
ConcurrentWeakValueCacheA low-contention/high concurrency weak value cache.Classcom.bigdata.cacheBlazeGraph
ConcurrentWeakValueCache .WeakRefAdds the key to the weak reference.Classcom.bigdata.cacheBlazeGraph
ConcurrentWeakValueCacheWithBatchedUpdatesA low-contention/high concurrency weak value cache.Classcom.bigdata.cacheBlazeGraph
ConcurrentWeakValueCacheWithBatchedUpdates .WeakRefAdds the key to the weak reference.Classcom.bigdata.cacheBlazeGraph
ConcurrentWeakValueCacheWithTimeout reference queue.Classcom.bigdata.cacheBlazeGraph
DescribeCacheAn interface providing a maintained DESCRIBE cache for some AbstractTripleStore.Classcom.bigdata.rdf.sparql.ast.cacheBlazeGraph
DescribeCacheServletA maintained cache for DESCRIBE of URIs.Classcom.bigdata.rdf.sail.webappBlazeGraph
DescribeCacheUpdaterCollects statements written onto the RDFWriter interface and adds/replaces the DESCRIBE of the Resource specified to theClasscom.bigdata.rdf.sparql.ast.cacheBlazeGraph
ICacheConnectionInterface for an abstraction used to support application specific local caches, remote caches, and cache fabrics.Interfacecom.bigdata.rdf.sparql.ast.cacheBlazeGraph
ICacheEntry Interface for hard reference cache entries exposes a dirty flag in addition to the object identifier and object reference.Interfacecom.bigdata.cacheBlazeGraph
ICacheListenerInterface receives notice of cache eviction events.Interfacecom.bigdata.cacheBlazeGraph
ICachePolicy Interface for cache policy.Interfacecom.bigdata.cacheBlazeGraph
IConcurrentWeakValueCacheInterfacecom.bigdata.cacheBlazeGraph
IDescribeCacheA maintained cache for the DESCRIBE of RDF resources.Interfacecom.bigdata.rdf.sparql.ast.cacheBlazeGraph
IndexCache from which any local IIndex view is reading.Classcom.bigdata.resourcesBlazeGraph
IndexCacheConcrete implementation for IClientIndex views.Classcom.bigdata.serviceBlazeGraph
ITermCacheReduced interface for the LexiconRelation's term cache.Interfacecom.bigdata.rdf.lexiconBlazeGraph
IVBindingSetEncoderWithIVCacheA concrete implementation using scalable BTrees to store the mapping from an IV to the cached RDF Value.Classcom.bigdata.rdf.internal.encoderBlazeGraph
IVCacheInterface for managing the BigdataValue cached on an IV.Interfacecom.bigdata.rdf.internalBlazeGraph
IWeakRefCacheEntryInterfacecom.bigdata.cacheBlazeGraph
IWeakRefCacheEntryFactoryInterface supports choice of either weak or soft references for cache entries and makes it possible for the application to extend the metadataInterfacecom.bigdata.cacheBlazeGraph
IWriteCacheInterface for a write cache with read back and the capability to update records while they are still in the cache.Interfacecom.bigdata.io.writecacheBlazeGraph
IWriteCacheCountersInterface declaring the counters exposed by the WriteCache.Interfacecom.bigdata.io.writecacheBlazeGraph
IWriteCacheManagerInterfacecom.bigdata.rwstoreBlazeGraph
IWriteCacheServiceCountersInterface declaring the counters exposed by the WriteCacheService .Interfacecom.bigdata.io.writecacheBlazeGraph
LRUCacheHard reference hash map with Least Recently Used ordering over entries.Classcom.bigdata.cacheBlazeGraph
LRUCache .ICacheOrderChangeListenerInterfacecom.bigdata.cacheBlazeGraph
MetadataIndexCacheConcrete implementation for IMetadataIndex views.Classcom.bigdata.serviceBlazeGraph
NoCacheMetadataIndexViewAn implementation that performs NO caching.Classcom.bigdata.serviceBlazeGraph
RWWriteCacheServiceDefines the WriteCacheService to be used by the RWStore.Classcom.bigdata.rwstoreBlazeGraph
SoftCacheEntryClasscom.bigdata.cacheBlazeGraph
SoftCacheEntryFactoryThe default factory for WeakReference cache entries.Classcom.bigdata.cacheBlazeGraph
TermCacheClasscom.bigdata.rdf.lexiconBlazeGraph
TestCacheConnectionFactoryStress test for correct shutdown of the ICacheConnection as allocated by the CacheConnectionFactory.Classcom.bigdata.rdf.sparql.ast.cacheBlazeGraph
TestIVBindingSetEncoderWithCacheTest suite for IVBindingSetEncoderWithIVCache.Classcom.bigdata.rdf.internal.encoderBlazeGraph
TestIVCacheTest suite for IVCache.Classcom.bigdata.rdf.lexiconBlazeGraph
TestRWWriteCacheServiceTest suite for the WriteCacheService using scattered writes on aVersion:$Id: TestWriteCacheService.Classcom.bigdata.io.writecacheBlazeGraph
TestWORMStrategyNoCacheTest suite for WORMStrategy journal with the write cache disabled.Classcom.bigdata.journalBlazeGraph
TestWORMStrategyNoCache .TestInterruptsTest suite integration for AbstractInterruptsTestCase.Classcom.bigdata.journalBlazeGraph
TestWORMStrategyNoCache .TestMRMWTest suite integration for AbstractMRMWTestCase.Classcom.bigdata.journalBlazeGraph
TestWORMStrategyNoCache .TestMROWTest suite integration for AbstractMROWTestCase.Classcom.bigdata.journalBlazeGraph
TestWORMStrategyNoCache .TestRawStoreTest suite integration for AbstractRestartSafeTestCase.Classcom.bigdata.journalBlazeGraph
TestWORMStrategyOneCacheBufferTest suite for WORMStrategy journals which runs with a single WriteCache buffer.Classcom.bigdata.journalBlazeGraph
TestWORMStrategyOneCacheBuffer .TestInterruptsTest suite integration for AbstractInterruptsTestCase.Classcom.bigdata.journalBlazeGraph
TestWORMStrategyOneCacheBuffer .TestMRMWTest suite integration for AbstractMRMWTestCase.Classcom.bigdata.journalBlazeGraph
TestWORMStrategyOneCacheBuffer .TestMROWTest suite integration for AbstractMROWTestCase.Classcom.bigdata.journalBlazeGraph
TestWORMStrategyOneCacheBuffer .TestRawStoreTest suite integration for AbstractRestartSafeTestCase.Classcom.bigdata.journalBlazeGraph
TestWORMWriteCacheServiceTest suite for the WriteCacheService using pure append writes.Classcom.bigdata.io.writecacheBlazeGraph
TestWriteCacheTest suite for the WriteCache.Classcom.bigdata.io.writecacheBlazeGraph
TestWriteCacheServiceLifetimeThese tests exercise the lifetime semantics of a WriteCacheService.Classcom.bigdata.io.writecacheBlazeGraph
WeakCacheEntryClasscom.bigdata.cacheBlazeGraph
WeakCacheEntryFactoryThe default factory for WeakReference cache entries.Classcom.bigdata.cacheBlazeGraph
WeakValueCache A memory sensitive cache using weak references for its values and object ids for its keys and backed by the CRUD operations of the persistence layer,Classcom.bigdata.cacheBlazeGraph
WeakValueCache .IClearReferenceListenerAn optional listener that is invoked when we notice a cleared reference.Interfacecom.bigdata.cacheBlazeGraph
WriteCacheThis class provides a write cache with read-through for NIO writes on a FileChannel (and potentially on a remote service).Classcom.bigdata.io.writecacheBlazeGraph
WriteCache .FileChannelScatteredWriteCacheThe scattered write cache is used by the RWStore since the writes can be made to any part of the file assigned for data allocation.Classcom.bigdata.io.writecacheBlazeGraph
WriteCache .FileChannelWriteCacheA WriteCache implementation suitable for an append-only file such as the WORMStrategy or the output file of theClasscom.bigdata.io.writecacheBlazeGraph
WriteCache .HAPackageUsed to retrieve the HAWriteMessage AND the associated This allows the WriteCache to compress the data and create theClasscom.bigdata.io.writecacheBlazeGraph
WriteCache .ReadCacheClasscom.bigdata.io.writecacheBlazeGraph
WriteCache .RecordMetadataThe metadata associated with a record in the WriteCache.Classcom.bigdata.io.writecacheBlazeGraph
WriteCacheCountersPerformance counters for the WriteCache.Classcom.bigdata.io.writecacheBlazeGraph
WriteCacheServiceA WriteCacheService is provisioned with some number of WriteCache buffers and a writer thread.Classcom.bigdata.io.writecacheBlazeGraph
WriteCacheService .AsynchronousCloseExceptionAn instance of this exception is thrown if a thread notices that the WriteCacheService was closed by a concurrent process.Classcom.bigdata.io.writecacheBlazeGraph
WriteCacheServiceCountersPerformance counters for the WriteCacheService.Classcom.bigdata.io.writecacheBlazeGraph
HystrixRequestCacheCache that is scoped to the current request as managed by HystrixRequestVariableDefault.Classcom.netflix.hystrixHystrix
CachedInstanceFactoryDecoratorA decorator that returns the first non-null instance returned by the delegate factory.Classorg.carrot2.util.factoryCarrot
ResourceCacheA static cache of immutable, reusable resources associated with a given ResourceLookup.Classorg.carrot2.util.resourceCarrot
AbstractCachedResultSimple abstract container for serialized resources or results of a query.Classorg.exist.xmlrpcExistDB
BTreeCacheThis cache implementation always tries to keep the inner btree pages in cache, while the leaf pages can be removed.Classorg.exist.storage.cacheExistDB
BTreeCacheableFields inherited from interface org.Interfaceorg.exist.storage.cacheExistDB
CacheClassorg.exist.managementExistDB
CacheBase interface for all cache implementations that are used for buffering btree and data pages.Interfaceorg.exist.storage.cacheExistDB
Cacheable Each object should provide a unique key, an internal reference counter, and a timestamp marker (used to measure how long the object has stayedInterfaceorg.exist.storage.cacheExistDB
CachedResultThis class is used to hold an intermediate result that can be cached.Classorg.exist.xqueryExistDB
CacheManagerCreated by IntelliJ IDEA.Classorg.exist.managementExistDB
CacheManagerInterfaceorg.exist.storageExistDB
CacheManagerMBeanCreated by IntelliJ IDEA.Interfaceorg.exist.managementExistDB
CacheMBeanInterfaceorg.exist.managementExistDB
CollectionCacheGlobal cache for Collection objects.Classorg.exist.collectionsExistDB
CollectionCacheManagerClassorg.exist.storageExistDB
DefaultCacheManagerCacheManager maintains a global memory pool available to all page caches.Classorg.exist.storageExistDB
FileFilterInputStreamCacheCache implementation for CachingFilterInputStream Backed by a Random Access FileClassorg.exist.util.ioExistDB
FilterInputStreamCacheInterface for Cache Implementations for use by the CachingFilterInputStreamVersion:1.Interfaceorg.exist.util.ioExistDB
FilterInputStreamCacheFactoryClassorg.exist.util.ioExistDB
FilterInputStreamCacheFactory .FilterInputStreamCacheConfigurationInterfaceorg.exist.util.ioExistDB
GClockCacheCache implementation based on the GClock algorithm.Classorg.exist.storage.cacheExistDB
LRDCacheA cache implementation based on a Least Reference Density (LRD) replacement policy.Classorg.exist.storage.cacheExistDB
LRUCacheA simple cache implementing a Last Recently Used policy.Classorg.exist.storage.cacheExistDB
MemoryFilterInputStreamCacheCache implementation for CachingFilterInputStream Backed by an in-memory byte arrayClassorg.exist.util.ioExistDB
MemoryMappedFileFilterInputStreamCacheCache implementation for CachingFilterInputStream Backed by a Memory Mapped FileClassorg.exist.util.ioExistDB
QueryResultCacheUsed by XmldbRequestProcessorFactory to cache query results.Classorg.exist.xmlrpcExistDB
STXTemplatesCacheCache for STX TemplatesConstructor SummarySTXTemplatesCache()Classorg.exist.collections.triggersExistDB
CacheStrategySpecify the default cache use specific entity type.Classcom.avaje.ebean.annotationEBean
CacheTuningSpecify cache tuning for a specific entity type.Classcom.avaje.ebean.annotationEBean
ServerCacheRepresents part of the "L2" server side cache.Interfacecom.avaje.ebean.cacheEBean
ServerCacheFactoryDefines method for constructing caches for beans and queries.Interfacecom.avaje.ebean.cacheEBean
ServerCacheManagerThe cache service for server side caching of beans and query results.Interfacecom.avaje.ebean.cacheEBean
ServerCacheOptionsOptions for controlling a cache.Classcom.avaje.ebean.cacheEBean
ServerCacheStatisticsThe statistics collected per cache.Classcom.avaje.ebean.cacheEBean
MethodCacheThis class cache's method lookups.Classorg.supercsv.utilSuperCSV
FileAppendStreamLRUCacheLRU cache of OutputStreams to handle situation in which it is necessary to have more FileOutputStreams than resource limits will allow.Classhtsjdk.samtools.utilHtsJDK
ReferenceCacheThat is a thread-safe wrapper for a list of cache Reference objects.Classhtsjdk.samtools.sraHtsJDK
AbstractSynchronizedCacheStrategyDecoratorEnsure that the loadValue(Object) will be called only once for the same key.Classro.isdc.wro.cache.supportWro4J
CacheKeyUsed as an entry for the cache.Classro.isdc.wro.cacheWro4J
CacheKeyFactoryFactory responsible for creating CacheKeySince:1.Interfacero.isdc.wro.cache.factoryWro4J
CacheKeyFactoryDecoratorDecorator for CacheKeyFactory object.Classro.isdc.wro.cache.factoryWro4J
CacheStrategy This interface will be implemented by all classes which will support aAuthor:Alex ObjeleanInterfacero.isdc.wro.cacheWro4J
CacheStrategyDecoratorA decorator of CacheStrategy.Classro.isdc.wro.cache.supportWro4J
CacheStrategyProviderA service provider responsible for providing new implementations of HashStrategy.Interfacero.isdc.wro.cache.spiWro4J
CacheValueEntry holding a resource content along with its associated hash.Classro.isdc.wro.cacheWro4J
ConfigurableCacheStrategyUses the CacheStrategy implementation associated with an alias read from properties file.Classro.isdc.wro.cacheWro4J
DefaultCacheKeyFactoryDefault implementation of CacheKeyFactory which builds the CacheKey by setting all required types after inspecting the request.Classro.isdc.wro.cache.factoryWro4J
DefaultCacheStrategyProviderDefault implementation of NamingStrategyProvider providing all NamingStrategy implementations fromSince:1.Classro.isdc.wro.cache.spiWro4J
DefaultSynchronizedCacheStrategyDecoratorResponsible for invoking GroupsProcessor when cache key is missed.Classro.isdc.wro.cache.supportWro4J
LruMemoryCacheStrategyThis class implements a LRU (Least Recently Used) cache strategy.Classro.isdc.wro.cache.implWro4J
MemoryCacheStrategyDefault CacheStrategy implementation using a Map to store values Memory caches are thread-safe in all operations.Classro.isdc.wro.cache.implWro4J
ReloadCacheRequestHandlerThis RequestHandler will reload the cache on HTTP requests to "wroAPI/reloadCache".Classro.isdc.wro.http.handlerWro4J
ReloadCacheRunnableA Runnable executed by scheduler to clear the cache.Classro.isdc.wro.manager.runnableWro4J
AbstractCachedStorageThe AbstractCachedStorage implements the caching mechanism of ICachedStorage.Classcom.sibvisions.rad.persistJVX
ICachedStorageThe ICachedStorage extends the IStorage with meta data caching features.Interfacejavax.rad.persistJVX
MetaDataCacheOptionenum MetaDataCacheOptionextends EnumThe MetaDataCacheOption is the enum type for client and server-side metadata cache options.Classjavax.rad.modelJVX
ObjectCacheThe ObjectCache is a utility class to cache/store objects for a period of time.Classcom.sibvisions.utilJVX
ObjectCacheInstanceThe ObjectCacheInstance is a utility class to cache/store objects for a period of time.Classcom.sibvisions.utilJVX
RemoteDataSource .MetaDataCacheRoleThe meta data cache roles.Classcom.sibvisions.rad.model.remoteJVX
TypeCacheThe TypeCache is the cache for BeanTypes which will be read or written from the UniversalSerializer in a single read or write operation.Classcom.sibvisions.rad.remote.serializerJVX
CacheInterface used to interact with the second-level cache.Interfacejavax.persistenceEclipseLink
CacheThe Cache annotation is used to configure the EclipseLink object cache.Classorg.eclipse.persistence.annotationsEclipseLink
CacheJPA scripting API implementation.Interfaceorg.eclipse.persistence.jpa.configEclipseLink
CacheableSpecifies whether an entity should be cached if caching is enabled when the value of the persistence.Classjavax.persistenceEclipseLink
CacheCoordinationProtocolCache coordination protocol persistence property values.Classorg.eclipse.persistence.configEclipseLink
CacheCoordinationTypeenum CacheCoordinationTypeAn enum that is used within the Cache annotation.Classorg.eclipse.persistence.annotationsEclipseLink
CacheIndexAllow a cache index to be define.Classorg.eclipse.persistence.annotationsEclipseLink
CacheIndex Define a secondary index on the cache.Classorg.eclipse.persistence.descriptorsEclipseLink
CacheIndexJPA scripting API implementation.Interfaceorg.eclipse.persistence.jpa.configEclipseLink
CacheIndexesAllow a set of cache indexes to be define on an Entity.Classorg.eclipse.persistence.annotationsEclipseLink
CacheInterceptorA CacheInterceptor can be set on an Entity and allows all EclipseLink cache access to be intercepted by the developer provided interceptor.Classorg.eclipse.persistence.annotationsEclipseLink
CacheInterceptorJPA scripting API implementation.Interfaceorg.eclipse.persistence.jpa.configEclipseLink
CacheInterceptor Purpose: Define a class through which Cache access can be Description: EclipseLink makes extensive use of cachingClassorg.eclipse.persistence.sessions.interceptorsEclipseLink
CacheInvalidationPolicy A CacheInvalidationPolicy is used to set objects in TopLink's identity maps to be invalid following given rules.Classorg.eclipse.persistence.descriptors.invalidationEclipseLink
CacheIsolationTypeenum CacheIsolationTypeOptions for how Entity instances should be shared within an EclipseLink Persistence Unit / ServerSessionClassorg.eclipse.persistence.configEclipseLink
CacheKeyInterceptorThe CacheKeyInterceptor allows a Cache Interceptor implementation to wrap the EclipseLink CacheKey.Classorg.eclipse.persistence.sessions.interceptorsEclipseLink
CacheKeyTypeConfigures what type of Id value is used to store the object in the cache.Classorg.eclipse.persistence.annotationsEclipseLink
CachePolicy CachePolicy defines the cache configuration.Classorg.eclipse.persistence.descriptorsEclipseLink
CacheRetrieveModeenum CacheRetrieveModeUsed as the value of theClassjavax.persistenceEclipseLink
CacheStoreModeUsed as the value of the javax.Classjavax.persistenceEclipseLink
CacheTypeThe CacheType enum is used with the Cache annotation for a persistent class.Classorg.eclipse.persistence.annotationsEclipseLink
CacheTypeCache type persistence property values.Classorg.eclipse.persistence.configEclipseLink
CacheUsageCache usage hint values.Classorg.eclipse.persistence.configEclipseLink
CacheUsageIndirectionPolicyIn-memory querying and conforming indirection policy.Classorg.eclipse.persistence.configEclipseLink
DailyCacheInvalidationPolicy A CacheInvalidationPolicy that allows objects to expire every day at a specific time.Classorg.eclipse.persistence.descriptors.invalidationEclipseLink
FileBasedProjectCacheClassorg.eclipse.persistence.jpa.metadataEclipseLink
FlushClearCacheFlushClearCache persistence property defines modes of cache handling after em.Classorg.eclipse.persistence.configEclipseLink
JpaCacheInterfaceorg.eclipse.persistence.jpaEclipseLink
NoExpiryCacheInvalidationPolicy A cache invalidation policy in which no objects will expire.Classorg.eclipse.persistence.descriptors.invalidationEclipseLink
NoncacheableThe NonCacheable annotation is used to configure caching behavior for relationships.Classorg.eclipse.persistence.annotationsEclipseLink
ProjectCachePurpose: Interface used to support caching the project generated from metadata avoiding costs associated processing the same metadata over multiple deployments.Interfaceorg.eclipse.persistence.jpa.metadataEclipseLink
QueryResultsCachePolicy A QueryResultsCache policy dictates how a query's results will be cached.Classorg.eclipse.persistence.queriesEclipseLink
SharedCacheModeenum SharedCacheModeSpecifies how the provider must use a second-level cache for theClassjavax.persistenceEclipseLink
TimeToLiveCacheInvalidationPolicy A CacheInvalidationPolicy which allows objects to live for a specific amount of time after they are read.Classorg.eclipse.persistence.descriptors.invalidationEclipseLink
IWDCachedResourceInterfacecom.sap.tc.webdynpro.services.sal.datatransport.apiSAP NetWeaver
IWDCachedWebResourceCreated on 15.Interfacecom.sap.tc.webdynpro.services.sal.url.apiSAP NetWeaver
WDCacheElementExpiredExceptionClasscom.sap.tc.webdynpro.services.sal.util.cacheSAP NetWeaver
CacheLayerCopyright: Copyright (c) 2002 by SAP AGFields inherited from interface com.Classcom.sapportals.portal.appintegrator.layerSAP NetWeaver
ICacheDiscriminatorAn ICachableDiscriminator is implemented by components that want to add caching capabilites depending on content values to their behavior.Interfacecom.sapportals.portal.prt.componentSAP NetWeaver
ICacheNavigationNodeMethods inherited from interface com.Interfacecom.sapportals.portal.navigation.cacheSAP NetWeaver
ICacheNavigationServiceInterfacecom.sapportals.portal.navigation.cacheSAP NetWeaver
ICacheValidatorAn ICachableValidator is implemented by components that wants to control the validity of the cache using a key which is stored in the cache contentInterfacecom.sapportals.portal.prt.componentSAP NetWeaver
ICachedSourceThe interface that determines whether the source of the XML transformation is The transformation service disables the cache if there is an error loading, Interfacecom.sap.portal.httpconnectivity.transformationservice.xmlsourceSAP NetWeaver
CacheEntryListRepresents a list of cache entries.Classcom.sapportals.wcm.util.cacheSAP NetWeaver
CacheEntryListIteratorAn iterator to access elements in a cache entry list.Classcom.sapportals.wcm.util.cacheSAP NetWeaver
CacheExceptionBase class for exceptions in this cache package.Classcom.sapportals.wcm.util.cacheSAP NetWeaver
CacheFactoryClasscom.sapportals.wcm.util.cacheSAP NetWeaver
CacheServiceFactoryService factory for the service of this package.Classcom.sapportals.wcm.service.cacheSAP NetWeaver
CustomizingControllerCacheThis class is only used internally.Classcom.sapportals.wcm.repository.service.layout.customizingSAP NetWeaver
ICacheGeneric cache interface.Interfacecom.sapportals.wcm.util.cacheSAP NetWeaver
ICacheEntryRepresents a cache entry.Interfacecom.sapportals.wcm.util.cacheSAP NetWeaver
ICacheNodeKeeps information about dependencies between cache entries.Interfacecom.sapportals.wcm.util.cacheSAP NetWeaver
ICacheServiceProvides a service to create caches.Interfacecom.sapportals.wcm.service.cacheSAP NetWeaver
ICacheStatisticsProvides basic statistical information about a cache instance.Interfacecom.sapportals.wcm.util.cacheSAP NetWeaver
IClusterCacheAreaRepresents a cacheable area.Interfacecom.sapportals.wcm.util.cacheSAP NetWeaver
IExtendedCacheStatisticsProvides some additional statistical information about a cache instance.Interfacecom.sapportals.wcm.util.cacheSAP NetWeaver
CacheSettingsCache settings contains cache validity and refresh periods for an ItemType.Classcom.sap.netweaver.bc.uwl.configSAP NetWeaver
AbstractCacheFactoryAbstract CacheFactory implementation containing common functionality such as cache configuration properties support.Classorg.alfresco.repo.cacheAlFresco
AbstractMTAsynchronouslyRefreshedCacheThe base implementation for Multi-tenant asynchronously refreshed cache.Classorg.alfresco.repo.cacheAlFresco
AbstractPropertyValueDAOImpl .CachePucKeyKey for PropertyUniqueContext cacheSee Also:Serialized FormClassorg.alfresco.repo.domain.propvalAlFresco
AbstractRefreshableCacheEventA generic event with the cache id and affected tenantAuthor:AndySee Also:Serialized FormClassorg.alfresco.repo.cacheAlFresco
AsynchronouslyRefreshedCacheInterfaceorg.alfresco.repo.cacheAlFresco
AsynchronouslyRefreshedCacheRegistryA registry of all AsynchronouslyRefreshedCaches to be used for notification.Interfaceorg.alfresco.repo.cacheAlFresco
AuthorityBridgeTableAsynchronouslyRefreshedCacheClassorg.alfresco.repo.security.authorityAlFresco
BackingStoreAwareCacheWriterWrapper for cache writer that is aware of backing store writer and calls backing store for getSize and getContentDataClassorg.alfresco.repo.content.cachingAlFresco
CachedContentCleanerCleans up redundant cache files from the cached content file store.Classorg.alfresco.repo.content.caching.cleanupAlFresco
CachedContentCleanerCreatedEventEvent fired when CachedContentCleaner instances are created.Classorg.alfresco.repo.content.caching.cleanupAlFresco
CachedContentCleanupJobQuartz job to remove cached content files from disk once they are no longer held in the in-memory cache.Classorg.alfresco.repo.content.caching.cleanupAlFresco
CachedPolicyFactoryPolicy Factory with caching support.Classorg.alfresco.repo.policyAlFresco
CacheFactoryCache factory interface.Interfaceorg.alfresco.repo.cacheAlFresco
CacheFilePropsManage a cache file's associated properties.Classorg.alfresco.repo.content.cachingAlFresco
CacheLookupSearchContextCache Lookup Search Context Class Use the file state cache to check for current timestamp values for file information being returned inClassorg.alfresco.filesys.repoAlFresco
CacheMissExceptionCacheMissException will be thrown if an attempt is made to read content from the ContentCache when it is not in the cache.Classorg.alfresco.repo.content.cachingAlFresco
CacheRegionKeyKey-wrapper used to separate cache regions, allowing a single cache to be used for different This class is distinct from the ID key so that ID-based lookups don't class with value-based lookups.Classorg.alfresco.repo.cache.lookupAlFresco
CacheRegionValueKeyValue-key-wrapper used to separate cache regions, allowing a single cache to be used for different This class is distinct from the region key so that ID-based lookups don't class with value-based lookups.Classorg.alfresco.repo.cache.lookupAlFresco
CacheStatisticsCentralised cache statistics service.Interfaceorg.alfresco.repo.cacheAlFresco
CacheStatisticsCreatedSignal that cache statistics have been registered for the given cache.Classorg.alfresco.repo.cacheAlFresco
CompiledModelsCacheAsynchronously refreshed cache for dictionary models.Classorg.alfresco.repo.dictionaryAlFresco
ConfigDataCacheAn innder class that uses the config service to asynchronously refresh tenant config data.Classorg.alfresco.repo.configAlFresco
ConfigDataCache .ConfigDataClassorg.alfresco.repo.configAlFresco
ConfigDataCache .ImmutableConfigDataImmutable version of ConfigDataCache.Classorg.alfresco.repo.configAlFresco
ContentCacheA cache designed to operate on content and split between memory and disk.Interfaceorg.alfresco.repo.content.cachingAlFresco
ContentCacheImplThe one and only implementation of the ContentCache class.Classorg.alfresco.repo.content.cachingAlFresco
ContentCacheImpl .CacheWriterThis FileContentWriter subclass allows for the temp cache file to be renamed to a cache file proper, e.Classorg.alfresco.repo.content.cachingAlFresco
ContentCacheImpl .NumericFileNameComparatorClassorg.alfresco.repo.content.cachingAlFresco
DefaultCacheFactoryCacheFactory implementation that creates DefaultSimpleCache instances.Classorg.alfresco.repo.cacheAlFresco
DefaultCacheProviderClassorg.alfresco.repo.cacheAlFresco
DefaultImporterContentCacheClassorg.alfresco.repo.importerAlFresco
DefaultSimpleCacheSimpleCache implementation backed by a Google Cache implementation.Classorg.alfresco.repo.cacheAlFresco
EntityLookupCacheA cache for two-way lookups of database entities.Classorg.alfresco.repo.cache.lookupAlFresco
EntityLookupCache .EntityLookupCallbackDAOInterfaceorg.alfresco.repo.cache.lookupAlFresco
EntityLookupCache .EntityLookupCallbackDAOAdaptorAdaptor for implementations that support immutable entities.Classorg.alfresco.repo.cache.lookupAlFresco
HibernateSimpleCacheAdapterAdapts a SimpleCache instance for use as a Hibernate Cache.Classorg.alfresco.repo.cacheAlFresco
ImporterContentCacheInterfaceorg.alfresco.service.cmr.viewAlFresco
InMemoryCacheStatisticsSimple non-persistent implementation of CacheStatistics.Classorg.alfresco.repo.cacheAlFresco
LockingCacheInterface for caches that support value lockingSince:4.Interfaceorg.alfresco.repo.cacheAlFresco
MemoryCacheA cache backed by a simple ConcurrentHashMap.Classorg.alfresco.repo.cacheAlFresco
MTNodesCache2In-memory cache that stores nodeRefs per tenant.Classorg.alfresco.repo.webdavAlFresco
NoStatsForCacheRead operations on CacheStatistics throw this RuntimeException when no statistics exist for theClassorg.alfresco.repo.cacheAlFresco
NullCacheA cache that does nothing - always.Classorg.alfresco.repo.cacheAlFresco
QNameCacheClassorg.alfresco.service.namespaceAlFresco
RefreshableCacheInterfaceorg.alfresco.repo.cacheAlFresco
RefreshableCacheEventInterfaceorg.alfresco.repo.cacheAlFresco
RefreshableCacheListenerInterfaceorg.alfresco.repo.cacheAlFresco
RefreshableCacheRefreshedEventDescribes a new entry has been inserted in the cache.Classorg.alfresco.repo.cacheAlFresco
RefreshableCacheRefreshEventDescribes an entry that is stale in the cacheAuthor:AndySee Also:Serialized FormClassorg.alfresco.repo.cacheAlFresco
RegistryAsynchronouslyRefreshedCacheAsynchronously refreshed cache for repository webscripts.Classorg.alfresco.repo.web.scriptsAlFresco
ShuffleCacheCache for alfresco "save shuffles" which are used by some applications to compensate for a most computer filesystem being non atomic.Interfaceorg.alfresco.filesys.alfrescoAlFresco
ShuffleCacheImplClassorg.alfresco.filesys.alfrescoAlFresco
SimpleCacheBasic caching interface.Interfaceorg.alfresco.repo.cacheAlFresco
TransactionalCacheA 2-level cache that mainains both a transaction-local cache and wraps a non-transactional (shared) cache.Classorg.alfresco.repo.cacheAlFresco
TransactionalCache .CacheRegionKeyClassorg.alfresco.repo.cacheAlFresco
TransactionalCache .ValueHolderA wrapper object to carry object values, but forcing a straight equality check based on a random integer only.Classorg.alfresco.repo.cacheAlFresco
AbstractLayoutSource .LayoutCacheHintThis class serves as both CacheHint and Cache key.Classcom.microstrategy.web.transformMicroStrategy
CacheCache interface.Interfacecom.microstrategy.utils.cacheMicroStrategy
CacheThe interface Cache represents a real cache slot in the memory of the Intelligence Server.Interfacecom.microstrategy.web.objects.admin.monitorsMicroStrategy
CacheBaseBase class for caches.Classcom.microstrategy.utils.cacheMicroStrategy
CacheDetailsThe interface CacheDetails contains the detailed information Since:MicroStrategy Web 9.Interfacecom.microstrategy.web.objects.admin.monitorsMicroStrategy
CacheExceptionClasscom.microstrategy.utils.cacheMicroStrategy
CacheHintEvery item stored in the cache is keyed by a CacheHint.Interfacecom.microstrategy.utils.cacheMicroStrategy
CacheManipulationFailureThe interface CacheManipulationFailure represents a failure in manipulating a cache.Interfacecom.microstrategy.web.objects.admin.monitorsMicroStrategy
CacheManipulatorThe interface CacheManipulator contains operations to manageSince:MicroStrategy Web 9.Interfacecom.microstrategy.web.objects.admin.monitorsMicroStrategy
CacheRegistrySingleton CacheRegistry class keeps track of all cachesSince:MicroStrategy Web 7.Classcom.microstrategy.utils.cacheMicroStrategy
CacheResultsThe interface CacheResults represents the result of a cache retrieval.Interfacecom.microstrategy.web.objects.admin.monitorsMicroStrategy
CachesThe interfaces Caches is a collection of It is usually grouped at the project level.Interfacecom.microstrategy.web.objects.admin.monitorsMicroStrategy
CacheSourceThe interface CacheSource is the entry point to retrieve and manipulate caches.Interfacecom.microstrategy.web.objects.admin.monitorsMicroStrategy
CachesUpdateTimeTaskFields inherited from class com.Classcom.microstrategy.web.app.tasksMicroStrategy
ClientSideLayoutCacheHintThis class provides the hint to use when looking up client side layout caches (for use in the Javascript UI Library [JUIL]).Classcom.microstrategy.utils.configMicroStrategy
ConfigurationFilesCacheThis is the Cache of configuration files.Classcom.microstrategy.utils.configMicroStrategy
ConfigurationFilesCache .ConfigurationFileCacheHintThis is the CacheHint for the ConfigurationFilesCache.Classcom.microstrategy.utils.configMicroStrategy
CubeCacheThe interface CubeCache represents cube-specific cache properties.Interfacecom.microstrategy.web.objects.admin.monitorsMicroStrategy
CustomizationsAwareCacheThis is an abstract base class for those Caches whose content can be affected by a customization.Classcom.microstrategy.utils.cacheMicroStrategy
EnumDSSRWDCacheStatesInterfacecom.microstrategy.webapiMicroStrategy
EnumDSSXMLCacheAdminActionThe interface EnumDSSXMLCacheAdminAction enumerates all the constants describing cache administration action.Interfacecom.microstrategy.webapiMicroStrategy
EnumDSSXMLCacheExpCommandThis interface defines the enumeration constants used to specify cache expiration commands.Interfacecom.microstrategy.webapiMicroStrategy
EnumDSSXMLCacheExpOptionsThis interface defines the enumeration constants used to specify cache expiration commands.Interfacecom.microstrategy.webapiMicroStrategy
EnumDSSXMLCacheInfoThe interface EnumDSSXMLCacheInfo enumerates a list of constants decribing the information of cache in the Intelligence Server.Interfacecom.microstrategy.webapiMicroStrategy
EnumDSSXMLCacheSettingCache setting constants.Interfacecom.microstrategy.webapiMicroStrategy
EnumDSSXMLCacheSwapPolicyCache Swap Policy constantsSince:MicroStrategy Web 7.Interfacecom.microstrategy.webapiMicroStrategy
EnumDSSXMLCacheTypeThis interfae defines the enumeration constants used to specify the type of cache a particular cache object representsInterfacecom.microstrategy.webapiMicroStrategy
EnumDSSXMLDBConnectionCacheOptionEnumeration used to specify the degree to which the IServer will attempt to reuse data for DB connectionsInterfacecom.microstrategy.webapiMicroStrategy
EnumDSSXmlReportCacheDisableOptionsThis enumeration specifies all the possible values that can be set for the EnumDSSXMLServerProjectSettingID.Interfacecom.microstrategy.webapiMicroStrategy
EnumDSSXMLReportCacheStatusThe interface EnumDSSXMLReportCacheStatus enumerates all the constants used to describe the cache status.Interfacecom.microstrategy.webapiMicroStrategy
EnumDSSXMLReportCacheTypeThe interface EnumDSSXMLReportCacheType enumerates all the constants representing the cache types.Interfacecom.microstrategy.webapiMicroStrategy
EnumDSSXMLRWDCacheAdminActionInterfacecom.microstrategy.webapiMicroStrategy
EnumDSSXMLRWDCacheInfoInterfacecom.microstrategy.webapiMicroStrategy
EnumDSSXMLRWDCacheOptionsInterfacecom.microstrategy.webapiMicroStrategy
EnumDSSXmlServerProjectReportCacheDBMatchingFlagThis enumeration specifies all the possible values that can be set for the EnumDSSXMLServerProjectSettingID.Interfacecom.microstrategy.webapiMicroStrategy
FileCacheBaseThe FileCacheBase is the base class for cached objects that depend on a single file, that is, the file they depend on cannot be customized through the plug-ins infrastructure,Classcom.microstrategy.utils.cacheMicroStrategy
ProjectCacheBaseClasscom.microstrategy.web.objectsMicroStrategy
PropertiesCacheClasscom.microstrategy.utils.cacheMicroStrategy
PurgeCachesTagClasscom.microstrategy.web.app.taglibsMicroStrategy
PurgeCachesTagHelperClasscom.microstrategy.web.app.taglibsMicroStrategy
ResourceBundleCacheClasscom.microstrategy.utils.cacheMicroStrategy
ResourceCacheThis is a cache for Resource objects.Classcom.microstrategy.web.app.utils.cacheMicroStrategy
ResourceCacheHintThis class is the hint for ResourceCache.Classcom.microstrategy.web.app.utils.cacheMicroStrategy
ResourceCacheManagerThe ResourceCacheManager is basically a wrapper of the ResourceCache.Classcom.microstrategy.web.app.utils.cacheMicroStrategy
RWDCacheInterfacecom.microstrategy.web.objects.admin.monitorsMicroStrategy
ServerCacheBaseClasscom.microstrategy.web.objectsMicroStrategy
SessionCacheBaseClasscom.microstrategy.web.objectsMicroStrategy
SysDimensionCacheClasscom.microstrategy.web.objectsMicroStrategy
CachedDateFormatStrategya DateFormat strategy that returns a cached SimpleDateFormat instance.Classcom.restfb.utilRestFB
CacheSyncInterfacecom.smartgwt.client.docsSmartGWT
CachedDistanceThis class implements a wrapper around other distance measure to cache previously calculated distances.Classnet.sf.javaml.distanceJavaML
KeyTransformingLoadingCacheA cache that transforms its keys before deferring to a delegate LoadingCache.Classbrooklyn.util.guavaBrooklyn
KeyTransformingLoadingCache .KeyTransformingSameTypeLoadingCacheClassbrooklyn.util.guavaBrooklyn
CacheAbstractJdbcStore Store works with database via SQL dialect.Classorg.apache.ignite.cache.store.jdbcIgnite
CacheAbstractJdbcStore .EntryMappingEntry mapping description.Classorg.apache.ignite.cache.store.jdbcIgnite
CacheAtomicityModeenum CacheAtomicityModeCache atomicity mode controls whether cache should maintain fully transactional semanticsClassorg.apache.ignite.cacheIgnite
CacheAtomicUpdateTimeoutExceptionException thrown when atomic operation timeout occurs.Classorg.apache.ignite.cacheIgnite
CacheAtomicWriteOrderModeenum CacheAtomicWriteOrderModeCache write ordering mode.Classorg.apache.ignite.cacheIgnite
CacheCheckpointSpiThis class defines cache-based implementation for checkpoint SPI.Classorg.apache.ignite.spi.checkpoint.cacheIgnite
CacheCheckpointSpiMBeanManagement bean that provides general administrative and configuration information about cache checkpoint SPI.Interfaceorg.apache.ignite.spi.checkpoint.cacheIgnite
CacheConfigurationThis class defines grid cache configuration.Classorg.apache.ignite.configurationIgnite
CacheEntryEventSerializableFilterThis filter adds Serializable interface to CacheEntryEventFilter object.Interfaceorg.apache.ignite.cacheIgnite
CacheEntryProcessorThis processor adds Serializable interface to EntryProcessor object.Interfaceorg.apache.ignite.cacheIgnite
CacheEventIn-memory database (cache) event.Classorg.apache.ignite.eventsIgnite
CacheExistsExceptionException thrown when cache must be created but it already exists.Classorg.apache.ignite.cacheIgnite
CacheInterceptorCache interceptor.Interfaceorg.apache.ignite.cacheIgnite
CacheInterceptorAdapterCache interceptor convenience adapter.Classorg.apache.ignite.cacheIgnite
CacheJdbcBlobStoreCacheStore implementation backed by JDBC.Classorg.apache.ignite.cache.store.jdbcIgnite
CacheJdbcPojoStore This implementation stores objects in underlying database using java beans mapping description via reflection.Classorg.apache.ignite.cache.store.jdbcIgnite
CacheJdbcPojoStore .PojoMethodsCacheClassorg.apache.ignite.cache.store.jdbcIgnite
CacheJndiTmLookupClassorg.apache.ignite.cache.jta.jndiIgnite
CacheLoadOnlyStoreAdapterThis adapter designed to support stores with bulk loading from stream-like source.Classorg.apache.ignite.cache.storeIgnite
CacheManagerClassorg.apache.ignite.cacheIgnite
CacheMemoryModeenum CacheMemoryModeDefines set of memory modes.Classorg.apache.ignite.cacheIgnite
CacheMetricsCache metrics used to obtain statistics on cache itself.Interfaceorg.apache.ignite.cacheIgnite
CacheMetricsMXBeanThis interface defines JMX view on IgniteCache.Interfaceorg.apache.ignite.mxbeanIgnite
CacheModeEnumeration of all supported caching modes.Classorg.apache.ignite.cacheIgnite
CacheNameResourceAnnotates a field or a setter method for injection of grid cache name.Classorg.apache.ignite.resourcesIgnite
CachePartialUpdateExceptionException thrown from non-transactional cache in case when update succeeded only partially.Classorg.apache.ignite.cacheIgnite
CachePeekModeEnumeration of all supported cache peek modes.Classorg.apache.ignite.cacheIgnite
CacheQueryExecutedEventCache query execution event.Classorg.apache.ignite.eventsIgnite
CacheQueryReadEventCache query read event.Classorg.apache.ignite.eventsIgnite
CacheRebalanceModeenum CacheRebalanceModeCache rebalance mode.Classorg.apache.ignite.cacheIgnite
CacheRebalancingEventIn-memory database (cache) rebalancing event.Classorg.apache.ignite.eventsIgnite
CacheReflectionTmLookup JTA manager by calling static method on the class.Classorg.apache.ignite.cache.jta.reflectIgnite
CacheServerNotFoundExceptionException thrown when all data nodes left the grid.Classorg.apache.ignite.cacheIgnite
CacheStoreAPI for cache persistent storage for read-through and write-through behavior.Interfaceorg.apache.ignite.cache.storeIgnite
CacheStoreAdapterCache storage convenience adapter.Classorg.apache.ignite.cache.storeIgnite
CacheStoreSessionSession for the cache store operations.Interfaceorg.apache.ignite.cache.storeIgnite
CacheStoreSessionResourceAnnotates a field or a setter method for injection of current CacheStoreSession instance.Classorg.apache.ignite.resourcesIgnite
CacheTmLookupAllows grid to use different transactional systems.Interfaceorg.apache.ignite.cache.jtaIgnite
CacheTypeFieldMetadataType field metadata.Classorg.apache.ignite.cacheIgnite
CacheTypeMetadataClassorg.apache.ignite.cacheIgnite
CacheWriteSynchronizationModeenum CacheWriteSynchronizationModeMode indicating how Ignite should wait for write replies from other nodes.Classorg.apache.ignite.cacheIgnite
ComputeTaskNoResultCacheThis annotation disables caching of task results when attached to ComputeTask class being executed.Classorg.apache.ignite.computeIgnite
IgniteCacheMain entry point for all Data Grid APIs.Interfaceorg.apache.igniteIgnite
NearCacheConfigurationClient cache configuration.Classorg.apache.ignite.configurationIgnite
SpringCacheManager Spring cache abstraction allows to enable caching for Java methods so that the result of a method execution is stored in some storage.Classorg.apache.ignite.cache.springIgnite
CacheableMakes a method response cacheable in memory for some time.Classcom.jcabi.aspectsJCabi
Cacheable .FlushClasscom.jcabi.aspectsJCabi
Cacheable .FlushAfterClasscom.jcabi.aspectsJCabi
Cacheable .FlushBeforeClasscom.jcabi.aspectsJCabi
MethodCacherCache method results.Classcom.jcabi.aspects.ajJCabi
HashedOverlappingPairCacheHash-space based OverlappingPairCache.Classcom.bulletphysics.collision.broadphaseJBullet
OverlappingPairCacheOverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the BroadphaseInterface broadphases.Classcom.bulletphysics.collision.broadphaseJBullet
AssetCacheAssetCache is an interface for asset caches.Interfacecom.jme3.asset.cacheJMonkeyEngine
CachedOggStream and caching an Ogg stream from a URL.Classcom.jme3.audio.pluginsJMonkeyEngine
LRUCacheAn LRU cache, based on LinkedHashMap.Classcom.jme3.terrain.geomipmapJMonkeyEngine
SimpleAssetCacheSimpleAssetCache is an asset cache that caches assets without any automatic removal policy.Classcom.jme3.asset.cacheJMonkeyEngine
UncachedOggStreamSingle-threaded physical ogg stream.Classcom.jme3.audio.pluginsJMonkeyEngine
WeakRefAssetCacheA garbage collector bound asset cache that handles non-clonable objects.Classcom.jme3.asset.cacheJMonkeyEngine
WeakRefCloneAssetCache caches cloneable assets in a weak-key cache, allowing them to be collected when memory is low.Classcom.jme3.asset.cacheJMonkeyEngine
CacheConfiguration for the TileCache.Classuk.ac.rdg.resc.ncwms.configncWMS
TileCacheUses the EHCache software to cache arrays of data that have been extracted.Classuk.ac.rdg.resc.ncwms.cachencWMS
TileCacheKeyKey that is used to identify a particular data array (tile) in a TileCache.Classuk.ac.rdg.resc.ncwms.cachencWMS
CacheFileManagerManages downloaded files in folders.Classlnb.utilLNB
SoftCacheMapA map using soft references and a decay time for values.Classlnb.utilLNB
ConcurrentCachedGeneratorA generic wrapper that makes an underlying item generator thread-safe by caching generated items in a concurrently-accessible list.Classcom.numericalmethod.suanshu.stats.random.rng.concurrent.cacheSuanShu
ConcurrentCachedGenerator .GeneratorDefines a generic generator of type T.Interfacecom.numericalmethod.suanshu.stats.random.rng.concurrent.cacheSuanShu
ConcurrentCachedRLGThis is a fast thread-safe wrapper for random long generators.Classcom.numericalmethod.suanshu.stats.random.rng.concurrent.cacheSuanShu
ConcurrentCachedRNGThis is a fast thread-safe wrapper for random number generators.Classcom.numericalmethod.suanshu.stats.random.rng.concurrent.cacheSuanShu
ConcurrentCachedRVGThis is a fast thread-safe wrapper for random vector generators.Classcom.numericalmethod.suanshu.stats.random.rng.concurrent.cacheSuanShu
CachedBindingCmisServiceProvides a framework to cache a CmisBinding object for aSee Also:Serialized FormClassorg.apache.chemistry.opencmis.bridgeOpenCMIS
CacheHeaderContentStreamContent stream with HTTP cache headers.Interfaceorg.apache.chemistry.opencmis.commons.dataOpenCMIS
CmisBindingCacheSimple LRU cache for CmisBinding objects.Classorg.apache.chemistry.opencmis.bridge.lrucacheOpenCMIS
LruCacheBridgeServiceFactoryClassorg.apache.chemistry.opencmis.bridge.lrucacheOpenCMIS
LruCacheCmisServiceUses a LRU cache to cache CmisBinding objects.Classorg.apache.chemistry.opencmis.bridge.lrucacheOpenCMIS
CacheFields inherited from class org.Classorg.jscience.media.audio.dsp.processorsJScience
CacheInterface for managing caches of objects.Interfaceorg.jscience.util.cacheJScience
CacheManagerClassorg.jscience.geography.coordinatesJScience
CacheMap Interface for managing caches of objects fetchable by key.Interfaceorg.jscience.util.cacheJScience
CacheReferenceInterface for a reference to an object, analogous to java.Interfaceorg.jscience.util.cacheJScience
ChangeableCacheClassorg.jscience.util.cacheJScience
FixedSizeCacheCache which stores up to limit Objects.Classorg.jscience.util.cacheJScience
JURLCachePaneA JEditorPane that can take advantage of a URLCache.Classorg.jscience.netJScience
SoftReferenceCacheCache which is cleared according to memory pressure.Classorg.jscience.util.cacheJScience
URLCacheA wrapper around java.Classorg.jscience.netJScience
URLCache .RefreshListenerRefreshListener objects can register with URLCache objects to be notified when the URLCache object is refreshedInterfaceorg.jscience.netJScience
WeakCacheMapA cache which retains weak references to objectsConstructor SummaryWeakCacheMap()Classorg.jscience.util.cacheJScience
CACheFormatClassorg.openscience.cdk.io.formatsCDK
CacheClassnet.yacy.crawler.dataYacy
CacheClassnet.yacy.kelondro.indexYacy
Cache .StatKeysClassnet.yacy.kelondro.indexYacy
CachedFileReaderClassnet.yacy.kelondro.ioYacy
CachedFileWriterClassnet.yacy.kelondro.ioYacy
CachedRecordsThe Records data structure is a flat file with records of fixed length.Classnet.yacy.kelondro.ioYacy
CachedSolrConnectorClassnet.yacy.cora.federate.solr.connectorYacy
CacheStrategyClassnet.yacy.cora.federate.yacyYacy
ErrorCacheClassnet.yacy.search.indexYacy
LargeNumberCachea LargeIntegerCache is used whenever a Integer.Classnet.yacy.documentYacy
ProxyCacheHandlerClassnet.yacy.httpYacy
ReferenceContainerCacheA ReferenceContainerCache is the ram cache for word indexes or other entity type indexes The defines the index reference specification and attributes that can beClassnet.yacy.kelondro.rwiYacy
ReferenceContainerCache .ContainerOrderClassnet.yacy.kelondro.rwiYacy
SearchEventCacheClassnet.yacy.search.queryYacy
TextSnippet .CacheClassnet.yacy.search.snippetYacy
WordCacheClassnet.yacy.cora.documentYacy
WordCache .DictionaryClassnet.yacy.cora.documentYacy
CachedObjectAn object with a timeout.Classorg.knopflerfish.utilKnoplerFish
CacheMapTimeout version of a HashMap.Classorg.knopflerfish.utilKnoplerFish
NaccacheSternEngineNaccacheStern Engine.Classorg.bouncycastle.crypto.enginesBouncyCastle
NaccacheSternKeyGenerationParametersParameters for NaccacheStern public private key generation.Classorg.bouncycastle.crypto.paramsBouncyCastle
NaccacheSternKeyPairGeneratorKey generation parameters for NaccacheStern cipher.Classorg.bouncycastle.crypto.generatorsBouncyCastle
NaccacheSternKeyParametersPublic key parameters for NaccacheStern cipher.Classorg.bouncycastle.crypto.paramsBouncyCastle
NaccacheSternPrivateKeyParametersPrivate key parameters for NaccacheStern cipher.Classorg.bouncycastle.crypto.paramsBouncyCastle
BaseCachedColumnA basic cached column.Classorg.encog.app.analyst.csv.basicHeatonReasearch
BasicCachedFileForms the foundation of all of the cached files in Encog Quant.Classorg.encog.app.analyst.csv.basicHeatonReasearch
CacheDelegateClassorg.quartz.impl.jdbcjobstoreQuartz
EhcacheConstraintConstraints related the locality of Ehcache valuesAuthor:Alex SnapsSee Also:EhcacheEvaluator, Classorg.quartz.locality.constraintQuartz
EhcacheConstraint .OperatorClassorg.quartz.locality.constraintQuartz
EhcacheConstraint .ValueSee Also:Serialized FormConstructor SummaryEhcacheConstraint.Classorg.quartz.locality.constraintQuartz
EhcacheEvaluatorClassorg.terracotta.modules.ehcache.storeQuartz
CachedRowClassliquibase.snapshotLiquiBase
RasterTerrainCacheA cache of raster terrain posts.Classagi.foundation.terrainAGI ( Analytical Graphics )
TerrainCacheA cache of terrain data.Classagi.foundation.terrainAGI ( Analytical Graphics )
TerrainCacheGroupA group of terrain caches.Classagi.foundation.terrainAGI ( Analytical Graphics )
TerrainCacheTimeStampA time stamp used to indicate, in a relative sense, when various terrain regions were last utilized.Classagi.foundation.terrainAGI ( Analytical Graphics )
WebMapServiceCachedImageGlobeOverlayA CustomImageGlobeOverlay that uses data from a WMS-C server.Classagi.foundation.graphicsAGI ( Analytical Graphics )
BinariesCacheThis class provides some convenience methods for caching BinaryPage objects.Classorg.hippoecm.hst.servlet.utilsHippo
CacheElementInterface for cached element.Interfaceorg.hippoecm.hst.cacheHippo
HstCacheHST Cache Interface for cache related activities.Interfaceorg.hippoecm.hst.cacheHippo
HstCacheExceptionClassorg.hippoecm.hst.cacheHippo
NOOPHstCacheClassorg.hippoecm.hst.cacheHippo
NOOPHstCache .NOOPCacheElementClassorg.hippoecm.hst.cacheHippo
PageCacheContextInterfaceorg.hippoecm.hst.core.containerHippo
PageCacheKeyA PageCacheKey represents a key that can be used to qualify/categorize some request.Interfaceorg.hippoecm.hst.core.containerHippo
RequestInfoCacheKeyFragmentCreator Responsible for creating the cachekey fragment that will be part of the PageCacheKey.Interfaceorg.hippoecm.hst.core.containerHippo
CacheElementInterface for cached element.Interfaceorg.hippoecm.hst.cacheHippo
HstCacheHST Cache Interface for cache related activities.Interfaceorg.hippoecm.hst.cacheHippo
HstCacheExceptionClassorg.hippoecm.hst.cacheHippo
PageCacheContextInterfaceorg.hippoecm.hst.core.containerHippo
PageCacheKeyA PageCacheKey represents a key that can be used to qualify/categorize some request.Interfaceorg.hippoecm.hst.core.containerHippo
RequestInfoCacheKeyFragmentCreator Responsible for creating the cachekey fragment that will be part of the PageCacheKey.Interfaceorg.hippoecm.hst.core.containerHippo
CacheableAn interface to indicate something can be cached.Interfacecom.jidesoft.gridJideSoft
CachedArrayListThis is a fast access ArrayList that sacrifices memory for speed.Classcom.jidesoft.utilsJideSoft
CachedArrayList .IntegerWrapperClasscom.jidesoft.utilsJideSoft
CachedTableModelCachedTableModel is a table model that can cache the table data.Classcom.jidesoft.gridJideSoft
CachedVectorThis is a fast access Vector that sacrifices memory for speed.Classcom.jidesoft.utilsJideSoft
CachedVector .IntegerWrapperClasscom.jidesoft.utilsJideSoft
CacheMapThis class was moved to com.Classcom.jidesoft.converterJideSoft
CacheMapCacheMap is a two-level HashMap.Classcom.jidesoft.utilsJideSoft
TreePathCacherTreePathCacher is a TreeScanner that creates and caches a TreePath for a target This class replicates some logic from TreePath.Classorg.checkerframework.framework.utilChecker
GuavaCache Cache services from Guava use(GuavaCache.Classorg.jooby.guavaJooby
GuavaCache .Callback com.Interfaceorg.jooby.guavaJooby
SpyMemcached Provides memcached access via SpyMemcached A MemcachedClient serviceClassorg.jooby.memcachedJooby
CacheActionClassreactor.rx.action.aggregationReactor
AbstractScoresCacheAbstact implementation of the ScoresCache with the shared code used in all objects with a variables cache.Classorg.biojava.nbio.structure.align.multipleBioJava
AtomCacheA utility class that provides easy access to Structure objects.Classorg.biojava.nbio.structure.align.utilBioJava
CachedRemoteScopInstallationAn extension of the RemoteScopInstallation that caches some of the data locally.Classorg.biojava.nbio.structure.scopBioJava
CacheFactoryprovides a SoftHashMap singleton.Classorg.biojava.nbio.structure.align.utilBioJava
DemoAtomCacheExample of how to load PDB files using the AtomCache class.ClassdemoBioJava
FlatFileCacheProvides a cache for storing multiple small files in memory.Classorg.biojava.nbio.core.utilBioJava
ScoresCacheInterface for classes which implement a temporary cache for various numeric scores, e.Interfaceorg.biojava.nbio.structure.align.multipleBioJava
SerializableCacheA class that provides all that is necessary to create a Serializable CacheSince:3.Classorg.biojava.nbio.structure.domainBioJava
AbstractDistributedCacheClientClasscom.landawn.abacus.cacheAbacusUtils
AbstractObjectCacheClasscom.landawn.abacus.cacheAbacusUtils
CacheFactoryClasscom.landawn.abacus.cacheAbacusUtils
DistributedCacheClientInterfacecom.landawn.abacus.cacheAbacusUtils
DistributedObjectCacheClasscom.landawn.abacus.cacheAbacusUtils
LocalObjectCacheClasscom.landawn.abacus.cacheAbacusUtils
MemcachedLockClasscom.landawn.abacus.utilAbacusUtils
ObjectCacheInterfacecom.landawn.abacus.cacheAbacusUtils
SpyMemcachedClasscom.landawn.abacus.cacheAbacusUtils
CMapCacheClasscom.itextpdf.text.pdf.fonts.cmapsIText
ICachedColorSpaceInterfacecom.itextpdf.text.pdfIText
TempFileCacheClasscom.itextpdf.text.ioIText
GpioProviderPinCacheThis class provides cache for gpio pin instances.Classcom.pi4j.io.gpioPI4J
Cache This interface represents a structure which can be used to store parts of a PDF to disk, a database or some other secondary storage, to reduce the amountInterfaceorg.faceless.pdf2BigFaceless
Cache .EntryRepresents a single entry in the Cache.Interfaceorg.faceless.pdf2BigFaceless
DiskCacheA general purpose Cache which optionally writes closed streams to files on disk.Classorg.faceless.pdf2BigFaceless
CachedKernelBase class for RBFKernel and PolyKernel that implements a simple LRU.Classweka.classifiers.functions.supportVectorWeka
ClassCacheA singleton that stores all classes on the classpath.Classweka.coreWeka
ClassCache .ClassFileFilterFor filtering classes.Classweka.coreWeka
ClassCache .DirectoryFilterFor filtering classes.Classweka.coreWeka