java.lang.Object
- com.tangosol.util.Base
- - com.tangosol.net.ExtensibleConfigurableCacheFactory

All Implemented Interfaces:

ConfigurableCacheFactory
```
public class ExtensibleConfigurableCacheFactory
extends Base
implements ConfigurableCacheFactory
```
ExtensibleConfigurableCacheFactory provides a facility to access caches declared in a "coherence-cache-config.xsd" compliant configuration file.
It is strongly recommended that developers get a ConfigurableCacheFactory instance via CacheFactory.getCacheFactoryBuilder().getConfigurableCacheFactory(), rather than instantiate an ExtensibleConfigurableCacheFactory instance directly.
There are various ways of using this factory:
```
   ExtensibleConfigurableCacheFactory.Dependencies deps =
       ExtensibleConfigurableCacheFactory.DependenciesHelper.newInstance("my-cache-config.xml");
   ExtensibleConfigurableCacheFactory factory =
       new ExtensibleConfigurableCacheFactory(deps);
   ...
   ClassLoader loader  = getClass().getClassLoader();
   NamedCache cacheOne = factory.ensureCache("one", loader);
   NamedCache cacheTwo = factory.ensureCache("two", loader);
 
```
Another option is using the static version of the "ensureCache" call:
```
   ClassLoader loader  = getClass().getClassLoader();
   NamedCache cacheOne = CacheFactory.getCache("one", loader);
 
```
which uses an instance of ConfigurableCacheFactory obtained by CacheFactory.getConfigurableCacheFactory().
Since:

Coherence 12.1.2

Author:

gg 2003.05.26, pfm 2012.12.19

See Also:

CacheFactory.getCache(String, ClassLoader, NamedCache.Option...)

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`ExtensibleConfigurableCacheFactory.DefaultDependencies`	The `ExtensibleConfigurableCacheFactory.DefaultDependencies` is a simple implementation of the `ExtensibleConfigurableCacheFactory` `ExtensibleConfigurableCacheFactory.Dependencies` interface.
`static interface`	`ExtensibleConfigurableCacheFactory.Dependencies`	The `ExtensibleConfigurableCacheFactory.Dependencies` for the `ExtensibleConfigurableCacheFactory`.
`static class`	`ExtensibleConfigurableCacheFactory.DependenciesHelper`	The `ExtensibleConfigurableCacheFactory.DependenciesHelper` provides helper method for constructing `ExtensibleConfigurableCacheFactory.Dependencies` implementations for `ExtensibleConfigurableCacheFactory`s.
`static class`	`ExtensibleConfigurableCacheFactory.Manager`	The Manager class uses builders to create the required backing maps and provides client access to those maps.
`static class`	`ExtensibleConfigurableCacheFactory.PartitionedBackingMapManager`	The PartitionedBackingMapManager is used by PartitionAwareBackingMap(s) to lazily configure the enclosing PABM based on the configuration settings of the enclosed maps.

Nested classes/interfaces inherited from class com.tangosol.util.Base
Base.LoggingWriter

Field Summary

