org.apache.uima.analysis_engine.impl

## Class PearAnalysisEngineWrapper

- java.lang.Object
- - org.apache.uima.resource.Resource_ImplBase
  - - org.apache.uima.resource.ConfigurableResource_ImplBase
    - - org.apache.uima.analysis_engine.impl.AnalysisEngineImplBase
      - - org.apache.uima.analysis_engine.impl.PearAnalysisEngineWrapper

- All Implemented Interfaces:
    AnalysisEngine, TextAnalysisEngine, CasObjectProcessor, CasProcessor, ConfigurableResource, Resource

      public class PearAnalysisEngineWrapper
      extends AnalysisEngineImplBase

  UIMA pear runtime analysis engine wrapper. With this wrapper implementation it is possible to run installed pear files out of the box in UIMA. Calls to the wrapper that are part of the public APIs of its superclasses are forwarded to the contained AE - this makes it possible to have the pear as a top level component. For instance, if you do an ae.getCas() - it will get a CAS with the type system of the contained ae. Or if you set parameters, it will set parameters of the contained ae.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `PearAnalysisEngineWrapper.StringPair` inner class StringPair

  - ### Field Summary

    - ### Fields inherited from class org.apache.uima.analysis_engine.impl.AnalysisEngineImplBase

      `LOG_RESOURCE_BUNDLE, PARAM_VERIFICATION_MODE`

    - ### Fields inherited from interface org.apache.uima.analysis_engine.AnalysisEngine

      `PARAM_CONFIG_PARAM_SETTINGS, PARAM_MBEAN_NAME_PREFIX, PARAM_MBEAN_SERVER, PARAM_NUM_SIMULTANEOUS_REQUESTS, PARAM_RESOURCE_MANAGER, PARAM_TIMEOUT_PERIOD`

    - ### Fields inherited from interface org.apache.uima.resource.Resource

      `PARAM_AGGREGATE_SOFA_MAPPINGS, PARAM_CONFIG_MANAGER, PARAM_EXTERNAL_OVERRIDE_SETTINGS, PARAM_PERFORMANCE_TUNING_SETTINGS, PARAM_UIMA_CONTEXT`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `PearAnalysisEngineWrapper()`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `batchProcessComplete()` Notifies this AnalysisEngine that processing of a batch has completed.
    `void` | `batchProcessComplete(ProcessTrace trace)` Completes the processing of a batch.
    `protected void` | `buildProcessTraceFromMBeanStats(ProcessTrace trace)` Modify an existing ProcessTrace object by adding events that represent the last excecution of this AnalysisEngine.
    `void` | `collectionProcessComplete()` Notifies this AnalysisEngine that processing of an entire collection has completed.
    `void` | `collectionProcessComplete(ProcessTrace trace)` Completes the processing of an entire collection.
    `ResultSpecification` | `createResultSpecification()` A factory method used to create an instance of `ResultSpecification` for use with this AnalysisEngine.
    `ResultSpecification` | `createResultSpecification(TypeSystem typeSystem)` A factory method used to create an instance of `ResultSpecification` for use with this AnalysisEngine.
    `void` | `destroy()` Releases all resources held by this `Resource`.
    `protected void` | `enterBatchProcessComplete()`
    `protected void` | `enterCollectionProcessComplete()`
    `protected void` | `enterProcess()`
    `protected void` | `exitBatchProcessComplete()`
    `protected void` | `exitCollectionProcessComplete()`
    `protected void` | `exitProcess()`
    `AnalysisEngineMetaData` | `getAnalysisEngineMetaData()` Gets the metadata that describes this `AnalysisEngine`.
    `static Map<ResourceManager,Map<PearAnalysisEngineWrapper.StringPair,ResourceManager>>` | `getCachedResourceManagers()`
    `protected String` | `getMBeanNamePrefix()`
    `protected Object` | `getMBeanServer()`
    `ResourceMetaData` | `getMetaData()` Gets the metadata that describes this `Resource`.
    `Properties` | `getPerformanceTuningSettings()` Gets the performance tuning settings in effect for this Analysis Engine.
    `ProcessingResourceMetaData` | `getProcessingResourceMetaData()` Gets the metadata that describes this `CasProcesor`.
    `UimaContext` | `getUimaContext()` Gets the UIMA Context for this Resource.
    `UimaContextAdmin` | `getUimaContextAdmin()` Gets the Admin interface to this Resource's UimaContext.
    `boolean` | `initialize(ResourceSpecifier aSpecifier, Map<String,Object> aAdditionalParams)` Initializes this `Resource` from a `ResourceSpecifier`.
    `protected boolean` | `isProcessTraceEnabled()` Gets whether the Process Trace (which collects performance stats for this AnalysisEngine) is enabled.
    `CAS` | `newCAS()` Creates a new Common Analysis System appropriate for this Analysis Engine.
    `CasIterator` | `processAndOutputNewCASes(CAS aCAS)` Processes a CAS, possibly producing multiple CASes as a result.
    `void` | `reconfigure()` Instructs this Resource to re-read its configuration parameter settings.
    `protected void` | `setMetaData(ResourceMetaData aMetaData)` Sets the `ResourceMetaData` object associated with this `Resource`.
    `protected void` | `setPerformanceTuningSettings(Properties aSettings)` Sets the performance tuning settings in effect for this Analysis Engine.
    `void` | `setResultSpecification(ResultSpecification resultSpec)` Sets the list of output types and features that the application wants this AnalysisEngine to produce.
    `void` | `typeSystemInit(TypeSystem typeSystem)` From the CAS Processor interface.

    - ### Methods inherited from class org.apache.uima.analysis_engine.impl.AnalysisEngineImplBase

      `buildProcessTraceFromMBeanStats, finalize, getCurrentConfigParameterSettings, getFeatureNamesForType, getManagementInterface, getMBean, isReadOnly, isStateless, newJCas, normalizeIsoLangCodes, process, process, process, process, process, process, process, processAndOutputNewCASes, processCas, processCas, resetResultSpecificationToDefault`

    - ### Methods inherited from class org.apache.uima.resource.ConfigurableResource_ImplBase

      `getConfigParameterValue, getConfigParameterValue, setConfigParameterValue, setConfigParameterValue`

    - ### Methods inherited from class org.apache.uima.resource.Resource_ImplBase

      `getCasManager, getLogger, getRelativePathResolver, getResourceManager, setLogger`

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

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

    - ### Methods inherited from interface org.apache.uima.analysis_engine.AnalysisEngine

      `getLogger, getResourceManager, setLogger`

    - ### Methods inherited from interface org.apache.uima.resource.ConfigurableResource

      `getConfigParameterValue, getConfigParameterValue, setConfigParameterValue, setConfigParameterValue`

