-
KFM.Cache
-
br.net.woodstock.rockframework.cache.Cache
-
br.net.woodstock.rockframework.core.cache.Cache
-
ca.grimoire.jnoise.modules.util.Cache
Utility module for caching a generated value. If the cached module appears more than once in a generator tree and generates values for the same location more than once in succession, Cache can speed it up by recording the value for a location.
There is no mechanism for explicitly clearing the cache, so non-deterministic source modules will not work correctly when cached. All of the jnoise modules are deterministic; non-deterministic modules are of questionable use in the context of coherent noise generation.
If you are using the included XML noise configuration system, Cache modules can be declared as
<cache>
<source module />
</cache>
-
cc.concurrent.mango.Cache
-
com.Yasna.util.Cache
General purpose cache implementation. It stores objects associated with unique keys in memory for fast access. All objects added to the cache must implement the Cacheable interface, which requires objects to know their size in memory. This restrictions allows the cache to never grow larger than a specified amount.
If the cache does grow too large, objects will be removed such that those that are accessed least frequently are removed first. Because expiration happens automatically, the cache makes no gaurantee as to how long an object will remain in cache after it is put in. The cache will return null if the requested object is not found.
Optionally, a maximum lifetime for all objects can be specified. In that case, objects will be deleted from cache after that amount of time, even if they are frequently accessed. This feature is useful if objects put in cache represent data that should be periodically refreshed; for example, information from a database.
Cache is optimized for fast data access. The getObject() method has 0(n) performance regardless of cache size. The other cache operations also perform quite fast.
Cache objects are thread safe.
The algorithm for cache is as follows: a HashMap is maintained for fast object lookup. Two linked lists are maintained: one keeps objects in the order they are accessed from cache, the other keeps objects in the order they were originally added to cache. When objects are added to cache, they are first wrapped by a CacheObject which maintains the following pieces of information:
- The size of the object (in bytes).
- A pointer to the node in the linked list that maintains accessed order for the object. Keeping a reference to the node lets us avoid linear scans of the linked list.
- A pointer to the node in the linked list that maintains the age of the object in cache. Keeping a reference to the node lets us avoid linear scans of the linked list.
To get an object from cache, a hash lookup is performed to get a reference to the CacheObject that wraps the real object we are looking for. The object is subsequently moved to the front of the accessed linked list and any necessary cache cleanups are performed. Cache deletion and expiration is performed as needed.
@see Cacheable
-
com.alibaba.dubbo.cache.Cache
Cache
@author william.liangf
-
com.alvazan.orm.api.z8spi.Cache
-
com.atlassian.cache.Cache
-
com.bah.lucene.blockcache.Cache
-
com.cetsoft.imcache.cache.Cache
The Interface Cache.
@param < K> the key type
@param < V> the value type
-
com.cj.jshintmojo.cache.Cache
-
com.dotcms.repackage.com.google.common.cache.Cache
-
com.extjs.gxt.ui.client.core.Templates.Cache
-
com.flaptor.util.Cache
-
com.gargoylesoftware.htmlunit.Cache
Simple cache implementation which caches compiled JavaScript files and parsed CSS snippets. Caching compiled JavaScript files avoids unnecessary web requests and additional compilation overhead, while caching parsed CSS snippets avoids very expensive CSS parsing.
@version $Revision: 5301 $
@author Marc Guillemot
@author Daniel Gredler
-
com.gemstone.gemfire.cache.Cache
-
com.github.dynamicextensionsalfresco.webscripts.annotations.Cache
-
com.github.mrcritical.ironcache.model.Cache
Represents a particular cache in Iron.io. The property {@link #size} is onlyavailable when a specific cache is requested. It is not available when listing the available caches.
@author pjarrell
-
com.google.common.cache.Cache
A semi-persistent mapping from keys to values. Values are automatically loaded by the cache, and are stored in the cache until either evicted or manually invalidated.
All methods other than {@link #get} and {@link #getUnchecked} are optional.
When evaluated as a {@link Function}, a cache yields the same result as invoking {@link #getUnchecked}.
@author Charles Fry
@since Guava release 10
-
com.impetus.kundera.cache.Cache
Implementors define a caching algorithm. All implementors must be threadsafe.
@author animesh.kumar
-
com.jada.jpa.entity.Cache
Cache generated by hbm2java
-
com.lixia.rdp.Cache
-
com.opensymphony.oscache.base.Cache
Provides an interface to the cache itself. Creating an instance of this class will create a cache that behaves according to its construction parameters. The public API provides methods to manage objects in the cache and configure any cache event listeners.
@version $Revision: 437 $
@author
Mike Cannon-Brookes
@author
Todd Gochenour
@author
Francois Beauregard
@author
Chris Miller
-
com.qspin.qtaste.datacollection.collection.Cache
Interface of the Cache
@author lvboque
-
com.salas.bb.utils.uif.images.Cache
Cache of images. The cache is disk-based, but it also has memory map of images which are currently loaded by someone. The cache uses separate thread for flushing of images to disk. The maximum disk usage amount can be specified and the writer thread will check if current saved data is not exceeding the limit after writing the next image. If the limits are exceeded it will remove several last-used images to get back into the limits.
-
com.scooterframework.cache.Cache
Cache interface defines methods of a cache store.
@author (Fei) John Chen
-
com.skyline.common.cache.annotation.Cache
-
com.skyline.energy.annotation.Cache
-
com.skyline.energy.cache.Cache
Cache封装接口
@author wuqh
-
com.spaceprogram.simplejpa.cache.Cache
User: treeder Date: Aug 2, 2009 Time: 7:07:41 PM
-
com.spidercache.cache.Cache
-
com.sun.appserv.util.cache.Cache
Cache Generic cache interface
-
com.sun.enterprise.deployment.runtime.web.Cache
this class contains runtime information for the web bundle it was kept to be backward compatible with the schema2beans descriptors generated by iAS 7.0 engineering team.
@author Jerome Dochez
-
com.thimbleware.jmemcached.Cache
-
com.volantis.cache.Cache
A cache.
Warning: This is a facade provided for use by user code, not for implementation by user code. User implementations of this interface are highly likely to be incompatible with future releases of the product at both binary and source levels.
@mock.generate
-
com.volantis.mcs.cache.Cache
This class provides a generalised cache module.
A cache is an amalgamation of a CacheStore, which handles the storage and retrieval of entries, and a CacheManager which is responsible for the automation of cache entry expiration.
-
de.innovationgate.utils.cache.Cache
A general purpose cache for WGA and all accompanied functionalities. Create a cache object by using {@link CacheFactory#createCache(String,int,Map)}.
This cache offers the following features:
- In-Memory caching
- Reading and writing of cache entries
- Specifying a maximum number of entries. After reaching this threshold adding new elements will result in other elements being dropped (chosen on a "Least recently used" basis by default)
- Specifying a global "timeToLive" time in seconds, which is the maximum allowed lifetime for an entry
- Specifying a specific "timeToLive" time for each individual entry in seconds, which is the maximum allowed lifetime for this entry
- Specifying groups of cache entries that may be flushed separately
- Retrieve Size, MaxSize and Utilisation of the cache
This cache object uses different backend cache implementations ("cache cores") based on configuration. Use sysproperty "de.innovationgate.utils.cache.core" to specify the implementation to use. Cache implementations must use the interface {@link CacheCore}.
-
de.odysseus.el.tree.impl.Cache
Simple (thread-safe) LRU cache. After the cache size reached a certain limit, the least recently used entry is removed, when adding a new entry.
@author Christoph Beck
-
dk.brics.jwig.server.cache.Cache
The cache is responsible for caching responses, generated by JWIG and sent to the client.
-
io.druid.client.cache.Cache
-
it.marcoberri.mbmeteo.model.Cache
@author Marco Berri
-
javax.cache.Cache
A Cache provides storage of data for later fast retrieval.
This Cache interface is based on {@link java.util.concurrent.ConcurrentMap} with some modifications forfast distributed performance.
A Cache does not allow null keys or values. Attempts to store a null value or to use a null key either in a get or put operation will result in a {@link NullPointerException}.
Caches use generics throughout providing a level of type safety akin to the collections package.
Cache implements {@link Iterable} for {@link Cache.Entry}, providing support for simplified iteration. However iteration should be used with caution. It is an O(n) operation and may be slow on large or distributed caches.
The Cache API also provides:
- read-through caching
- write-through caching
- cache loading
- cache listeners
- statistics
- lifecycle
- configuration
Though not visible in the Cache interface caches may be optionally transactional.
User programs may make use of caching annotations to interact with a cache.
A simple example of how to use a cache is:
String cacheName = "sampleCache"; CacheManager cacheManager = Caching.getCacheManager(); Cache<Integer, Date> cache = cacheManager.getCache(cacheName); if (cache == null) { cache = cacheManager.<Integer,Date>createCacheBuilder(cacheName).build(); } Date value1 = new Date(); Integer key = 1; cache.put(key, value1); Date value2 = cache.get(key);
Concurrency
Concurrency is described as if there exists a locking mechanism on each key. If a cache operation gets an exclusive lock on a key, then all subsequent operations on that key will block until that lock is released. The consequences are that operations performed by a thread happen-before read or mutation operations performed by another thread, including threads in different Java Virtual Machines.
@param < K> the type of keys maintained by this cache
@param < V> the type of cached values
@author Greg Luck
@author Yannis Cosmadopoulos
@since 1.0
-
javax.jcache.Cache
-
javax.persistence.Cache
Cache for objects
@since JPA 2.0
-
javax.util.jcache.Cache
Contains several usefull methods for configuring, administering and monitoring the Cache.
@author Frank Karlstr�m
@deprecated will be reomved with no replacement.
-
net.paoding.rose.jade.annotation.Cache
-
net.sf.cache4j.Cache
Cache ��������� ������� � �������� ����
@version $Revision: 1.0 $ $Date:$
@author Yuriy Stepovoy.
stepovoy@gmail.com
-
net.sf.ehcache.Cache
Cache is the central class in ehcache. Caches have {@link Element}s and are managed by the {@link CacheManager}. The Cache performs logical actions. It delegates physical implementations to its {@link net.sf.ehcache.store.Store}s.
A reference to a Cache can be obtained through the {@link CacheManager}. A Cache thus obtained is guaranteed to have status {@link Status#STATUS_ALIVE}. This status is checked for any method which throws {@link IllegalStateException} and the same thrown if it is not alive. This would normallyhappen if a call is made after {@link CacheManager#shutdown} is invoked.
Cache is threadsafe.
Statistics on cache usage are collected and made available through the {@link #getStatistics()} methods.
Various decorators are available for Cache, such as BlockingCache, SelfPopulatingCache and the dynamic proxy ExceptionHandlingDynamicCacheProxy. See each class for details.
@author Greg Luck
@version $Id: Cache.java 793 2008-10-07 07:28:03Z gregluck $
-
net.sf.jsr107cache.Cache
A cache, being a mechanism for efficient temporary storage of objects for the purpose of improving the overall performance of an application system, should not be necessary for the application to function correctly, it only improves the performance.
A cache could be scoped, for examples to a JVM, all JVMs on a node, all nodes in a cluster, etc. Operations that are scoped to a cache such as put or load would affect all JVMs in the cache. So the object loaded in 1 JVM would be equally available to all other JVMs in the cache.
Objects are identified in the cache by a key. A key can be any Java object that implements the equals and hashcode methods. If the object is to be distributed or persisted (if supported) it must implement serializable.
Each object in the cache will have a
CacheEntry object associated with it. This object will encapsulate the metadata associated with the cached object. Mainly it represents the object statistics. "CacheStatistics" represents the read-only statistics of the cache, while "CacheAttributes" represents the user settable attributes of the cache.
-
opennlp.tools.util.Cache
Provides fixed size, pre-allocated, least recently used replacement cache.
-
org.apache.abdera.protocol.client.cache.Cache
-
org.apache.archiva.redback.components.cache.Cache
-
org.apache.blur.store.blockcache.Cache
-
org.apache.chemistry.opencmis.client.bindings.cache.Cache
An interface for an hierarchical cache.
Each level of the hierarchy could use a different caching strategy. The cache is initialize by defining the classes that handle the caching for one level. These classes must implement the {@link CacheLevel} interface.
Level configuration string format: " <class name> [param1=value1,param2=value2,...]
".
For example: org.apache.opencmis.client.bindings.cache.impl.MapCacheLevelImpl capacity=10
@author
Florian Müller
@see CacheLevel
-
org.apache.chemistry.opencmis.client.runtime.cache.Cache
Implements a session cache providing following capabilities:
- access CmisObject by object id
- access CmisObject by object path
-
org.apache.cocoon.caching.Cache
This is the Cocoon cache. This component is responsible for storing and retrieving cached responses. It can be used to monitor the cache or the investigate which responses are cached etc. This interface will grow!
@since 2.1
@author
Carsten Ziegeler
@version CVS $Id: Cache.java,v 1.1 2003/03/09 00:08:43 pier Exp $
-
org.apache.ibatis.cache.Cache
-
org.apache.lucene.util.cache.Cache
Base class for cache implementations.
-
org.apache.olio.webapp.cache.Cache
The cache interface provides all operations necessary for the cache. We could have extended java.util.Map but that would make a lot of unnecessary work for the scope of this project. We can always implement that interface later if desired.
-
org.apache.oodt.cas.filemgr.ingest.Cache
@author mattmann
@author bfoster
@version $Revision$
The core interface for a cache of {@link Product}s (identified by a particular uniqueElement
) from a File Manager.
.
-
org.apache.shiro.cache.Cache
A Cache efficiently stores temporary objects primarily to improve an application's performance.
Shiro doesn't implement a full Cache mechanism itself, since that is outside the core competency of a Security framework. Instead, this interface provides an abstraction (wrapper) API on top of an underlying cache framework's cache instance (e.g. JCache, Ehcache, JCS, OSCache, JBossCache, TerraCotta, Coherence, GigaSpaces, etc, etc), allowing a Shiro user to configure any cache mechanism they choose.
@author Les Hazlewood
@author Jeremy Haile
@since 0.2
-
org.apache.slide.projector.store.Cache
-
org.apache.stanbol.entityhub.servicesapi.yard.Cache
The Cache is a mediator between a {@link Yard} storing the cached informationand the {@link Site} acting as access point to a referencedinformation source.
This interface provides also access to the configuration of the cache. This includes meta data needed to decide if requested information can be retrieved by using the cache or if data need to be requested directly by the referenced site. This includes mainly cached fields used {@link CacheStrategy}for fields as well as cached languages. This may be extended in future versions.
It is important, that the configuration of the cache is stored within the {@link Yard} together with all the other cached information, because it MUSTBE possible to copy&paste cached information to an other Entityhub instance. This requirements enables the initialisation of a Cache only based on the information stored within the cache.
Cache instances should be instantiated automatically by {@link Site}s based on there configuration. The only parameter needed for the initialisation of a {@link Cache} is the id of the yard ({@link Yard#getId()}). However note that the Cache is not responsible to create, configure nor activate the {@link Yard}. If the {@link Yard} for an cache is not active the cachereturns false
on calls to {@link #isAvailable()}.
@author Rupert Westenthaler
-
org.apache.stratum.jcs.engine.control.Cache
This is the primary cache hub. It control the flow of items through the cache. The auxiliary and memory caches are plugged in here.
@author asmuts
@created January 15, 2002
-
org.apache.tools.ant.types.selectors.modifiedselector.Cache
A Cache let the user store key-value-pairs in a permanent manner and access them. It is possible that a client uses get() before load() therefore the implementation must ensure that no error occured because of the wrong order. The implementing class should implement a useful toString() method.
@author Jan Mat\u00e8rne
@version 2003-09-13
@since Ant 1.6
-
org.castor.cache.Cache
Interface specification for performance caches as used in Castor. Please implement this interface if you wish to provide your own cache implementation.
At initialization each cache implementation gets passed a properties map containing key/value pairs. Apart of 3 reserved standard properties, individual once can be used to configure the cache behavier. The standard properties are:
type which is evaluated by the CacheFactoryRegistry and defines the requested cache type. If not set count-limited cahce will be used as default.
debug is also evaluated by the CacheFactoryRegistry and defines if the cache instance will be wrapped by a DebuggingCacheProxy to log debug messages at every access to the cache. If not set no debugging will take place.
name is used by AbstractBaseCache to set the name of the cache instance. At the moment every cache type available extends this AbstractBaseCache. The name does not influence internal behavier of the cache but is usefull to identify from which cache instance debug messages are coming from. By default castor uses the classname of the cached objects as name for the cache. If not present the name will be empty.
For a description of the individual properties you should have a look at the javadoc of the different cache types. It needs to be noted that only string keys and values are allowed.
@author Werner Guttmann
@author Ralf Joachim
@version $Revision: 7950 $ $Date: 2006-04-25 16:09:10 -0600 (Tue, 25 Apr 2006) $
@since 1.0
-
org.chaidb.db.helper.cache.Cache
-
org.codehaus.plexus.cache.Cache
-
org.dayatang.cache.Cache
@author chencao
-
org.dozer.cache.Cache
Internal interface to a single cache. Holds all of the cache entries for the cache. Only intended for internal use.
@author tierney.matt
@author dmitry.buzdin
-
org.dspace.services.model.Cache
This is a cache which can be used to store data.
This is an abstraction of the general concept of a cache.
A Cache holds objects with keys with a limited lifespan and stores them based on the underlying implementation. This cache interface adheres to the JSR-107 spec.
@author Aaron Zeckoski (azeckoski @ gmail.com)
-
org.eclipse.core.internal.utils.Cache
A cache that keeps a collection of at most maximumCapacity+threshold entries. When the number of entries exceeds that limit, least recently used entries are removed so the current size is the same as the maximum capacity.
-
org.eurekastreams.server.persistence.mappers.cache.Cache
Represents a data store where values can be retrieved (typically faster than database access).
-
org.exist.storage.cache.Cache
Base interface for all cache implementations that are used for buffering btree and data pages.
@author Wolfgang
-
org.glassfish.web.deployment.runtime.Cache
this class contains runtime information for the web bundle it was kept to be backward compatible with the schema2beans descriptors generated by iAS 7.0 engineering team.
@author Jerome Dochez
-
org.h2.util.Cache
The cache keeps frequently used objects in the main memory.
-
org.hibernate.Cache
Provides an API for querying/managing the second level cache regions.
CAUTION: None of these methods respect any isolation or transactional semantics associated with the underlying caches. Specifically, evictions perform an immediate "hard" removal outside any transactions and/or locking scheme(s).
@author Steve Ebersole
-
org.hibernate.annotations.Cache
-
org.hibernate.cache.Cache
Implementors define a caching algorithm. All implementors
must be threadsafe.
@deprecated As of 3.3; see
for details.
-
org.infinispan.Cache
-
org.jahia.services.cache.Cache
This is the root class for all the cache in Jahia.
This cache can handle synchronization messages with other Jahia server instances by using JMS messages. This synchronization is automatically initialized and used when the JMS synchronization is activated in the Jahia configuration file.
Each cache must has a distinct name
, and the associated description
is only for debugging purpose or for monitoring display. Each cache uses a MRU (Most Recent Used) list to determine which elements will be removed from the cache when the cache limit has been reached. In this case, the least used cache entry will be removed.
Each object inserted in the cache will be wrapped into a {@link org.jahia.services.cache.CacheEntry CacheEntry} instance, which containsamong other information, the entry's expiration date and last accessed date.
Using the {@link org.jahia.services.cache.Cache#getCacheEntry getCacheEntry}method will retrieve the cache entry instance and not the object stored into the entry instance. To access the stored object instance, the {@link org.jahia.services.cache.Cache#get get} method should be used instead or usethe getter methods of the {@link org.jahia.services.cache.CacheEntry CacheEntry}class.
Caches can only be retrieved and created through the {@link org.jahia.services.cache.CacheFactory CacheFactory} class, which is responsiblefor managing all the caches.
@author Fulco Houkes, Copyright (c) 2003 by Jahia Ltd.
@version 1.0
@since Jahia 4.0
@see org.jahia.services.cache.CacheFactory CacheFactory
@see org.jahia.services.cache.CacheEntry CacheEntry
@see org.jahia.services.cache.CacheListener CacheListener
-
org.jboss.cache.Cache
tes with default settings and starts the cache Cache cache = DefaultCacheFactory.getInstance().createCache(); Fqn personRecords = Fqn.fromString("/org/mycompany/personRecords");
Node rootNode = cache.getRoot(); Node personRecordsNode = rootNode.addChild(personRecords);
// now add some person records. Fqn peterGriffin = Fqn.fromString("/peterGriffin"); Fqn stewieGriffin = Fqn.fromString("/stewieGriffin");
// the addChild() API uses relative Fqns Node peter = personRecordsNode.addChild(peterGriffin); Node stewie = personRecordsNode.addChild(stewieGriffin);
peter.put("name", "Peter Griffin"); peter.put("ageGroup", "MidLifeCrisis"); peter.put("homicidal", Boolean.FALSE);
stewie.put("name", "Stewie Griffin"); stewie.put("ageGroup", "Infant"); stewie.put("homicidal", Boolean.TRUE);
peter.getFqn().toString(); // will print out /org/mycompany/personRecords/peterGriffin stewie.getFqn().toString(); // will print out /org/mycompany/personRecords/stewieGriffin
peter.getFqn().getParent().equals(stewie.getFqn().getParent()); // will return true
For more information, please read the JBoss Cache user guide and tutorial, available on
the JBoss Cache documentation site, and look through the examples
shipped with the JBoss Cache distribution.
@author
Manik Surtani (manik AT jboss DOT org)
@see Node
@see CacheFactory
@since 2.0.0
-
org.jboss.ejb3.annotation.Cache
Injection utilities
@author Scott.Stark@jboss.org
@version $Revision: 93959 $
-
org.jboss.resteasy.annotations.cache.Cache
-
org.jivesoftware.util.cache.Cache
General purpose cache. It stores objects associated with unique keys in memory for fast access. All keys and values added to the cache must implement the Serializable interface. Values may implement the Cacheable interface, which allows the cache to determine object size much more quickly. These restrictions allow a cache to never grow larger than a specified number of bytes and to optionally be distributed over a cluster of servers.
If the cache does grow too large, objects will be removed such that those that are accessed least frequently are removed first. Because expiration happens automatically, the cache makes no gaurantee as to how long an object will remain in cache after it is put in.
Optionally, a maximum lifetime for all objects can be specified. In that case, objects will be deleted from cache after that amount of time, even if they are frequently accessed. This feature is useful if objects put in cache represent data that should be periodically refreshed; for example, information from a database.
All cache operations are thread safe.
@see Cacheable
-
org.nemesis.forum.util.cache.Cache
-
org.nutz.dao.cache.Cache
缓存接口,key现在的生成策略是类名#id或类名#name或类名#pk1,pk2 Implementors define a caching algorithm. All implementors must be threadsafe.
-
org.objectweb.speedo.jmx.mbeans.Cache
@author chassase
-
org.ofbiz.entity.cache.Cache
-
org.omnifaces.component.output.Cache
google.com/p/concurrentlinkedhashmap">http://code.google.com/p/concurrentlinkedhashmap.
@since 1.1
@author Arjan Tijms
@see CacheValue
-
org.openbankdata.core.client.Cache
Class for handling caching of HTTP responses.
-
org.openxri.resolve.Cache
This class provides a cache for XRI resolutions
@author steveg
@author =chetan
-
org.richfaces.cache.Cache
-
org.rzo.yajsw.cache.Cache
-
org.sgx.yuigwt.yui.cache.Cache
ary.com/yui/docs/cache/
@see http://yuilibrary.com/yui/docs/api/classes/Cache.htmlNotes - you can use JavaScriptObject, string and double types - I'm not sure if this support java objects as keys or values.
@author sg
-
org.shiftone.cache.Cache
Interface Cache
@author
Jeff Drost
@version $Revision: 1.8 $
-
org.springframework.cache.Cache
Interface that defines the common cache operations. Note: Due to the generic use of caching, it is recommended that implementations allow storage of null values (for example to cache methods that return {@code null}).
@author Costin Leau
@since 3.1
-
org.syncany.config.Cache
The cache class represents the local disk cache. It is used for storing multichunks or other metadata files before upload, and as a download location for the same files.
The cache implements an LRU strategy based on the last modified date of the cached files. When files are accessed using the respective getters, the last modified date is updated. Using the {@link #clear()}/ {@link #clear(long)} method, the cachecan be cleaned.
@author Philipp C. Heckel
-
org.teiid.cache.Cache
Abstraction over cache providers
-
org.tomighty.resources.cache.Cache
-
org.uiautomation.ios.inspector.model.Cache
-
org.wso2.caching.Cache
-
org.xbill.DNS.Cache
A cache of DNS records. The cache obeys TTLs, so items are purged after their validity period is complete. Negative answers are cached, to avoid repeated failed DNS queries. The credibility of each RRset is maintained, so that more credible records replace less credible records, and lookups can specify the minimum credibility of data they are requesting.
@see RRset
@see Credibility
@author Brian Wellington
-
powermock.examples.bypassencapsulation.nontest.Cache
A made-up class used to demonstrate some PowerMock functionality.
-
railo.commons.io.cache.Cache
-
se.rupy.sprout.Sprout.Cache