Fields
Modifier and Type	Field	Description
`static String`	`CACHE_FACTORY`	The name of the replaceable parameter representing a cache factory.
`static String`	`CACHE_NAME`	The name of the replaceable parameter representing the cache name.
`static String`	`CACHE_REF`	The name of the replaceable parameter representing a cache reference.
`static String`	`CLASS_LOADER`	The name of the replaceable parameter representing the class loader.
`protected com.tangosol.net.events.internal.ConfigurableCacheFactoryDispatcher`	`f_dispatcher`	ConfigurableCacheFactoryDispatcher linked to this cache factory.
`protected com.tangosol.net.internal.ScopedCacheReferenceStore`	`f_store`	Store that holds cache references scoped by class loader and optionally, if configured, Subject.
`protected com.tangosol.net.internal.ScopedReferenceStore<NamedTopic>`	`f_storeTopics`	Store that holds `NamedTopic` references scoped by class loader and optionally, if configured, Subject.
`static String`	`FILE_CFG_CACHE`	The default configuration file name.
`protected boolean`	`m_fActivated`	Indicates whether this factory has been activated.
`protected boolean`	`m_fDisposed`	Indicates whether this factory has been disposed.
`protected Map<Service,String>`	`m_mapServices`	Map used to hold references to services that are ensured by this factory where values are non-scoped service names.
`protected Set<BackingMapManager>`	`m_setManager`	A Set of BackingMapManager instances registered by this factory.
`static HashMap<String,Integer>`	`MAP_SCHEMETYPE_BY_SCHEMENAME`	The mappings from scheme name to scheme type.
`static String`	`MGR_CONTEXT`	The name of the replaceable parameter representing the backing map manager context.
`static int`	`SCHEME_CLASS`	The custom class scheme.
`static int`	`SCHEME_DISK`	Deprecated. As of Coherence 3.0, replaced by `SCHEME_EXTERNAL` and `SCHEME_EXTERNAL_PAGED`
`static int`	`SCHEME_DISTRIBUTED`	The distributed cache scheme.
`static int`	`SCHEME_EXTERNAL`	The external scheme.
`static int`	`SCHEME_EXTERNAL_PAGED`	The paged-external scheme.
`static int`	`SCHEME_FLASHJOURNAL`	The flash journal cache scheme.
`static int`	`SCHEME_INVOCATION`	The invocation service scheme.
`static int`	`SCHEME_LOCAL`	The local cache scheme.
`static int`	`SCHEME_NEAR`	The near cache scheme.
`static int`	`SCHEME_OPTIMISTIC`	The optimistic cache scheme.
`static int`	`SCHEME_OVERFLOW`	The overflow map scheme.
`static int`	`SCHEME_PROXY`	The proxy service scheme.
`static int`	`SCHEME_RAMJOURNAL`	The ram journal cache scheme.
`static int`	`SCHEME_READ_WRITE_BACKING`	The read write backing map scheme.
`static String`	`SCHEME_REF`	The name of the replaceable parameter representing a scheme reference.
`static int`	`SCHEME_REMOTE_CACHE`	The remote cache scheme.
`static int`	`SCHEME_REMOTE_INVOCATION`	The remote invocation scheme.
`static int`	`SCHEME_REPLICATED`	The replicated cache scheme.
`static int`	`SCHEME_TRANSACTIONAL`	The transactional cache scheme.
`static int`	`SCHEME_UNKNOWN`	The unknown scheme type.
`static int`	`SCHEME_VERSIONED_BACKING`	The versioned backing map scheme.
`static int`	`SCHEME_VERSIONED_NEAR`	The versioned near cache scheme.

Fields inherited from class com.tangosol.util.Base
LOG_ALWAYS, LOG_CONFIG, LOG_DEBUG, LOG_ERR, LOG_INFO, LOG_MAX, LOG_MIN, LOG_QUIET, LOG_WARN, POWER_0, POWER_G, POWER_K, POWER_M, POWER_T, UNIT_D, UNIT_H, UNIT_M, UNIT_MS, UNIT_NS, UNIT_S, UNIT_US

Constructor Summary

