org.apache.uima.analysis_engine.impl

## Class AnalysisEngineImplBase

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

- All Implemented Interfaces:
    AnalysisEngine, TextAnalysisEngine, CasObjectProcessor, CasProcessor, ConfigurableResource, Resource
  Direct Known Subclasses:
    AggregateAnalysisEngine_impl, AnalysisEngineProcessorAdapter, AnalysisEngineServiceAdapter, MultiprocessingAnalysisEngine_impl, PearAnalysisEngineWrapper, PrimitiveAnalysisEngine_impl, UimacppAnalysisEngineImpl

      public abstract class AnalysisEngineImplBase
      extends ConfigurableResource_ImplBase
      implements TextAnalysisEngine

  Provides functionality common to Analysis Engine implementations.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected static String` | `LOG_RESOURCE_BUNDLE` resource bundle for log messages
    `static String` | `PARAM_VERIFICATION_MODE` Key that must be inserted into the aAdditionalParams map to turn on verification mode.

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

      `MDC_ANNOTATOR_CONTEXT_NAME, MDC_ANNOTATOR_IMPL_NAME, MDC_CAS_ID, MDC_ROOT_CONTEXT_ID, PARAM_CONFIG_PARAM_SETTINGS, PARAM_MBEAN_NAME_PREFIX, PARAM_MBEAN_SERVER, PARAM_NUM_SIMULTANEOUS_REQUESTS, PARAM_RESOURCE_MANAGER, PARAM_THROTTLE_EXCESSIVE_ANNOTATOR_LOGGING, 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
    `AnalysisEngineImplBase()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `batchProcessComplete()` Notifies this AnalysisEngine that processing of a batch has completed.
    `void` | `batchProcessComplete(ProcessTrace aTrace)` Completes the processing of a batch.
    `protected ProcessTrace` | `buildProcessTraceFromMBeanStats()`
    `protected void` | `buildProcessTraceFromMBeanStats(ProcessTrace trace)` Modify an existing ProcessTrace object by adding events that represent the last excecution of this AnalysisEngine.
    `protected void` | `callInitializeMethod(AnalysisComponent component, UimaContext context)`
    `protected void` | `callProcessMethod(AnalysisComponent component, AbstractCas cas)`
    `void` | `collectionProcessComplete()` Notifies this AnalysisEngine that processing of an entire collection has completed.
    `void` | `collectionProcessComplete(ProcessTrace aTrace)` 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 aTypeSystem)` A factory method used to create an instance of `ResultSpecification` for use with this AnalysisEngine.
    `protected void` | `enterBatchProcessComplete()`
    `protected void` | `enterCollectionProcessComplete()`
    `protected void` | `enterProcess()`
    `protected void` | `exitBatchProcessComplete()`
    `protected void` | `exitCollectionProcessComplete()`
    `protected void` | `exitProcess()`
    `protected void` | `finalize()`
    `AnalysisEngineMetaData` | `getAnalysisEngineMetaData()` Gets the metadata that describes this `AnalysisEngine`.
    `protected ConfigurationParameterSettings` | `getCurrentConfigParameterSettings()` Kludge - make this public (but not part of AnalysisEngine interface) so that TAFAnnotator can access it.
    `String[]` | `getFeatureNamesForType(String aTypeName)` Gets the names of the features that are defined on one of the CAS types that this AE inputs or outputs.
    `AnalysisEngineManagement` | `getManagementInterface()` Gets an object that can be used to do monitoring or management of this AnalysisEngine.
    `protected AnalysisEngineManagementImpl` | `getMBean()`
    `protected String` | `getMBeanNamePrefix()`
    `protected Object` | `getMBeanServer()`
    `Properties` | `getPerformanceTuningSettings()` Gets the performance tuning settings in effect for this Analysis Engine.
    `ProcessingResourceMetaData` | `getProcessingResourceMetaData()` Gets the metadata that describes this `CasProcesor`.
    `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.
    `boolean` | `isReadOnly()` Gets whether this is a read-only CAS Processor, which does not modify the CAS.
    `boolean` | `isStateless()` Gets whether this is a stateless CAS Processor.
    `CAS` | `newCAS()` Creates a new Common Analysis System appropriate for this Analysis Engine.
    `JCas` | `newJCas()` Similar to `AnalysisEngine.newCAS()` but wraps the new CAS objects with the Java-object-based `JCas` interface.
    `protected void` | `normalizeIsoLangCodes(ProcessingResourceMetaData md)`
    `void` | `process(AnalysisProcessData aProcessData, ResultSpecification aResultSpec)` Deprecated.
    `ProcessTrace` | `process(CAS aCAS)` Invokes this AnalysisEngine's analysis logic.
    `ProcessTrace` | `process(CAS aCAS, ResultSpecification aResultSpec)` Invokes this AnalysisEngine's analysis logic.
    `void` | `process(CAS aCAS, ResultSpecification aResultSpec, ProcessTrace aTrace)` Invokes this AnalysisEngine's analysis logic.
    `ProcessTrace` | `process(JCas aJCas)` Similar to `AnalysisEngine.process(CAS)` but uses the Java-object-based `JCas` interface instead of the general `CAS` interface.
    `ProcessTrace` | `process(JCas aJCas, ResultSpecification aResultSpec)` Similar to `AnalysisEngine.process(CAS,ResultSpecification)` but uses the Java-object-based `JCas` interface instead of the general `CAS` interface.
    `void` | `process(JCas aJCas, ResultSpecification aResultSpec, ProcessTrace aTrace)` Similar to `AnalysisEngine.process(CAS, ResultSpecification, ProcessTrace)` but uses the Java-object-based `JCas` interface instead of the general `CAS` interface.
    `CasIterator` | `processAndOutputNewCASes(CAS aCAS)` Processes a CAS, possibly producing multiple CASes as a result.
    `JCasIterator` | `processAndOutputNewCASes(JCas aJCas)` Default implementation of processAndOutputNewCASes(JCas) method.
    `void` | `processCas(CAS aCAS)` Process a single CAS.
    `void` | `processCas(CAS[] aCASes)` Processes multiple CASes.
    `void` | `resetResultSpecificationToDefault()`
    `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 aResultSpec)` Sets the list of output types and features that the application wants this AnalysisEngine to produce.
    `void` | `typeSystemInit(TypeSystem aTypeSystem)` From the CAS Processor interface.

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

      `getConfigParameterValue, getConfigParameterValue, reconfigure, setConfigParameterValue, setConfigParameterValue`

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

      `destroy, getCasManager, getLogger, getMetaData, getRelativePathResolver, getResourceManager, getUimaContext, getUimaContextAdmin, loadUserClass, loadUserClassOrThrow, setContextHolder, setContextHolderX, setLogger, withContextHolder`

    - ### 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, reconfigure, setLogger`

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

      `getConfigParameterValue, getConfigParameterValue, setConfigParameterValue, setConfigParameterValue`

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

      `destroy, getMetaData, getUimaContext, getUimaContextAdmin`

