org.apache.uima.resource.impl

## Class ResourceManager_impl

- java.lang.Object
- - org.apache.uima.resource.impl.ResourceManager_impl

- All Implemented Interfaces:
    ResourceManager

      public class ResourceManager_impl
      extends Object
      implements ResourceManager

  Reference implementation of `ResourceManager`.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `protected static class` | `ResourceManager_impl.ResourceRegistration` Ties an External Resource instance to - its description -- name -- textual description -- a ResourceSpecifier describing how to create it -- (optional) the String name of the Java class that implements the resource) - its defining UIMA Context These are used to validate multiple declarations, and to get a resource to tie it to a binding

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected static Class<Resource>` | `EMPTY_RESOURCE_CLASS`
    `protected static String` | `LOG_RESOURCE_BUNDLE` resource bundle for log messages
    `protected CasManager` | `mCasManager` CasManager - manages creation and pooling of CASes.
    `protected Map<String,Class<?>>` | `mInternalParameterizedResourceImplClassMap` Internal map from resource names (declared in resource declaration XML) to Class objects for parameterized Resource.
    `protected Map<String,ResourceManager_impl.ResourceRegistration>` | `mInternalResourceRegistrationMap` Internal map from resource names (declared in resource declaration XML) to ResourceRegistration objects.
    `protected Map<String,Class<?>>` | `mParameterizedResourceImplClassMap` Map from String keys to Class objects.
    `protected Map<List<Object>,Object>` | `mParameterizedResourceInstanceMap` Map from ParameterizedResourceKey to SharedResourceObject or DataResource instances.
    `protected Map<String,Object>` | `mResourceMap` Map from qualified key names (declared in resource dependency XML) to either DataResource objects or SharedResourceObjects that impl Resource.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ResourceManager_impl()` Creates a new `ResourceManager_impl`.
    `ResourceManager_impl(ClassLoader aClassLoader)` Creates a new `ResourceManager_impl` with a custom ClassLoader to use for locating resources.
    `ResourceManager_impl(Map<String,Object> resourceMap, Map<String,ResourceManager_impl.ResourceRegistration> internalResourceRegistrationMap, Map<String,Class<?>> parameterizedResourceImplClassMap, Map<String,Class<?>> internalParameterizedResourceImplClassMap, Map<List<Object>,Object> parameterizedResourceInstanceMap)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `ResourceManager_impl` | `copy()`
    `void` | `destroy()` Frees all resources held by this ResourceManager, and marks the ResourceManager as having been destroyed.
    `CasManager` | `getCasManager()` Gets the CasManager, which manages the creation and pooling of CASes.
    `String` | `getDataPath()` Gets the data path used to resolve relative paths.
    `ClassLoader` | `getExtensionClassLoader()` Returns the UIMA extension class loader.
    `List<Object>` | `getExternalResources()`
    `Map<String,XMLizable>` | `getImportCache()` Gets a cache of imported descriptors, so that the parsed objects can be reused if the same URL is imported more than once.
    `Map<String,Set<String>>` | `getImportUrlsCache()`
    `protected RelativePathResolver` | `getRelativePathResolver()`
    `Object` | `getResource(String aName)` Gets the instance of the implementation object for a resource that has been registered under the specified name.
    `Object` | `getResource(String aName, String[] aParams)` Returns one of two kinds of objects (or null): - an instance of the implementation object for a resource, that has been loaded with a DataResource resource produced by the resource given the aParms - (if there is no implementation defined for this resource) returns an instance of the DataResource, itself, produced by the resource given the aParms An example of a parameterized Resource is a dictionary whose data depend on a specified language identifier.
    `InputStream` | `getResourceAsStream(String aKey)` Retrieves an InputStream for reading from the named resource.
    `InputStream` | `getResourceAsStream(String aKey, String[] aParams)` Retrieves an InputStream for reading from the named resource.
    `Class<?>` | `getResourceClass(String aName)` Gets the Class of the Resource that will be returned by a call to `ResourceManager.getResource(String)` or `ResourceManager.getResource(String,String[])`.
    `URL` | `getResourceURL(String aKey)` Retrieves the URL to the named resource.
    `URL` | `getResourceURL(String aKey, String[] aParams)` Retrieves the URL to the named resource.
    `void` | `initializeExternalResources(ResourceManagerConfiguration aConfiguration, String aQualifiedContextName, Map<String,Object> aAdditionalParams)` Initializes all external resources declared in a ResourceCreationSpecifier.
    `<N> Class<N>` | `loadUserClass(String name)` Loads a user class using either the UIMA extension class loader (if specified) or the ThreadLocal Context Class Loader (if available) or the loader the UIMA framework is running in.
    `static Class<?>` | `loadUserClass(String name, ResourceManager rm)`
    `static Class<?>` | `loadUserClassOrThrow(String name, ResourceManager rm, ResourceSpecifier aSpecifier)`
    `void` | `resolveAndValidateResourceDependencies(ExternalResourceDependency[] aDependencies, String aQualifiedContextName)` Resolves a component's external resource dependencies (bindings) using this resource manager.
    `URL` | `resolveRelativePath(String aRelativePath)` Attempts to resolve a relative path to an absolute path using the same mechanism that the ResourceManager uses to find resources -- a lookup in the datapath followed by a lookup in the classpath.
    `void` | `setCasManager(CasManager aCasManager)` Sets the CasManager, which manages the creation and pooling of CASes.
    `void` | `setDataPath(String aPath)` Sets the data path used to resolve relative paths.
    `void` | `setExtensionClassPath(ClassLoader parent, String classpath, boolean resolveResource)` Sets the classpath for the UIMA extension ClassLoader and specifies if the extension ClassLoader should also be used to resolve resources.
    `void` | `setExtensionClassPath(String classpath, boolean resolveResource)` /**
    `void` | `setExtensionClassPath(org.apache.uima.internal.util.UIMAClassLoader uimaCL, boolean resolveResource)` Support reusing UIMA Class Loader instances to speed up things including the Component Description Editor when obtaining info from CustomResourceSpecifiers https://issues.apache.org/jira/browse/UIMA-1722

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### LOG_RESOURCE_BUNDLE

          protected static final String LOG_RESOURCE_BUNDLE

      resource bundle for log messages
      See Also:
        Constant Field Values

    - #### EMPTY_RESOURCE_CLASS

          protected static final Class<Resource> EMPTY_RESOURCE_CLASS

    - #### mResourceMap

          protected final Map<String,Object> mResourceMap

      Map from qualified key names (declared in resource dependency XML) to either DataResource objects or SharedResourceObjects that impl Resource. This map is many to one (multiple keys may refer to the same Resource object) Can't be concurrentMap because it (currently) depends on storing nulls Keeping the Map's 2nd argument as Object, although it could be Resource, for backwards compatibility

    - #### mInternalResourceRegistrationMap

          protected final Map<String,ResourceManager_impl.ResourceRegistration> mInternalResourceRegistrationMap

      Internal map from resource names (declared in resource declaration XML) to ResourceRegistration objects. Uses: for detecting if multiple declarations are made for the same resource name .values() for list of all resources that have been registered This is a one-to-one map.

    - #### mParameterizedResourceImplClassMap

          protected final Map<String,Class<?>> mParameterizedResourceImplClassMap

      Map from String keys to Class objects. For ParameterizedResources only, stores the implementation class (not a Resource) corresponding to each resource name. These class objects may or may not be Resource instances. They may be arbitrary classes, except that they must implement SharedResourceObject. This is a many to one map; many keys may refer to the same class key = aQualifiedContextName + the key name in an external resource binding

    - #### mInternalParameterizedResourceImplClassMap

          protected final Map<String,Class<?>> mInternalParameterizedResourceImplClassMap

      Internal map from resource names (declared in resource declaration XML) to Class objects for parameterized Resource. These class objects may or may not be Resource instances. They may be arbitrary classes, except that they must implement SharedResourceObject. These are "customized" when referenced, by parameter strings (such as language, for a Dictionary resource). Used internally during resource initialization. key = external resource declared name.

    - #### mParameterizedResourceInstanceMap

          protected final Map<List<Object>,Object> mParameterizedResourceInstanceMap

      Map from ParameterizedResourceKey to SharedResourceObject or DataResource instances. Note: SharedResourceObjects are not "Resource" instances, but rather arbitrary Java classes that are the "implementations" of Resources. The only requirement on these Java classes is that they implement SharedResourceObject interface. This map is for ParameterizedResources only, and stores the SharedResourceObjects or DataResource objects that have already been instantiated and loaded.

    - #### mCasManager

          protected volatile CasManager mCasManager

      CasManager - manages creation and pooling of CASes.

  - ### Constructor Detail

    - #### ResourceManager_impl

          public ResourceManager_impl()

      Creates a new `ResourceManager_impl`.

    - #### ResourceManager_impl

          public ResourceManager_impl(ClassLoader aClassLoader)

      Creates a new `ResourceManager_impl` with a custom ClassLoader to use for locating resources.
      Parameters:
        `aClassLoader` - -

    - #### ResourceManager_impl

          public ResourceManager_impl(Map<String,Object> resourceMap,
                                      Map<String,ResourceManager_impl.ResourceRegistration> internalResourceRegistrationMap,
                                      Map<String,Class<?>> parameterizedResourceImplClassMap,
                                      Map<String,Class<?>> internalParameterizedResourceImplClassMap,
                                      Map<List<Object>,Object> parameterizedResourceInstanceMap)

  - ### Method Detail

    - #### copy

          public ResourceManager_impl copy()

    - #### setExtensionClassPath

          public void setExtensionClassPath(org.apache.uima.internal.util.UIMAClassLoader uimaCL,
                                            boolean resolveResource)

      Support reusing UIMA Class Loader instances to speed up things including the Component Description Editor when obtaining info from CustomResourceSpecifiers https://issues.apache.org/jira/browse/UIMA-1722
      Parameters:
        `uimaCL` - -
        `resolveResource` - -

    - #### setExtensionClassPath

          public void setExtensionClassPath(String classpath,
                                            boolean resolveResource)
                                     throws MalformedURLException

      /**
      Specified by:
        `setExtensionClassPath` in interface `ResourceManager`
      Parameters:
        `classpath` - extension ClassLoader classpath
        `resolveResource` - if true ClassLoad resolves resources
      Throws:
        `MalformedURLException` - if a malformed URL has occurred in the classpath string.
      See Also:
        `ResourceManager.setExtensionClassPath(java.lang.String, boolean)`

    - #### setExtensionClassPath

          public void setExtensionClassPath(ClassLoader parent,
                                            String classpath,
                                            boolean resolveResource)
                                     throws MalformedURLException

      Description copied from interface: `ResourceManager`
      Sets the classpath for the UIMA extension ClassLoader and specifies if the extension ClassLoader should also be used to resolve resources. Also allows a parent ClassLoader to be specified.
      Specified by:
        `setExtensionClassPath` in interface `ResourceManager`
      Parameters:
        `parent` - parent ClassLoader for the extension ClassLoader
        `classpath` - extension ClassLoader classpath
        `resolveResource` - if true ClassLoad resolves resources
      Throws:
        `MalformedURLException` - if a malformed URL has occurred in the classpath string.
      See Also:
        `ResourceManager.setExtensionClassPath(ClassLoader,java.lang.String, boolean)`

    - #### getExtensionClassLoader

          public ClassLoader getExtensionClassLoader()

      Description copied from interface: `ResourceManager`
      Returns the UIMA extension class loader.
      Specified by:
        `getExtensionClassLoader` in interface `ResourceManager`
      Returns:
        ClassLoader - returns the UIMA extension class loader of null if it is not available.
      See Also:
        `ResourceManager.getExtensionClassLoader()`

    - #### getDataPath

          public String getDataPath()

      Description copied from interface: `ResourceManager`
      Gets the data path used to resolve relative paths. More than one directory may be specified by separating them with the System `path.separator` character (; on windows, : on UNIX).
      Specified by:
        `getDataPath` in interface `ResourceManager`
      Returns:
        the data path
      See Also:
        `ResourceManager.getDataPath()`

    - #### setDataPath

          public void setDataPath(String aPath)
                           throws MalformedURLException

      Description copied from interface: `ResourceManager`
      Sets the data path used to resolve relative paths. More than one directory may be specified by separating them with the System `path.separator` character (; on windows, : on UNIX). The elements of this path may be URLs or File paths.
      Specified by:
        `setDataPath` in interface `ResourceManager`
      Parameters:
        `aPath` - the data path
      Throws:
        `MalformedURLException` - if an element of the path is neither a valid URL or a valid file path
      See Also:
        `ResourceManager.setDataPath(String)`

    - #### resolveRelativePath

          public URL resolveRelativePath(String aRelativePath)
                                  throws MalformedURLException

      Description copied from interface: `ResourceManager`
      Attempts to resolve a relative path to an absolute path using the same mechanism that the ResourceManager uses to find resources -- a lookup in the datapath followed by a lookup in the classpath.
      Specified by:
        `resolveRelativePath` in interface `ResourceManager`
      Parameters:
        `aRelativePath` - a relative URL or file path
      Returns:
        the absolute URL of an actual file in the datapath or classpath, null if no file matching `aRelativePath` is found.
      Throws:
        `MalformedURLException` - if the path cannot be converted to a URL

    - #### getResource

          public Object getResource(String aName)
                             throws ResourceAccessException

      Description copied from interface: `ResourceManager`
      Gets the instance of the implementation object for a resource that has been registered under the specified name.
      Specified by:
        `getResource` in interface `ResourceManager`
      Parameters:
        `aName` - the name of the resource to retrieve
      Returns:
        the instance of the implementation object for the resource, registered under `aName`, `null` if none exists.
      Throws:
        `ResourceAccessException` - if the requested resource could not be initialized. A common cause is that it requires parameters and the `ResourceManager.getResource(String,String[])` method should have been called instead of this method.
      See Also:
        `ResourceManager.getResource(String)`

    - #### getResource

          public Object getResource(String aName,
                                    String[] aParams)
                             throws ResourceAccessException

      Description copied from interface: `ResourceManager`
      Returns one of two kinds of objects (or null): - an instance of the implementation object for a resource, that has been loaded with a DataResource resource produced by the resource given the aParms - (if there is no implementation defined for this resource) returns an instance of the DataResource, itself, produced by the resource given the aParms An example of a parameterized Resource is a dictionary whose data depend on a specified language identifier. If the implementation object class exists, but no instance has been created (yet) for the particular data resource corresponding to the parameters, then this method will create and register a new instance and call its load() api using the data resource corresponding to the parameters, and return that.
      Specified by:
        `getResource` in interface `ResourceManager`
      Parameters:
        `aName` - the name of the parameterized resource to retrieve
        `aParams` - the parameters determining which particular instance is returned and specifying a particular DataResource instance to use in initializing the implementation of the resource (if there is an implementation). If there is no implementation, the DataResource instance produced from the named Resource given these parameters is returned instead.
      Returns:
        one of two kinds of objects (or null): an instance of the requested implementation of the named resource where that instance has been initialized by calling its load method with the DataResource instance produced from the Resource given aParams, or, (if the named resource has no implementation) the DataResource instance corresponding to the named Resource, given aParams, or if no resource with this name exists, `null`.
      Throws:
        `ResourceAccessException` - if there is a resource registered under `aName` but it could not be instantiated for the specified parameters.
      See Also:
        `ResourceManager.getResource(java.lang.String, java.lang.String[])`

    - #### getResourceClass

          public Class<?> getResourceClass(String aName)

      Description copied from interface: `ResourceManager`
      Gets the Class of the Resource that will be returned by a call to `ResourceManager.getResource(String)` or `ResourceManager.getResource(String,String[])`. For those resource specifications which include an implementation class, this call returns that class.
      Specified by:
        `getResourceClass` in interface `ResourceManager`
      Parameters:
        `aName` - the name of a resource
      Returns:
        the Class for the resource named `aName`, `null` if there is no resource registered under that name.
      See Also:
        `ResourceManager.getResourceClass(java.lang.String)`

    - #### getResourceAsStream

          public InputStream getResourceAsStream(String aKey,
                                                 String[] aParams)
                                          throws ResourceAccessException

      Description copied from interface: `ResourceManager`
      Retrieves an InputStream for reading from the named resource. This can be used, for example, to read configuration or authority files. This version of this method takes an array of parameters used to further identify the resource. This can be used, for example, with resources that vary depending on the language of the document being analyzed.
      Specified by:
        `getResourceAsStream` in interface `ResourceManager`
      Parameters:
        `aKey` - the key by which the resource is identified. If this key was declared in the <externalResourceDependencies> section of the annotator's descriptor, then the resource manager is used to locate the resource. If not, the key is assumed to be the resource name and is looked up in the `data path` or in the class path using `ClassLoader.getResource(String)`.
        `aParams` - parameters used to further identify the resource
      Returns:
        an `InputStream` for reading from the named resource, `null` if the named resource could not be found. It is the caller's responsibility to close this stream once it is no longer needed.
      Throws:
        `ResourceAccessException` - if a failure occurs in accessing the resource

    - #### getResourceAsStream

          public InputStream getResourceAsStream(String aKey)
                                          throws ResourceAccessException

      Description copied from interface: `ResourceManager`
      Retrieves an InputStream for reading from the named resource. This can be used, for example, to read configuration or authority files.
      Specified by:
        `getResourceAsStream` in interface `ResourceManager`
      Parameters:
        `aKey` - the key by which the resource is identified. If this key was declared in the <externalResourceDependencies> section of the annotator's descriptor, then the resource manager is used to locate the resource. If not, the key is assumed to be the resource name and is looked up in the `data path` or in the class path using `ClassLoader.getResource(String)`.
      Returns:
        an `InputStream` for reading from the named resource, `null` if the named resource could not be found. It is the caller's responsibility to close this stream once it is no longer needed.
      Throws:
        `ResourceAccessException` - if a failure occurs in accessing the resource

    - #### getResourceURL

          public URL getResourceURL(String aKey,
                                    String[] aParams)
                             throws ResourceAccessException

      Description copied from interface: `ResourceManager`
      Retrieves the URL to the named resource. This can be used, for example, to locate configuration or authority files. This version of this method takes an array of parameters used to further identify the resource. This can be used, for example, with resources that vary depending on the language of the document being analyzed.
      Specified by:
        `getResourceURL` in interface `ResourceManager`
      Parameters:
        `aKey` - the key by which the resource is identified. If this key was declared in the <externalResourceDependencies> section of the annotator's descriptor, then the resource manager is used to locate the resource. If not, the key is assumed to be the resource name and is looked up in the `data path` or in the class path using `ClassLoader.getResource(String)`.
        `aParams` - parameters used to further identify the resource
      Returns:
        the `URL` at which the named resource is located, `null` if the named resource could not be found.
      Throws:
        `ResourceAccessException` - if a failure occurs in accessing the resource

    - #### getResourceURL

          public URL getResourceURL(String aKey)
                             throws ResourceAccessException

      Description copied from interface: `ResourceManager`
      Retrieves the URL to the named resource. This can be used, for example, to locate configuration or authority files.
      Specified by:
        `getResourceURL` in interface `ResourceManager`
      Parameters:
        `aKey` - the key by which the resource is identified. If this key was declared in the <externalResourceDependencies> section of the descriptor, then the resource manager is used to locate the resource. If not, the key is assumed to be the resource name and is looked up in the `data path` or in the class path using `ClassLoader.getResource(String)`.
      Returns:
        the `URL` at which the named resource is located, `null` if the named resource could not be found.
      Throws:
        `ResourceAccessException` - if a failure occurs in accessing the resource

    - #### initializeExternalResources

          public void initializeExternalResources(ResourceManagerConfiguration aConfiguration,
                                                  String aQualifiedContextName,
                                                  Map<String,Object> aAdditionalParams)
                                           throws ResourceInitializationException

      Description copied from interface: `ResourceManager`
      Initializes all external resources declared in a ResourceCreationSpecifier. Multi-threading: may be called on multiple threads. Initialization should be done once, on the first call External resources have a Container class representing the resource, which are instances of Resource. This may act as the implementation class, or they may also have a separately specified implementation class, which may or may not implement Resource. As part of the initialization of the Container class, by default, External Resource Bindings are processed to hook them up with defined External Resources, using the default implementation of resolveAndValidateResourceDependencies.
      Specified by:
        `initializeExternalResources` in interface `ResourceManager`
      Parameters:
        `aConfiguration` - the ResourceManagerConfiguration containing resource declarations and bindings
        `aQualifiedContextName` - qualified name of UimaContext for the component (e.g. analysis engine) that is declaring these external resources
        `aAdditionalParams` - additional parameters to be passed to resource initialize methods
      Throws:
        `ResourceInitializationException` - if an initialization failure occurs

    - #### resolveAndValidateResourceDependencies

          public void resolveAndValidateResourceDependencies(ExternalResourceDependency[] aDependencies,
                                                             String aQualifiedContextName)
                                                      throws ResourceInitializationException

      Description copied from interface: `ResourceManager`
      Resolves a component's external resource dependencies (bindings) using this resource manager. The default implementation has special defaulting logic: If a binding specifies a non-existing resource, an attempt is made to interpret the key as a file name, looked up using the current context for relative path resolution. - If successfully found, a FileResourceSpecifier is created using the file and used as the implementing class. If no resource can be found at all, then unless the dependency is marked "optional", an ResourceInitializationException is thrown. Multi-threading: may be called on multiple threads, repeatedly for the same set of resources. Implementations should recognize this and skip repeated resolutions.
      Specified by:
        `resolveAndValidateResourceDependencies` in interface `ResourceManager`
      Parameters:
        `aDependencies` - declarations of a component's dependencies on external resources
        `aQualifiedContextName` - qualified name of UimaContext for the component (e.g. analysis engine) that is declaring these dependencies
      Throws:
        `ResourceInitializationException` - if a required dependency is not satisfied

    - #### getCasManager

          public CasManager getCasManager()

      Description copied from interface: `ResourceManager`
      Gets the CasManager, which manages the creation and pooling of CASes.
      Specified by:
        `getCasManager` in interface `ResourceManager`
      Returns:
        the CasManager

    - #### setCasManager

          public void setCasManager(CasManager aCasManager)

      Description copied from interface: `ResourceManager`
      Sets the CasManager, which manages the creation and pooling of CASes. This method does not normally need to be called by an application. It allows a custom CAS Manager implementation to be substituted for the default one, which may be useful when embedding UIMA in other middleware where a different CAS Manager implementation may be desired.

      This method can only be called once, and must be called before creating any AnalysisEngines that use this ResourceManager. An Exception will be thrown if this method is called twice or is called after `ResourceManager.getCasManager()` has already been called (which happens during AE initialization).

      Specified by:
        `setCasManager` in interface `ResourceManager`
      Parameters:
        `aCasManager` - CAS Manager instance to plug in

    - #### getRelativePathResolver

          protected RelativePathResolver getRelativePathResolver()

    - #### getImportCache

          public Map<String,XMLizable> getImportCache()

      Description copied from interface: `ResourceManager`
      Gets a cache of imported descriptors, so that the parsed objects can be reused if the same URL is imported more than once.
      Specified by:
        `getImportCache` in interface `ResourceManager`
      Returns:
        A map from absolute URL to the XMLizable object that was parsed from that URL

    - #### getImportUrlsCache

          public Map<String,Set<String>> getImportUrlsCache()

    - #### loadUserClass

          public <N> Class<N> loadUserClass(String name)
                                     throws ClassNotFoundException

      Description copied from interface: `ResourceManager`
      Loads a user class using either the UIMA extension class loader (if specified) or the ThreadLocal Context Class Loader (if available) or the loader the UIMA framework is running in. If the class is not found in the ThreadLocal COntext Class Loader, then the loader the UIMA framework is running in will be searched.
      Specified by:
        `loadUserClass` in interface `ResourceManager`
      Type Parameters:
        `N` - the generic type for the returned class
      Parameters:
        `name` - the class to load
      Returns:
        the class
      Throws:
        `ClassNotFoundException` - -

    - #### loadUserClass

          public static Class<?> loadUserClass(String name,
                                               ResourceManager rm)
                                        throws ClassNotFoundException

      Throws:
        `ClassNotFoundException`

    - #### loadUserClassOrThrow

          public static Class<?> loadUserClassOrThrow(String name,
                                                      ResourceManager rm,
                                                      ResourceSpecifier aSpecifier)
                                               throws ResourceInitializationException

      Throws:
        `ResourceInitializationException`

    - #### destroy

          public void destroy()

      Description copied from interface: `ResourceManager`
      Frees all resources held by this ResourceManager, and marks the ResourceManager as having been destroyed. A destroyed ResourceManager will throw an exception if an attempt is made to continue using it. Resources managed by a ResourceManager include all of the external shared Resources. If there is an extension class loader in use, it will be closed. Any class loaders (including PEAR class loaders) that might use this as a parent will be affected by this closure. Any streams opened using getResourceAsStream will also be closed. The Resources managed by this manager will have their destroy() methods called, as part of the execution of this API. The framework does not call this method; it is up to the containing application to decide if and when a ResourceManager instance should be destroyed. This is because the containing application is the only knowledgeable source; for example a single ResourceManager might be used for multiple UIMA Pipelines.
      Specified by:
        `destroy` in interface `ResourceManager`

    - #### getExternalResources

          public List<Object> getExternalResources()

      Specified by:
        `getExternalResources` in interface `ResourceManager`
      Returns:
        a List of External Shared Resource instances instantiated by this Resource Manager. For parameterized resources, those which have been asked for (having unique parameter sets) are included.

Copyright © 2006–2021 The Apache Software Foundation. All rights reserved.