Constructors
Constructor	Description
`ExtensibleConfigurableCacheFactory(ExtensibleConfigurableCacheFactory.Dependencies dependencies)`	Constructs an `ExtensibleConfigurableCacheFactory` using the specified `ExtensibleConfigurableCacheFactory.Dependencies`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`activate()`	Activate prepares the factory to be used within a container and should be called before any other factory method.
`protected void`	`assertNotDisposed()`	Throws `IllegalStateException` if this factory has been disposed via invocation of `dispose()`.
`protected static void`	`checkContextPermission(NamedCache cache)`	Container aware access check to a cache.
`protected static void`	`checkPermission(NamedCache cache)`	Check if the current user is allowed to "join" the cache.
`protected static void`	`checkPermission(NamedCollection collection)`	Check if the current user is allowed to "join" to the collection.
`protected static void`	`checkPermission(Service service, String sName)`	Check if the current user is allowed to "join" the data structure with the specified name.
`protected void`	`configure()`	Performs final configuration of an `ExtensibleConfigurableCacheFactory` instance prior to it being used by Coherence.
`ParameterResolver`	`createParameterResolver(ClassLoader loader, BackingMapManagerContext ctxBMM)`	Return the ParameterResolver that has been initialized with the built-in Coherence parameters.
`void`	`destroyCache(NamedCache cache)`	Release and destroy this instance of NamedCache.
`void`	`destroyTopic(NamedTopic<?> topic)`	Release and destroy this instance of `NamedTopic`.
`void`	`dispose()`	Dispose of this factory.
`<K,V> NamedCache<K,V>`	`ensureCache(String sCacheName, ClassLoader loader, NamedMap.Option... options)`	Ensure an cache for the given name, classloader and options.
`Service`	`ensureService(ServiceScheme scheme)`	Ensure the service for the specified scheme then start the service if it isn't running.
`Service`	`ensureService(String sServiceName)`	Ensure a service for the given name.
`<V> NamedTopic<V>`	`ensureTopic(String sName, ClassLoader loader, NamedCollection.Option... options)`	Ensure an Object-based topic for the given name.
`Context`	`getApplicationContext()`	Return the application Context associated with this ECCF.
`CacheConfig`	`getCacheConfig()`	Return the `CacheConfig` that contains the configuration used by this factory.
`protected ClassLoader`	`getConfigClassLoader()`	Return the class loader used to load the configuration for this factory.
`ContainerContext`	`getContainerContext()`	Return the ContainerContext associated with this ECCF.
`InterceptorRegistry`	`getInterceptorRegistry()`	Return the `InterceptorRegistry` for this factory.
`<M extends ResourceMapping> ParameterResolver`	`getParameterResolver(String sResourceName, Class<M> clzResourceMapping, ClassLoader loader, BackingMapManagerContext ctxBMM, ContainerContext ctxContainer)`	Return the ParameterResolver that has been initialized with the built-in Coherence parameters.
`ParameterResolver`	`getParameterResolver(String sCacheName, ClassLoader loader, BackingMapManagerContext ctxBMM, ContainerContext ctxContainer)`	Return the ParameterResolver that has been initialized with the built-in Coherence parameters.
`protected long`	`getRequestTimeout(ServiceScheme scheme)`	Return the request timeout determined by the `ServiceScheme`.
`ResourceRegistry`	`getResourceRegistry()`	Return the `ResourceRegistry` for this factory.
`String`	`getScopeName()`	Return the scope name for this ConfigurableCacheFactory.
`Map<Service,String>`	`getServiceMap()`	Return a map of services that were successfully started by this factory where values are corresponding non-scoped service names.
`boolean`	`isActive()`	Returns `true` if this `ExtensibleConfigurableCacheFactory` is activated.
`boolean`	`isCacheActive(String sCacheName, ClassLoader loader)`	Validate whether a cache with the given name is active in the context of the given `ClassLoader`.
`boolean`	`isDisposed()`	Return true if this factory has been disposed via invocation of `dispose()`.
`boolean`	`isTopicActive(String sTopicName, ClassLoader loader)`	Validate whether a topic with the given name is active in the context of the given `ClassLoader`.
`protected void`	`registerBackingMapManager(BackingMapManager mgr)`	Register the specified BackingMapManager as a "valid" one.
`protected void`	`release(BinaryStore store)`	Release all resources associated with the specified binary store.
`protected void`	`release(CacheLoader loader)`	Release all resources associated with the specified loader.
`protected void`	`release(Map map, Map mapListeners)`	Release all resources associated with the specified backing map.
`void`	`releaseCache(NamedCache cache)`	Release a cache and its associated resources.
`protected void`	`releaseCache(NamedCache cache, boolean fDestroy)`	Release a cache managed by this factory, optionally destroying it.
`void`	`releaseTopic(NamedTopic<?> topic)`	Release a `NamedTopic` and its associated resources.
`protected void`	`setConfigClassLoader(ClassLoader loader)`	Set the class loader used to load the configuration for this factory.
`protected void`	`startService(Service service)`	Start the given `Service`.
`void`	`startServices()`	Start all services that are declared as requiring an "autostart".
`protected static int`	`translateStandardSchemeType(String sScheme)`	Translate the scheme name into the scheme type.
`protected void`	`validateBackingMapManager(CacheService service)`	Ensures that the backing map manager of the specified service was configured by this (or equivalent) factory.

Methods inherited from class com.tangosol.util.Base
azzert, azzert, azzert, azzertFailed, breakLines, breakLines, capitalize, checkNotEmpty, checkNotNull, checkRange, computeSafeWaitTime, decimalValue, dup, dup, ensureBigDecimal, ensureClassLoader, ensureRuntimeException, ensureRuntimeException, equals, equalsDeep, err, err, err, err, err, escape, formatDateTime, getCallerStackFrame, getCommonMonitor, getCommonMonitor, getCommonMonitor, getContextClassLoader, getContextClassLoader, getDeepMessage, getErr, getLastSafeTimeMillis, getLog, getMaxDecDigits, getMaxHexDigits, getOriginalException, getOut, getProcessRandom, getRandom, getRandomBinary, getRandomBinary, getRandomString, getSafeTimeMillis, getStackFrame, getStackFrames, getStackTrace, getStackTrace, getStackTrace, getThreadFactory, getTimeZone, getUpTimeMillis, hashCode, hexValue, indentString, indentString, isDecimal, isHex, isLogEcho, isOctal, log, log, log, log, log, makeInteger, makeLong, makeThread, mergeArray, mergeBooleanArray, mergeByteArray, mergeCharArray, mergeDoubleArray, mergeFloatArray, mergeIntArray, mergeLongArray, mod, mod, octalValue, out, out, out, out, out, pad, parseBandwidth, parseBandwidth, parseDelimitedString, parseHex, parseHex, parseMemorySize, parseMemorySize, parsePercentage, parseTime, parseTime, parseTimeNanos, parseTimeNanos, printStackTrace, randomize, randomize, randomize, randomize, read, read, read, read, read, read, read, replace, setErr, setLog, setLogEcho, setOut, sleep, toBandwidthString, toBandwidthString, toCharEscape, toCrc, toCrc, toCrc, toCrc, toCrc, toDecString, toDelimitedString, toDelimitedString, toDelimitedString, toDelimitedString, toHex, toHex, toHexDump, toHexEscape, toHexEscape, toHexEscape, toHexEscape, toHexString, toMemorySizeString, toMemorySizeString, toQuotedCharEscape, toQuotedStringEscape, toSqlString, toString, toString, toStringEscape, toUnicodeEscape, trace, trace, trace, trace, trace, trace, trace, trace, trace, truncateString, truncateString, wait

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.tangosol.net.ConfigurableCacheFactory
ensureCache, ensureTopic, ensureTypedCache