- - ### Field Detail

    - #### LOG_RESOURCE_BUNDLE

          protected static final String LOG_RESOURCE_BUNDLE

      resource bundle for log messages
      See Also:
        Constant Field Values

    - #### PARAM_VERIFICATION_MODE

          public static final String PARAM_VERIFICATION_MODE

      Key that must be inserted into the aAdditionalParams map to turn on verification mode. Also passed down to delegates.
      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### AnalysisEngineImplBase

          public AnalysisEngineImplBase()

  - ### Method Detail

    - #### 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 `Resource_ImplBase`
      Parameters:
        `aMetaData` - metadata to assign to this `Resource`

    - #### 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`
      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`
      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`
      Parameters:
        `aCAS` - the CAS to be processed
      Returns:
        an object for iterating through any output CASes
      Throws:
        `AnalysisEngineProcessException` - if a failure occurs during processing

    - #### 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 `Resource_ImplBase`
      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. Returns 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`

    - #### finalize

          protected void finalize()
                           throws Throwable

      Overrides:
        `finalize` in class `Object`
      Throws:
        `Throwable`

    - #### 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`
      Returns:
        an object containing all metadata for this AnalysisEngine
      See Also:
        `AnalysisEngine.getAnalysisEngineMetaData()`

    - #### getProcessingResourceMetaData

          public ProcessingResourceMetaData getProcessingResourceMetaData()

      Description copied from interface: `CasProcessor`
      Gets the metadata that describes this `CasProcesor`.
      Specified by:
        `getProcessingResourceMetaData` in interface `CasProcessor`
      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`
      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()`

    - #### newJCas

          public JCas newJCas()
                       throws ResourceInitializationException

      Description copied from interface: `AnalysisEngine`
      Similar to `AnalysisEngine.newCAS()` but wraps the new CAS objects with the Java-object-based `JCas` interface.

      Note: the JCas that is returned is equivalent to what you would get if you called `newCAS().getCurrentView().getJCas()`. That is, this method returns a view of the default Sofa, NOT a Base CAS.

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

      Specified by:
        `newJCas` in interface `AnalysisEngine`
      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.newJCas()`

    - #### process

          public ProcessTrace process(CAS aCAS,
                                      ResultSpecification aResultSpec)
                               throws ResultNotSupportedException,
                                      AnalysisEngineProcessException

      Description copied from interface: `AnalysisEngine`
      Invokes this AnalysisEngine's analysis logic. Prior to calling this method, the caller must ensure that the CAS has been populated with the artifact to be analyzed as well as any inputs required by this AnalysisEngine (as defined by this AnalysisEngine's `Capability` specification.)

      This version of the `process` method takes a `ResultSpecification` as an argument. The `ResultSpecification` is alist of output types and features that the application wants this AnalysisEngine to produce. If you are going to use the same `ResultSpecification` for multiple calls to `process`, it is not recommended to use this method. Instead call `AnalysisEngine.setResultSpecification(ResultSpecification)` once and then call `AnalysisEngine.process(CAS)` for each CAS that you want to process.

      Specified by:
        `process` in interface `AnalysisEngine`
      Parameters:
        `aCAS` - the CAS containing the inputs to the processing. Analysis results will also be written to this CAS.
        `aResultSpec` - a list of outputs that this AnalysisEngine should produce.
      Returns:
        an object containing information about which AnalysisEngine components have executed and information, such as timing, about that execution.
      Throws:
        `ResultNotSupportedException` - if this AnalysisEngine is not capable of producing the results requested in `aResultSpec`.
        `AnalysisEngineProcessException` - if a failure occurs during processing.
      See Also:
        `AnalysisEngine.process(org.apache.uima.cas.CAS, org.apache.uima.analysis_engine.ResultSpecification)`

    - #### process

          public void process(CAS aCAS,
                              ResultSpecification aResultSpec,
                              ProcessTrace aTrace)
                       throws ResultNotSupportedException,
                              AnalysisEngineProcessException

      Description copied from interface: `AnalysisEngine`
      Invokes this AnalysisEngine's analysis logic. Prior to calling this method, the caller must ensure that the CAS has been populated with the artifact to be analyzed as well as any inputs required by this AnalysisEngine (as defined by this AnalysisEngine's `Capability` specification.)

      This version of the `process` method takes a `ResultSpecification` as an argument. The `ResultSpecification` is a list of output types and features that the application wants this AnalysisEngine to produce. If you are going to use the same `ResultSpecification` for multiple calls to `process`, it is not recommended to use this method. Instead call `AnalysisEngine.setResultSpecification(ResultSpecification)` once and then call `AnalysisEngine.process(CAS)` for each CAS that you want to process.

      This version of this method also takes a `ProcessTrace` object as a parameter. This allows trace events to be written to an existing `ProcessTrace` rather than a new one.

      Specified by:
        `process` in interface `AnalysisEngine`
      Parameters:
        `aCAS` - the CAS containing the inputs to the processing. Analysis results will also be written to this CAS.
        `aResultSpec` - a list of outputs that this AnalysisEngine should produce.
        `aTrace` - the object to which trace events will be recorded
      Throws:
        `ResultNotSupportedException` - if this AnalysisEngine is not capable of producing the results requested in `aResultSpec`.
        `AnalysisEngineProcessException` - if a failure occurs during processing.
      See Also:
        `AnalysisEngine.process(org.apache.uima.cas.CAS, org.apache.uima.analysis_engine.ResultSpecification, org.apache.uima.util.ProcessTrace)`

    - #### process

          public ProcessTrace process(CAS aCAS)
                               throws AnalysisEngineProcessException

      Description copied from interface: `AnalysisEngine`
      Invokes this AnalysisEngine's analysis logic. Prior to calling this method, the caller must ensure that the CAS has been populated with the artifact to be analyzed as well as any inputs required by this AnalysisEngine (as defined by this AnalysisEngine's `Capability` specification.)

      This version of `process` does not take a `ResultSpecification` parameter. You may specify a `ResultSpecification` by calling `AnalysisEngine.setResultSpecification(ResultSpecification)` prior to calling this method.

      Specified by:
        `process` in interface `AnalysisEngine`
      Parameters:
        `aCAS` - the CAS containing the inputs to the processing. Analysis results will also be written to this CAS.
      Returns:
        an object containing information about which AnalysisEngine components have executed and information, such as timing, about that execution.
      Throws:
        `AnalysisEngineProcessException` - if a failure occurs during processing.

    - #### process

          public ProcessTrace process(JCas aJCas)
                               throws AnalysisEngineProcessException

      Description copied from interface: `AnalysisEngine`
      Similar to `AnalysisEngine.process(CAS)` but uses the Java-object-based `JCas` interface instead of the general `CAS` interface.
      Specified by:
        `process` in interface `AnalysisEngine`
      Parameters:
        `aJCas` - the JCas containing the inputs to the processing. Analysis results will also be written to this JCas.
      Returns:
        an object containing information about which AnalysisEngine components have executed and information, such as timing, about that execution.
      Throws:
        `AnalysisEngineProcessException` - if a failure occurs during processing.
      See Also:
        `AnalysisEngine.process(org.apache.uima.jcas.JCas)`

    - #### process

          public ProcessTrace process(JCas aJCas,
                                      ResultSpecification aResultSpec)
                               throws ResultNotSupportedException,
                                      AnalysisEngineProcessException

      Description copied from interface: `AnalysisEngine`
      Similar to `AnalysisEngine.process(CAS,ResultSpecification)` but uses the Java-object-based `JCas` interface instead of the general `CAS` interface.

      This version of the `process` method takes a `ResultSpecification` as an argument. The `ResultSpecification` is a list of output types and features that the application wants this AnalysisEngine to produce. If you are going to use the same `ResultSpecification` for multiple calls to `process`, it is not recommended to use this method. Instead call `AnalysisEngine.setResultSpecification(ResultSpecification)` once and then call `AnalysisEngine.process(JCas)` for each CAS that you want to process.

      Specified by:
        `process` in interface `AnalysisEngine`
      Parameters:
        `aJCas` - the JCas containing the inputs to the processing. Analysis results will also be written to this JCas.
        `aResultSpec` - a list of outputs that this AnalysisEngine should produce.
      Returns:
        an object containing information about which AnalysisEngine components have executed and information, such as timing, about that execution.
      Throws:
        `ResultNotSupportedException` - if this AnalysisEngine is not capable of producing the results requested in `aResultSpec`.
        `AnalysisEngineProcessException` - if a failure occurs during processing.
      See Also:
        `AnalysisEngine.process(org.apache.uima.jcas.JCas, org.apache.uima.analysis_engine.ResultSpecification)`

    - #### process

          public void process(JCas aJCas,
                              ResultSpecification aResultSpec,
                              ProcessTrace aTrace)
                       throws ResultNotSupportedException,
                              AnalysisEngineProcessException

      Description copied from interface: `AnalysisEngine`
      Similar to `AnalysisEngine.process(CAS, ResultSpecification, ProcessTrace)` but uses the Java-object-based `JCas` interface instead of the general `CAS` interface.

      This version of the `process` method takes a `ResultSpecification` as an argument. The `ResultSpecification` is a list of output types and features that the application wants this AnalysisEngine to produce. If you are going to use the same `ResultSpecification` for multiple calls to `process`, it is not recommended to use this method. Instead call `AnalysisEngine.setResultSpecification(ResultSpecification)` once and then call `AnalysisEngine.process(JCas)` for each CAS that you want to process.

      This version of this method also takes a `ProcessTrace` object as a parameter. This allows trace events to be written to an existing `ProcessTrace` rather than a new one.

      Specified by:
        `process` in interface `AnalysisEngine`
      Parameters:
        `aJCas` - the JCas containing the inputs to the processing. Analysis results will also be written to this JCas.
        `aResultSpec` - a list of outputs that this AnalysisEngine should produce.
        `aTrace` - the object to which trace events will be recorded
      Throws:
        `ResultNotSupportedException` - if this AnalysisEngine is not capable of producing the results requested in `aResultSpec`.
        `AnalysisEngineProcessException` - if a failure occurs during processing.
      See Also:
        `AnalysisEngine.process(org.apache.uima.jcas.JCas, org.apache.uima.analysis_engine.ResultSpecification, org.apache.uima.util.ProcessTrace)`

    - #### process

          @Deprecated
          public void process(AnalysisProcessData aProcessData,
                                          ResultSpecification aResultSpec)
                                   throws ResultNotSupportedException,
                                          AnalysisEngineProcessException

      Deprecated.
      Description copied from interface: `AnalysisEngine`
      Invokes this AnalysisEngine's analysis logic. Prior to calling this method, the caller must ensure that the CAS has been populated with the artifact to be analyzed as well as any inputs required by this AnalysisEngine (as defined by this AnalysisEngine's `Capability` specification.)

      This version of this method is not normally used directly by applications. It is used to call Analysis Engines that are components within an aggregate Analysis Engine, so that they can share all information in the `AnalysisProcessData` object, which includes the CAS and the ProcessTrace.

      Specified by:
        `process` in interface `AnalysisEngine`
      Parameters:
        `aProcessData` - the data that will be modified during processing. This includes the CAS and the ProcessTrace.
        `aResultSpec` - a list of outputs that this AnalysisEngine should produce. A `null` result specification is equivalent to a request for all possible results.
      Throws:
        `ResultNotSupportedException` - if this AnalysisEngine is not capable of producing the results requested in `aResultSpec`.
        `AnalysisEngineProcessException` - if a failure occurs during processing.

    - #### processCas

          public void processCas(CAS aCAS)
                          throws ResourceProcessException

      Description copied from interface: `CasObjectProcessor`
      Process a single CAS.
      Specified by:
        `processCas` in interface `CasObjectProcessor`
      Parameters:
        `aCAS` - the CAS to be processed. Additional information may be added to this CAS (if this CAS processor is not `read-only`).
      Throws:
        `ResourceProcessException` - if processing fails

    - #### processCas

          public void processCas(CAS[] aCASes)
                          throws ResourceProcessException

      Description copied from interface: `CasObjectProcessor`
      Processes multiple CASes.
      Specified by:
        `processCas` in interface `CasObjectProcessor`
      Parameters:
        `aCASes` - an array of CASes to be processed. Additional information may be added to these CASes (if this CAS processor is not `read-only`).
      Throws:
        `ResourceProcessException` - if processing fails for any of the CASes
      See Also:
        `CasObjectProcessor.processCas(org.apache.uima.cas.CAS[])`

    - #### processAndOutputNewCASes

          public JCasIterator processAndOutputNewCASes(JCas aJCas)
                                                throws AnalysisEngineProcessException

      Default implementation of processAndOutputNewCASes(JCas) method. Calls the version of this method that takes a CAS, then wraps the resulting CasIterator in a JCasIterator.
      Specified by:
        `processAndOutputNewCASes` in interface `AnalysisEngine`
      Parameters:
        `aJCas` - the JCAS to be processed
      Returns:
        an object for iterating through any output JCASes
      Throws:
        `AnalysisEngineProcessException` - if a failure occurs during processing

    - #### 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`
      Returns:
        a new instance of `ResultSpecification`
      See Also:
        `AnalysisEngine.createResultSpecification()`

    - #### createResultSpecification

          public ResultSpecification createResultSpecification(TypeSystem aTypeSystem)

      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`
      Parameters:
        `aTypeSystem` - the type system
      Returns:
        a new instance of `ResultSpecification`
      See Also:
        `AnalysisEngine.createResultSpecification(TypeSystem)`

    - #### getFeatureNamesForType

          public String[] getFeatureNamesForType(String aTypeName)

      Description copied from interface: `AnalysisEngine`
      Gets the names of the features that are defined on one of the CAS types that this AE inputs or outputs. When a AE's capabilities are declared with `allAnnotatorFeatures == true`, this method can be used to determine all of the feature names.
      Specified by:
        `getFeatureNamesForType` in interface `AnalysisEngine`
      Parameters:
        `aTypeName` - type for which to get features
      Returns:
        an array of feature names. If `aTypeName` is not defined, `null` will be returned.
      See Also:
        `AnalysisEngine.getFeatureNamesForType(java.lang.String)`

    - #### isStateless

          public boolean isStateless()

      Description copied from interface: `CasProcessor`
      Gets whether this is a stateless CAS Processor. Stateless CAS Processors do not maintain any data between calls to their process methods.
      Specified by:
        `isStateless` in interface `CasProcessor`
      Returns:
        true if this CAS processor is stateless, false if it is stateful.

    - #### isReadOnly

          public boolean isReadOnly()

      Description copied from interface: `CasProcessor`
      Gets whether this is a read-only CAS Processor, which does not modify the CAS.
      Specified by:
        `isReadOnly` in interface `CasProcessor`
      Returns:
        true if this CAS processor does not modify the CAS, false if it does.

    - #### typeSystemInit

          public void typeSystemInit(TypeSystem aTypeSystem)
                              throws ResourceInitializationException

      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`
      Parameters:
        `aTypeSystem` - 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)`

    - #### getPerformanceTuningSettings

          public Properties getPerformanceTuningSettings()

      Gets the performance tuning settings in effect for this Analysis Engine.
      Specified by:
        `getPerformanceTuningSettings` in interface `AnalysisEngine`
      Returns:
        performance tuning settings

    - #### setResultSpecification

          public void setResultSpecification(ResultSpecification aResultSpec)

      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`
      Parameters:
        `aResultSpec` - specifies the list of output types and features that the application is interested in.

    - #### resetResultSpecificationToDefault

          public void resetResultSpecificationToDefault()

    - #### getManagementInterface

          public AnalysisEngineManagement getManagementInterface()

      Description copied from interface: `AnalysisEngine`
      Gets an object that can be used to do monitoring or management of this AnalysisEngine.
      Specified by:
        `getManagementInterface` in interface `AnalysisEngine`
      Returns:
        an object exposing a management interface to this AE

    - #### batchProcessComplete

          public void batchProcessComplete(ProcessTrace aTrace)
                                    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`
      Parameters:
        `aTrace` - 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 aTrace)
                                         throws ResourceProcessException,
                                                IOException

      Description copied from interface: `CasProcessor`
      Completes the processing of an entire collection.
      Specified by:
        `collectionProcessComplete` in interface `CasProcessor`
      Parameters:
        `aTrace` - 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

    - #### setPerformanceTuningSettings

          protected void setPerformanceTuningSettings(Properties aSettings)

      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.
      Parameters:
        `aSettings` - performance tuning settings

    - #### normalizeIsoLangCodes

          protected void normalizeIsoLangCodes(ProcessingResourceMetaData md)

    - #### getCurrentConfigParameterSettings

          protected ConfigurationParameterSettings getCurrentConfigParameterSettings()

      Kludge - make this public (but not part of AnalysisEngine interface) so that TAFAnnotator can access it.
      Returns:
        -
      See Also:
        `ConfigurationManager.getCurrentConfigParameterSettings(String)`

    - #### getMBean

          protected AnalysisEngineManagementImpl getMBean()

      Returns:
        the MBean that provides the management interface to this AE. Returns the same object as getManagementInterface() but casted to the AnalysisEngineManagement type.

    - #### enterProcess

          protected void enterProcess()

    - #### exitProcess

          protected void exitProcess()

    - #### enterBatchProcessComplete

          protected void enterBatchProcessComplete()

    - #### exitBatchProcessComplete

          protected void exitBatchProcessComplete()

    - #### enterCollectionProcessComplete

          protected void enterCollectionProcessComplete()

    - #### exitCollectionProcessComplete

          protected void exitCollectionProcessComplete()

    - #### buildProcessTraceFromMBeanStats

          protected ProcessTrace buildProcessTraceFromMBeanStats()

      Returns:
        a constructed ProcessTrace object that represents the last execution 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.

    - #### buildProcessTraceFromMBeanStats

          protected void buildProcessTraceFromMBeanStats(ProcessTrace trace)

      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.
      Parameters:
        `trace` - -

    - #### isProcessTraceEnabled

          protected boolean isProcessTraceEnabled()

      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.
      Returns:
        true if the ProcessTrace is enabled, false if not.

    - #### getMBeanServer

          protected Object getMBeanServer()

    - #### getMBeanNamePrefix

          protected String getMBeanNamePrefix()

    - #### callInitializeMethod

          protected void callInitializeMethod(AnalysisComponent component,
                                              UimaContext context)
                                       throws ResourceInitializationException

      Throws:
        `ResourceInitializationException`

    - #### callProcessMethod

          protected void callProcessMethod(AnalysisComponent component,
                                           AbstractCas cas)
                                    throws Exception

      Throws:
        `Exception`

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