- - ### Constructor Detail

    - #### PearAnalysisEngineWrapper

          public PearAnalysisEngineWrapper()

  - ### Method Detail

    - #### initialize

          public boolean initialize(ResourceSpecifier aSpecifier,
                                    Map<String,Object> aAdditionalParams)
                             throws ResourceInitializationException

      Description copied from interface: `Resource`
      Initializes this `Resource` from a `ResourceSpecifier`. Applications do not need to call this method. It is called automatically by the `ResourceFactory` and cannot be called a second time.
      Specified by:
        `initialize` in interface `AnalysisEngine`
      Specified by:
        `initialize` in interface `Resource`
      Overrides:
        `initialize` in class `AnalysisEngineImplBase`
      Parameters:
        `aSpecifier` - specifies how to create a resource or locate an existing resource service.
        `aAdditionalParams` - a Map containing additional parameters. May be `null` if there are no parameters. Each class that implements this interface can decide what additional parameters it supports.
      Returns:
        true if and only if initialization completed successfully. Reutrns false if the given `ResourceSpecifier` is not of an appropriate type for this Resource. If the `ResourceSpecifier` is of an appropriate type but is invalid or if some other failure occurs, an exception should be thrown.
      Throws:
        `ResourceInitializationException` - if a failure occurs during initialization.
      See Also:
        `multi-thread safe, given that each instance of this class is only called on one thread, once. The critical parts that update shared information (in shared uima context) are inside a synchronize block`

    - #### getAnalysisEngineMetaData

          public AnalysisEngineMetaData getAnalysisEngineMetaData()

      Description copied from interface: `AnalysisEngine`
      Gets the metadata that describes this `AnalysisEngine`. This is just a convenience method that calls `Resource.getMetaData()` and casts the result to a `AnalysisEngineMetaData`.
      Specified by:
        `getAnalysisEngineMetaData` in interface `AnalysisEngine`
      Overrides:
        `getAnalysisEngineMetaData` in class `AnalysisEngineImplBase`
      Returns:
        an object containing all metadata for this AnalysisEngine
      See Also:
        `AnalysisEngine.getAnalysisEngineMetaData()`

    - #### getMetaData

          public ResourceMetaData getMetaData()

      Description copied from interface: `Resource`
      Gets the metadata that describes this `Resource`.
      Specified by:
        `getMetaData` in interface `Resource`
      Overrides:
        `getMetaData` in class `Resource_ImplBase`
      Returns:
        an object containing all metadata for this resource.
      See Also:
        `Resource.getMetaData()`

    - #### batchProcessComplete

          public void batchProcessComplete()
                                    throws AnalysisEngineProcessException

      Description copied from interface: `AnalysisEngine`
      Notifies this AnalysisEngine that processing of a batch has completed. It is up to the caller to determine the size of a batch. Components (particularly CAS Consumers) inside this Analysis Engine may respond to this event, for example by writing data to the disk.
      Specified by:
        `batchProcessComplete` in interface `AnalysisEngine`
      Overrides:
        `batchProcessComplete` in class `AnalysisEngineImplBase`
      Throws:
        `AnalysisEngineProcessException` - if an exception occurs during processing

    - #### collectionProcessComplete

          public void collectionProcessComplete()
                                         throws AnalysisEngineProcessException

      Description copied from interface: `AnalysisEngine`
      Notifies this AnalysisEngine that processing of an entire collection has completed. It is up to the caller to determine when this has occurred. Components (particularly CAS Consumers) inside this Analysis Engine may respond to this event, for example by writing data to the disk.

      If this AnalysisEngine is an aggregate, this method will call the collectionProcessComplete method of all components of that aggregate. If the aggregate descriptor declares a `fixedFlow` or `capabilityLanguageFlow`, then the components' collectionProcessComplete methods will be called in the order specified by that flow element. Once all components in the flow have been called, any components not declared in the flow will be called, in arbitrary order. If there is no `fixedFlow` or `capabilityLanguageFlow`, then all components in the aggregate will be called in arbitrary order.

      Specified by:
        `collectionProcessComplete` in interface `AnalysisEngine`
      Overrides:
        `collectionProcessComplete` in class `AnalysisEngineImplBase`
      Throws:
        `AnalysisEngineProcessException` - if an exception occurs during processing

    - #### processAndOutputNewCASes

          public CasIterator processAndOutputNewCASes(CAS aCAS)
                                               throws AnalysisEngineProcessException

      Description copied from interface: `AnalysisEngine`
      Processes a CAS, possibly producing multiple CASes as a result. The application uses the `CasIterator` interface to step through the output CASes.

      If this Analysis Engine does not produce output CASes, then the `CasIterator` will return no elements. You can check if an AnalysisEngine is capable of producing output CASes by checking the `OperationalProperties.getOutputsNewCASes()` operational property (`getAnalysisEngineMetaData().getOperationalProperties().getOutputsNewCASes()`).

      Once this method is called, the AnalysisEngine "owns" `aCAS` until such time as the `CasIterator.hasNext()` method returns false. That is, the caller should not attempt to modify or access the input CAS until it has read all of the elements from the CasIterator. If the caller wants to abort the processing before having read all of the output CASes, it may call `CasIterator.release()`, which will stop further processing from occurring, and ownership of `aCAS` will revert to the caller.

      Specified by:
        `processAndOutputNewCASes` in interface `AnalysisEngine`
      Overrides:
        `processAndOutputNewCASes` in class `AnalysisEngineImplBase`
      Parameters:
        `aCAS` - the CAS to be processed
      Returns:
        an object for iterating through any output CASes
      Throws:
        `AnalysisEngineProcessException` - if a failure occurs during processing

    - #### destroy

          public void destroy()

      Description copied from interface: `Resource`
      Releases all resources held by this `Resource`.
      Specified by:
        `destroy` in interface `Resource`
      Overrides:
        `destroy` in class `Resource_ImplBase`
      See Also:
        `Resource.destroy()`

    - #### reconfigure

          public void reconfigure()
                           throws ResourceConfigurationException

      Description copied from interface: `ConfigurableResource`
      Instructs this Resource to re-read its configuration parameter settings.
      Specified by:
        `reconfigure` in interface `AnalysisEngine`
      Specified by:
        `reconfigure` in interface `ConfigurableResource`
      Overrides:
        `reconfigure` in class `ConfigurableResource_ImplBase`
      Throws:
        `ResourceConfigurationException` - if the configuration is not valid
      See Also:
        `ConfigurableResource.reconfigure()`

    - #### buildProcessTraceFromMBeanStats

          protected void buildProcessTraceFromMBeanStats(ProcessTrace trace)

      Description copied from class: `AnalysisEngineImplBase`
      Modify an existing ProcessTrace object by adding events that represent the last excecution of this AnalysisEngine. This is used so that we can return a ProcessTrace object from each process() call for backwards compatibility with version 1.x.
      Overrides:
        `buildProcessTraceFromMBeanStats` in class `AnalysisEngineImplBase`
      Parameters:
        `trace` - -

    - #### enterBatchProcessComplete

          protected void enterBatchProcessComplete()

      Overrides:
        `enterBatchProcessComplete` in class `AnalysisEngineImplBase`

    - #### enterCollectionProcessComplete

          protected void enterCollectionProcessComplete()

      Overrides:
        `enterCollectionProcessComplete` in class `AnalysisEngineImplBase`

    - #### enterProcess

          protected void enterProcess()

      Overrides:
        `enterProcess` in class `AnalysisEngineImplBase`

    - #### exitBatchProcessComplete

          protected void exitBatchProcessComplete()

      Overrides:
        `exitBatchProcessComplete` in class `AnalysisEngineImplBase`

    - #### exitCollectionProcessComplete

          protected void exitCollectionProcessComplete()

      Overrides:
        `exitCollectionProcessComplete` in class `AnalysisEngineImplBase`

    - #### exitProcess

          protected void exitProcess()

      Overrides:
        `exitProcess` in class `AnalysisEngineImplBase`

    - #### getMBeanNamePrefix

          protected String getMBeanNamePrefix()

      Overrides:
        `getMBeanNamePrefix` in class `AnalysisEngineImplBase`

    - #### getMBeanServer

          protected Object getMBeanServer()

      Overrides:
        `getMBeanServer` in class `AnalysisEngineImplBase`

    - #### getPerformanceTuningSettings

          public Properties getPerformanceTuningSettings()

      Description copied from class: `AnalysisEngineImplBase`
      Gets the performance tuning settings in effect for this Analysis Engine.
      Specified by:
        `getPerformanceTuningSettings` in interface `AnalysisEngine`
      Overrides:
        `getPerformanceTuningSettings` in class `AnalysisEngineImplBase`
      Returns:
        performance tuning settings

    - #### isProcessTraceEnabled

          protected boolean isProcessTraceEnabled()

      Description copied from class: `AnalysisEngineImplBase`
      Gets whether the Process Trace (which collects performance stats for this AnalysisEngine) is enabled. This is controlled through the PerformanceTuningSettings passed to the initialize() method.
      Overrides:
        `isProcessTraceEnabled` in class `AnalysisEngineImplBase`
      Returns:
        true if the ProcessTrace is enabled, false if not.

    - #### setPerformanceTuningSettings

          protected void setPerformanceTuningSettings(Properties aSettings)

      Description copied from class: `AnalysisEngineImplBase`
      Sets the performance tuning settings in effect for this Analysis Engine. This should be set from the initialize() method if the defaults are to be overriden.
      Overrides:
        `setPerformanceTuningSettings` in class `AnalysisEngineImplBase`
      Parameters:
        `aSettings` - performance tuning settings

    - #### getUimaContext

          public UimaContext getUimaContext()

      Description copied from interface: `Resource`
      Gets the UIMA Context for this Resource. This can be used to access external resources or facilities such as the Logger.
      Specified by:
        `getUimaContext` in interface `Resource`
      Overrides:
        `getUimaContext` in class `Resource_ImplBase`
      Returns:
        the UimaContext for use by this Resource

    - #### getUimaContextAdmin

          public UimaContextAdmin getUimaContextAdmin()

      Description copied from class: `Resource_ImplBase`
      Gets the Admin interface to this Resource's UimaContext.
      Specified by:
        `getUimaContextAdmin` in interface `Resource`
      Overrides:
        `getUimaContextAdmin` in class `Resource_ImplBase`
      Returns:
        the administrative interface to this Resource's UimaContext

    - #### setMetaData

          protected void setMetaData(ResourceMetaData aMetaData)

      Description copied from class: `Resource_ImplBase`
      Sets the `ResourceMetaData` object associated with this `Resource`. Any previously existing metadata will be replaced.

      Resource subclasses should call this method during initialization in order to set the metadata before any calls to `Resource_ImplBase.getMetaData()` are made.

      Overrides:
        `setMetaData` in class `AnalysisEngineImplBase`
      Parameters:
        `aMetaData` - metadata to assign to this `Resource`

    - #### setResultSpecification

          public void setResultSpecification(ResultSpecification resultSpec)

      Description copied from interface: `AnalysisEngine`
      Sets the list of output types and features that the application wants this AnalysisEngine to produce. This is only a guideline. Annotators may use this information to avoid doing unnecessary work, but they are not required to do so.
      Specified by:
        `setResultSpecification` in interface `AnalysisEngine`
      Overrides:
        `setResultSpecification` in class `AnalysisEngineImplBase`
      Parameters:
        `resultSpec` - specifies the list of output types and features that the application is interested in.

    - #### batchProcessComplete

          public void batchProcessComplete(ProcessTrace trace)
                                    throws ResourceProcessException,
                                           IOException

      Description copied from interface: `CasProcessor`
      Completes the processing of a batch. A collection may be divided into one or more batches - it is up to the CollectionProcessingManager or the application to determine the number and size of batches.
      Specified by:
        `batchProcessComplete` in interface `CasProcessor`
      Overrides:
        `batchProcessComplete` in class `AnalysisEngineImplBase`
      Parameters:
        `trace` - an object that records information, such as timing, about this method's execution.
      Throws:
        `ResourceProcessException` - if an exception occurs during processing
        `IOException` - if an I/O failure occurs

    - #### collectionProcessComplete

          public void collectionProcessComplete(ProcessTrace trace)
                                         throws ResourceProcessException,
                                                IOException

      Description copied from interface: `CasProcessor`
      Completes the processing of an entire collection.
      Specified by:
        `collectionProcessComplete` in interface `CasProcessor`
      Overrides:
        `collectionProcessComplete` in class `AnalysisEngineImplBase`
      Parameters:
        `trace` - an object that records information, such as timing, about this method's execution.
      Throws:
        `ResourceProcessException` - if an exception occurs during processing
        `IOException` - if an I/O failure occurs

    - #### createResultSpecification

          public ResultSpecification createResultSpecification()

      Description copied from interface: `AnalysisEngine`

      A factory method used to create an instance of `ResultSpecification` for use with this AnalysisEngine. Applications use this method to construct `ResultSpecification`s to pass to this AnalysisEngine's `AnalysisEngine.setResultSpecification(ResultSpecification)` method.

      See also `AnalysisEngine.createResultSpecification(TypeSystem)` which should be used if the type system associated with this result specification is known at this point in time.

      Specified by:
        `createResultSpecification` in interface `AnalysisEngine`
      Overrides:
        `createResultSpecification` in class `AnalysisEngineImplBase`
      Returns:
        a new instance of `ResultSpecification`
      See Also:
        `AnalysisEngine.createResultSpecification()`

    - #### createResultSpecification

          public ResultSpecification createResultSpecification(TypeSystem typeSystem)

      Description copied from interface: `AnalysisEngine`
      A factory method used to create an instance of `ResultSpecification` for use with this AnalysisEngine. Applications use this method to construct `ResultSpecification`s to pass to this AnalysisEngine's `AnalysisEngine.setResultSpecification(ResultSpecification)` method.
      Specified by:
        `createResultSpecification` in interface `AnalysisEngine`
      Overrides:
        `createResultSpecification` in class `AnalysisEngineImplBase`
      Parameters:
        `typeSystem` - the type system
      Returns:
        a new instance of `ResultSpecification`
      See Also:
        `AnalysisEngine.createResultSpecification(TypeSystem)`

    - #### getProcessingResourceMetaData

          public ProcessingResourceMetaData getProcessingResourceMetaData()

      Description copied from interface: `CasProcessor`
      Gets the metadata that describes this `CasProcesor`.
      Specified by:
        `getProcessingResourceMetaData` in interface `CasProcessor`
      Overrides:
        `getProcessingResourceMetaData` in class `AnalysisEngineImplBase`
      Returns:
        an object containing all metadata for this CasProcessor
      See Also:
        `CasProcessor.getProcessingResourceMetaData()`

    - #### newCAS

          public CAS newCAS()
                     throws ResourceInitializationException

      Description copied from interface: `AnalysisEngine`
      Creates a new Common Analysis System appropriate for this Analysis Engine. An application can pre-populate this CAS, then pass it to the `AnalysisEngine.process(CAS)` method. Then, when the process method returns, the CAS will contain the results of the analysis.

      Important: CAS creation is expensive, so if at all possible an application should reuse CASes. When a CAS instance is no longer being used, call its `CAS.reset()` method, which will remove all prior analysis information, and then reuse that same CAS instance for another call to `AnalysisEngine.process(CAS)`.

      Note that the CAS allows multiple subjects of analysis (e.g. documents) and defines a separate "view" for each of them. If your application wants to work with a single subject of analysis, call the method `CAS.getCurrentView()` and operate on the returned view.

      Specified by:
        `newCAS` in interface `AnalysisEngine`
      Overrides:
        `newCAS` in class `AnalysisEngineImplBase`
      Returns:
        a new `CAS` appropriate for this AnalysisEngine.
      Throws:
        `ResourceInitializationException` - if a CAS could not be created because this AnalysisEngine's CAS metadata (type system, type priorities, or FS indexes) are invalid. Ideally this would be checked at AnalysisEngine initialization time, and it will likely be moved in the future.
      See Also:
        `AnalysisEngine.newCAS()`

    - #### typeSystemInit

          public void typeSystemInit(TypeSystem typeSystem)
                              throws ResourceInitializationException

      Description copied from class: `AnalysisEngineImplBase`
      From the CAS Processor interface. Called by the CPM if the CAS type system changes - this does not need to do anything since the annotators' typeSystemInit methods are automatically called prior to processing whenever it is necessary.
      Specified by:
        `typeSystemInit` in interface `CasObjectProcessor`
      Overrides:
        `typeSystemInit` in class `AnalysisEngineImplBase`
      Parameters:
        `typeSystem` - the type system to use
      Throws:
        `ResourceInitializationException` - if the type system is not compatible with this Cas Consumer
      See Also:
        `CasObjectProcessor.typeSystemInit(org.apache.uima.cas.TypeSystem)`

    - #### getCachedResourceManagers

          public static Map<ResourceManager,Map<PearAnalysisEngineWrapper.StringPair,ResourceManager>> getCachedResourceManagers()

      Returns:
        the cachedResourceManagers

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