- Field Detail
  - FILE_CFG_CACHE
```
public static final String FILE_CFG_CACHE
```
    The default configuration file name.
    
    See Also:
    
    Constant Field Values
  - CACHE_NAME
```
public static final String CACHE_NAME
```
    The name of the replaceable parameter representing the cache name.
    
    See Also:
    
    Constant Field Values
  - CLASS_LOADER
```
public static final String CLASS_LOADER
```
    The name of the replaceable parameter representing the class loader.
    
    See Also:
    
    Constant Field Values
  - MGR_CONTEXT
```
public static final String MGR_CONTEXT
```
    The name of the replaceable parameter representing the backing map manager context.
    
    See Also:
    
    Constant Field Values
  - SCHEME_REF
```
public static final String SCHEME_REF
```
    The name of the replaceable parameter representing a scheme reference.
    
    See Also:
    
    Constant Field Values
  - CACHE_REF
```
public static final String CACHE_REF
```
    The name of the replaceable parameter representing a cache reference.
    
    See Also:
    
    Constant Field Values
  - CACHE_FACTORY
```
public static final String CACHE_FACTORY
```
    The name of the replaceable parameter representing a cache factory.
    
    See Also:
    
    Constant Field Values
  - SCHEME_UNKNOWN
```
public static final int SCHEME_UNKNOWN
```
    The unknown scheme type.
    
    See Also:
    
    Constant Field Values
  - SCHEME_REPLICATED
```
public static final int SCHEME_REPLICATED
```
    The replicated cache scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_OPTIMISTIC
```
public static final int SCHEME_OPTIMISTIC
```
    The optimistic cache scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_DISTRIBUTED
```
public static final int SCHEME_DISTRIBUTED
```
    The distributed cache scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_NEAR
```
public static final int SCHEME_NEAR
```
    The near cache scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_VERSIONED_NEAR
```
public static final int SCHEME_VERSIONED_NEAR
```
    The versioned near cache scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_LOCAL
```
public static final int SCHEME_LOCAL
```
    The local cache scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_OVERFLOW
```
public static final int SCHEME_OVERFLOW
```
    The overflow map scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_DISK
```
public static final int SCHEME_DISK
```
    Deprecated.
    As of Coherence 3.0, replaced by SCHEME_EXTERNAL and SCHEME_EXTERNAL_PAGED
    
    The disk scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_EXTERNAL
```
public static final int SCHEME_EXTERNAL
```
    The external scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_EXTERNAL_PAGED
```
public static final int SCHEME_EXTERNAL_PAGED
```
    The paged-external scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_CLASS
```
public static final int SCHEME_CLASS
```
    The custom class scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_READ_WRITE_BACKING
```
public static final int SCHEME_READ_WRITE_BACKING
```
    The read write backing map scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_VERSIONED_BACKING
```
public static final int SCHEME_VERSIONED_BACKING
```
    The versioned backing map scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_INVOCATION
```
public static final int SCHEME_INVOCATION
```
    The invocation service scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_PROXY
```
public static final int SCHEME_PROXY
```
    The proxy service scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_REMOTE_CACHE
```
public static final int SCHEME_REMOTE_CACHE
```
    The remote cache scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_REMOTE_INVOCATION
```
public static final int SCHEME_REMOTE_INVOCATION
```
    The remote invocation scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_TRANSACTIONAL
```
public static final int SCHEME_TRANSACTIONAL
```
    The transactional cache scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_FLASHJOURNAL
```
public static final int SCHEME_FLASHJOURNAL
```
    The flash journal cache scheme.
    
    See Also:
    
    Constant Field Values
  - SCHEME_RAMJOURNAL
```
public static final int SCHEME_RAMJOURNAL
```
    The ram journal cache scheme.
    
    See Also:
    
    Constant Field Values
  - MAP_SCHEMETYPE_BY_SCHEMENAME
```
public static final HashMap<String,Integer> MAP_SCHEMETYPE_BY_SCHEMENAME
```
    The mappings from scheme name to scheme type.
  - f_store
```
protected final com.tangosol.net.internal.ScopedCacheReferenceStore f_store
```
    Store that holds cache references scoped by class loader and optionally, if configured, Subject.
  - f_storeTopics
```
protected final com.tangosol.net.internal.ScopedReferenceStore<NamedTopic> f_storeTopics
```
    Store that holds NamedTopic references scoped by class loader and optionally, if configured, Subject.
  - f_dispatcher
```
protected final com.tangosol.net.events.internal.ConfigurableCacheFactoryDispatcher f_dispatcher
```
    ConfigurableCacheFactoryDispatcher linked to this cache factory.
  - m_mapServices
```
protected Map<Service,String> m_mapServices
```
    Map used to hold references to services that are ensured by this factory where values are non-scoped service names.
  - m_setManager
```
protected Set<BackingMapManager> m_setManager
```
    A Set of BackingMapManager instances registered by this factory.
    Note: we rely on the BackingMapManager classes *not* to override the hashCode() and equals() methods.
  - m_fActivated
```
protected boolean m_fActivated
```
    Indicates whether this factory has been activated.
  - m_fDisposed
```
protected boolean m_fDisposed
```
    Indicates whether this factory has been disposed.
- Constructor Detail
  - ExtensibleConfigurableCacheFactory
```
public ExtensibleConfigurableCacheFactory(ExtensibleConfigurableCacheFactory.Dependencies dependencies)
```
    Constructs an ExtensibleConfigurableCacheFactory using the specified ExtensibleConfigurableCacheFactory.Dependencies.
    
    Parameters:
    
    dependencies - the ExtensibleConfigurableCacheFactory.Dependencies
- Method Detail
  - ensureCache
```
public <K,V> NamedCache<K,V> ensureCache(String sCacheName,
                                                     ClassLoader loader,
                                                     NamedMap.Option... options)
```
    Description copied from interface: ConfigurableCacheFactory
    
    Ensure an cache for the given name, classloader and options.
    
    Specified by:
    
    ensureCache in interface ConfigurableCacheFactory
    
    Parameters:
    
    sCacheName - the cache name
    
    loader - ClassLoader that should be used to deserialize objects in the cache
    
    options - the NamedMap.Options
    
    Returns:
    
    a NamedCache created
  - releaseCache
```
public void releaseCache(NamedCache cache)
```
    Release a cache and its associated resources.
    Releasing a cache makes it no longer usable, but does not affect the cache itself. In other words, all other references to the cache will still be valid, and the cache data is not affected by releasing the reference. Any attempt to use the released cache reference afterword will result in an exception.
    
    Specified by:
    
    releaseCache in interface ConfigurableCacheFactory
    
    Parameters:
    
    cache - the cache to release
  - destroyCache
```
public void destroyCache(NamedCache cache)
```
    Release and destroy this instance of NamedCache.
    Warning: This method is used to completely destroy the specified cache across the cluster. All references in the entire cluster to this cache will be invalidated, the cached data will be cleared, and all internal and associated resources will be released.
    
    Specified by:
    
    destroyCache in interface ConfigurableCacheFactory
    
    Parameters:
    
    cache - the cache to release
  - ensureTopic
```
public <V> NamedTopic<V> ensureTopic(String sName,
                                     ClassLoader loader,
                                     NamedCollection.Option... options)
```
    Ensure an Object-based topic for the given name.
    
    Specified by:
    
    ensureTopic in interface ConfigurableCacheFactory
    
    Parameters:
    
    sName - the topic name
    
    loader - ClassLoader that should be used to deserialize objects in the cache
    
    options - the NamedCollection.Options to control any optional topic configuration
    
    Returns:
    
    a NamedTopic created
  - ensureService
```
public Service ensureService(String sServiceName)
```
    Ensure a service for the given name.
    
    Specified by:
    
    ensureService in interface ConfigurableCacheFactory
    
    Parameters:
    
    sServiceName - the service name
    
    Returns:
    
    a Service created
  - activate
```
public void activate()
```
    Activate prepares the factory to be used within a container and should be called before any other factory method.
    
    Specified by:
    
    activate in interface ConfigurableCacheFactory
  - dispose
```
public void dispose()
```
    Dispose of this factory. This will stop all services that were started by this factory and dispose of all resources registered via ConfigurableCacheFactory.getResourceRegistry(). This factory may not be used after invoking dispose.
    
    Specified by:
    
    dispose in interface ConfigurableCacheFactory
  - getResourceRegistry
```
public ResourceRegistry getResourceRegistry()
```
    Return the ResourceRegistry for this factory.
    
    Specified by:
    
    getResourceRegistry in interface ConfigurableCacheFactory
    
    Returns:
    
    the ResourceRegistry for this factory
  - getInterceptorRegistry
```
public InterceptorRegistry getInterceptorRegistry()
```
    Return the InterceptorRegistry for this factory. EventInterceptors registered with this registry will be scoped to services and caches created by this factory.
    
    Specified by:
    
    getInterceptorRegistry in interface ConfigurableCacheFactory
    
    Returns:
    
    the InterceptorRegistry for this factory
  - isActive
```
public boolean isActive()
```
    Returns true if this ExtensibleConfigurableCacheFactory is activated.
    
    Specified by:
    
    isActive in interface ConfigurableCacheFactory
    
    Returns:
    
    true if this ExtensibleConfigurableCacheFactory is activated
  - getScopeName
```
public String getScopeName()
```
    Return the scope name for this ConfigurableCacheFactory. If specified, this name will be used as a prefix for the name of all services created by this factory.
    
    Specified by:
    
    getScopeName in interface ConfigurableCacheFactory
    
    Returns:
    
    the scope name for this ConfigurableCacheFactory; may be null
  - getApplicationContext
```
public Context getApplicationContext()
```
    Return the application Context associated with this ECCF.
    
    Returns:
    
    the application Context or null, if none is associated
  - getContainerContext
```
public ContainerContext getContainerContext()
```
    Return the ContainerContext associated with this ECCF.
    
    Returns:
    
    the ContainerContext or null, if none is associated
  - getRequestTimeout
```
protected long getRequestTimeout(ServiceScheme scheme)
```
    Return the request timeout determined by the ServiceScheme.
    
    Parameters:
    
    scheme - the scheme that determines the request timeout
    
    Returns:
    
    the request timeout
  - isDisposed
```
public boolean isDisposed()
```
    Return true if this factory has been disposed via invocation of dispose().
    
    Specified by:
    
    isDisposed in interface ConfigurableCacheFactory
    
    Returns:
    
    true if this factory has been disposed
  - assertNotDisposed
```
protected void assertNotDisposed()
```
    Throws IllegalStateException if this factory has been disposed via invocation of dispose().
  - configure
```
protected void configure()
```
    Performs final configuration of an ExtensibleConfigurableCacheFactory instance prior to it being used by Coherence.
    This method is called by the ExtensibleConfigurableCacheFactory constructor, just after the internal state has been initialized and before the ExtensibleConfigurableCacheFactory instance is returned to the caller.
    This method allows those that need to sub-class an ExtensibleConfigurableCacheFactory to override the final stages of configuration. Anyone overriding this method must be sure to call super.configure() in order to ensure correction configuration semantics.
  - ensureService
```
public Service ensureService(ServiceScheme scheme)
```
    Ensure the service for the specified scheme then start the service if it isn't running.
    
    Parameters:
    
    scheme - the scheme referring to the service
    
    Returns:
    
    the corresponding Service
  - getCacheConfig
```
public CacheConfig getCacheConfig()
```
    Return the CacheConfig that contains the configuration used by this factory.
    
    Returns:
    
    the CacheConfig
  - translateStandardSchemeType
```
protected static int translateStandardSchemeType(String sScheme)
```
    Translate the scheme name into the scheme type. Valid scheme types are any of the SCHEME_* constants.
    
    Parameters:
    
    sScheme - the scheme name
    
    Returns:
    
    the scheme type
  - startServices
```
public void startServices()
```
    Start all services that are declared as requiring an "autostart".
  - getServiceMap
```
public Map<Service,String> getServiceMap()
```
    Return a map of services that were successfully started by this factory where values are corresponding non-scoped service names.
    Note, that this method returns a copy of the underlying map
  - startService
```
protected void startService(Service service)
```
    Start the given Service. Extensions of this class can override this method to provide pre/post start functionality.
    
    Parameters:
    
    service - the Service to start
  - setConfigClassLoader
```
protected void setConfigClassLoader(ClassLoader loader)
```
    Set the class loader used to load the configuration for this factory.
    
    Parameters:
    
    loader - the class loader to use for loading the configuration
  - getConfigClassLoader
```
protected ClassLoader getConfigClassLoader()
```
    Return the class loader used to load the configuration for this factory.
    
    Returns:
    
    the class loader to use for loading the configuration
  - checkPermission
```
protected static void checkPermission(NamedCache cache)
```
    Check if the current user is allowed to "join" the cache.
    
    Parameters:
    
    cache - the cache
  - checkPermission
```
protected static void checkPermission(NamedCollection collection)
```
    Check if the current user is allowed to "join" to the collection.
    
    Parameters:
    
    collection - the collection
  - checkPermission
```
protected static void checkPermission(Service service,
                                      String sName)
```
    Check if the current user is allowed to "join" the data structure with the specified name.
    
    Parameters:
    
    service - the service
    
    sName - the data structure name
  - checkContextPermission
```
protected static void checkContextPermission(NamedCache cache)
```
    Container aware access check to a cache.
    
    Parameters:
    
    cache - the cache
  - getParameterResolver
```
public ParameterResolver getParameterResolver(String sCacheName,
                                              ClassLoader loader,
                                              BackingMapManagerContext ctxBMM,
                                              ContainerContext ctxContainer)
```
    Return the ParameterResolver that has been initialized with the built-in Coherence parameters. Schemes may use expressions (macros) and the resolver contains the parameters that are defined in the cache mapping needed to translate those expressions into values.
    
    Parameters:
    
    sCacheName - the cache name
    
    loader - the ClassLoader
    
    ctxBMM - the BackingMapManagerContext
    
    ctxContainer - the ContainerContext
    
    Returns:
    
    the ParameterResolver
  - getParameterResolver
```
public <M extends ResourceMapping> ParameterResolver getParameterResolver(String sResourceName,
                                                                          Class<M> clzResourceMapping,
                                                                          ClassLoader loader,
                                                                          BackingMapManagerContext ctxBMM,
                                                                          ContainerContext ctxContainer)
```
    Return the ParameterResolver that has been initialized with the built-in Coherence parameters. Schemes may use expressions (macros) and the resolver contains the parameters that are defined in the cache mapping needed to translate those expressions into values.
    
    Parameters:
    
    sResourceName - the resource name
    
    clzResourceMapping - resource type
    
    loader - the ClassLoader
    
    ctxBMM - the BackingMapManagerContext
    
    ctxContainer - the ContainerContext
    
    Returns:
    
    the ParameterResolver
    
    Since:
    
    14.1.1.0
  - createParameterResolver
```
public ParameterResolver createParameterResolver(ClassLoader loader,
                                                 BackingMapManagerContext ctxBMM)
```
    Return the ParameterResolver that has been initialized with the built-in Coherence parameters. Schemes may use expressions (macros) and the resolver contains the parameters that are defined for components defined at a scheme level and not a cache level.
    
    Parameters:
    
    loader - the ClassLoader
    
    ctxBMM - the BackingMapManagerContext
    
    Returns:
    
    the ParameterResolver
  - registerBackingMapManager
```
protected void registerBackingMapManager(BackingMapManager mgr)
```
    Register the specified BackingMapManager as a "valid" one. That registry is used to identify services configured and started by this factory and prevent accidental usage of (potentially incompatible) cache services with the same name created by other factories.
    
    Parameters:
    
    mgr - a BackingMapManager instance instantiated by this factory
  - validateBackingMapManager
```
protected void validateBackingMapManager(CacheService service)
                                  throws IllegalStateException
```
    Ensures that the backing map manager of the specified service was configured by this (or equivalent) factory. This validation is performed to prevent accidental usage of (potentially incompatible) cache services with the same name created by other factories.
    
    Parameters:
    
    service - the CacheService to validate
    
    Throws:
    
    IllegalStateException - if the backing map for the provided service does not reference the expected factory
  - release
```
protected void release(Map map,
                       Map mapListeners)
```
    Release all resources associated with the specified backing map.
    
    Parameters:
    
    map - the map being released
    
    mapListeners - map of registered map listeners keyed by the corresponding map references
  - release
```
protected void release(CacheLoader loader)
```
    Release all resources associated with the specified loader.
    
    Parameters:
    
    loader - the cache loader being released
  - release
```
protected void release(BinaryStore store)
```
    Release all resources associated with the specified binary store.
    
    Parameters:
    
    store - the binary store being released
  - releaseCache
```
protected void releaseCache(NamedCache cache,
                            boolean fDestroy)
```
    Release a cache managed by this factory, optionally destroying it.
    
    Parameters:
    
    cache - the cache to release
    
    fDestroy - true to destroy the cache as well
  - releaseTopic
```
public void releaseTopic(NamedTopic<?> topic)
```
    Release a NamedTopic and its associated resources.
    Releasing a topic makes it no longer usable, but does not affect the topic itself. In other words, all other references to the topic will still be valid, and the topic data is not affected by releasing the reference. Any attempt to use the released topic reference afterword will result in an exception.
    
    Specified by:
    
    releaseTopic in interface ConfigurableCacheFactory
    
    Parameters:
    
    topic - the topic to release
  - destroyTopic
```
public void destroyTopic(NamedTopic<?> topic)
```
    Release and destroy this instance of NamedTopic.
    Warning: This method is used to completely destroy the specified topic across the cluster. All references in the entire cluster to this topic will be invalidated, the topic data will be cleared, and all internal and associated resources will be released.
    
    Specified by:
    
    destroyTopic in interface ConfigurableCacheFactory
    
    Parameters:
    
    topic - the topic to release
  - isCacheActive
```
public boolean isCacheActive(String sCacheName,
                             ClassLoader loader)
```
    Validate whether a cache with the given name is active in the context of the given ClassLoader. The ClassLoader should be the same as provided to a previous call to ConfigurableCacheFactory.ensureCache(String, ClassLoader, NamedCache.Option...).
    
    Specified by:
    
    isCacheActive in interface ConfigurableCacheFactory
    
    Parameters:
    
    sCacheName - the cache name
    
    loader - the ClassLoader used to originally obtain the cache
    
    Returns:
    
    true if cache is active in context of the provided ClassLoader
  - isTopicActive
```
public boolean isTopicActive(String sTopicName,
                             ClassLoader loader)
```
    Validate whether a topic with the given name is active in the context of the given ClassLoader. The ClassLoader should be the same as provided to a previous call to ConfigurableCacheFactory.ensureTopic(String, ClassLoader, NamedTopic.Option...).
    
    Specified by:
    
    isTopicActive in interface ConfigurableCacheFactory
    
    Parameters:
    
    sTopicName - the topic name
    
    loader - the ClassLoader used to originally obtain the topic
    
    Returns:
    
    true if topic is active in context of the provided ClassLoader

Class ExtensibleConfigurableCacheFactory

Nested Class Summary

Nested classes/interfaces inherited from class com.tangosol.util.Base

Field Summary

Fields inherited from class com.tangosol.util.Base

Constructor Summary

Method Summary

Methods inherited from class com.tangosol.util.Base

Methods inherited from class java.lang.Object

Methods inherited from interface com.tangosol.net.ConfigurableCacheFactory

Field Detail

FILE_CFG_CACHE

CACHE_NAME

CLASS_LOADER

MGR_CONTEXT

SCHEME_REF

CACHE_REF

CACHE_FACTORY

SCHEME_UNKNOWN

SCHEME_REPLICATED

SCHEME_OPTIMISTIC

SCHEME_DISTRIBUTED

SCHEME_NEAR

SCHEME_VERSIONED_NEAR

SCHEME_LOCAL

SCHEME_OVERFLOW

SCHEME_DISK

SCHEME_EXTERNAL

SCHEME_EXTERNAL_PAGED

SCHEME_CLASS

SCHEME_READ_WRITE_BACKING

SCHEME_VERSIONED_BACKING

SCHEME_INVOCATION

SCHEME_PROXY

SCHEME_REMOTE_CACHE

SCHEME_REMOTE_INVOCATION

SCHEME_TRANSACTIONAL

SCHEME_FLASHJOURNAL

SCHEME_RAMJOURNAL

MAP_SCHEMETYPE_BY_SCHEMENAME

f_store

f_storeTopics

f_dispatcher

m_mapServices

m_setManager

m_fActivated

m_fDisposed

Constructor Detail

ExtensibleConfigurableCacheFactory

Method Detail

ensureCache

releaseCache

destroyCache

ensureTopic

ensureService

activate

dispose

getResourceRegistry

getInterceptorRegistry

isActive

getScopeName

getApplicationContext

getContainerContext

getRequestTimeout

isDisposed

assertNotDisposed

configure

ensureService

getCacheConfig

translateStandardSchemeType

startServices

getServiceMap

startService

setConfigClassLoader

getConfigClassLoader

checkPermission

checkPermission

checkPermission

checkContextPermission

getParameterResolver