org.apache.uima.analysis_engine.asb.impl

## Class FlowControllerContainer

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

- All Implemented Interfaces:
    ConfigurableResource, Resource

      public class FlowControllerContainer
      extends ConfigurableResource_ImplBase

  Container for a FlowController. Manages configuration parameters, resources, CAS interface conversions, and performance timing.

- - ### Field Summary

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

      `PARAM_AGGREGATE_SOFA_MAPPINGS, PARAM_CONFIG_MANAGER, PARAM_CONFIG_PARAM_SETTINGS, PARAM_EXTERNAL_OVERRIDE_SETTINGS, PARAM_PERFORMANCE_TUNING_SETTINGS, PARAM_RESOURCE_MANAGER, PARAM_UIMA_CONTEXT`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `FlowControllerContainer()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addAnalysisEngines(Collection<String> aKeys)` Notifies this FlowController that new Analysis Engines
    `void` | `collectionProcessComplete()`
    `FlowContainer` | `computeFlow(CAS aCAS)` Invokes the FlowController's computeFlow method, returning a Flow object that routes the given CAS through this aggregate.
    `void` | `destroy()` Releases all resources held by this `Resource`.
    `protected void` | `finalize()`
    `AnalysisEngineManagementImpl` | `getMBean()`
    `ProcessingResourceMetaData` | `getProcessingResourceMetaData()`
    `Class<? extends AbstractCas>` | `getRequiredCasInterface()`
    `boolean` | `initialize(ResourceSpecifier aSpecifier, Map<String,Object> aAdditionalParams)` Initializes this `Resource` from a `ResourceSpecifier`.
    `void` | `reconfigure()` Instructs this Resource to re-read its configuration parameter settings.
    `void` | `removeAnalysisEngines(Collection<String> aKeys)` Notifies this FlowController that some Analysis Engines are no longer available to route CASes to.

    - ### 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, getMetaData, getRelativePathResolver, getResourceManager, getUimaContext, getUimaContextAdmin, loadUserClass, loadUserClassOrThrow, setContextHolder, setContextHolderX, setLogger, setMetaData, 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.resource.Resource

      `getLogger, getMetaData, getResourceManager, getUimaContext, getUimaContextAdmin, setLogger`

- - ### Constructor Detail

    - #### FlowControllerContainer

          public FlowControllerContainer()

  - ### 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 `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`

    - #### 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 `ConfigurableResource`
      Overrides:
        `reconfigure` in class `ConfigurableResource_ImplBase`
      Throws:
        `ResourceConfigurationException` - if the configuration is not valid
      See Also:
        `ConfigurableResource.reconfigure()`

    - #### 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()`

    - #### computeFlow

          public FlowContainer computeFlow(CAS aCAS)
                                    throws AnalysisEngineProcessException

      Invokes the FlowController's computeFlow method, returning a Flow object that routes the given CAS through this aggregate. This method makes sure to provide the FlowController with its required CAS interface (e.g. JCas).
      Parameters:
        `aCAS` - the CAS to pass to the FlowController
      Returns:
        a Flow object that routes this CAS
      Throws:
        `AnalysisEngineProcessException` - if the FlowController failed

    - #### getRequiredCasInterface

          public Class<? extends AbstractCas> getRequiredCasInterface()

      Returns:
        the required CAS interface of the FlowController

    - #### getProcessingResourceMetaData

          public ProcessingResourceMetaData getProcessingResourceMetaData()

    - #### getMBean

          public AnalysisEngineManagementImpl getMBean()

      Returns:
        the MBean to use to report performance statistics.

    - #### addAnalysisEngines

          public void addAnalysisEngines(Collection<String> aKeys)

      Notifies this FlowController that new Analysis Engines
      Parameters:
        `aKeys` - the keys for the delegates
      See Also:
        `FlowController.addAnalysisEngines(Collection)`

    - #### removeAnalysisEngines

          public void removeAnalysisEngines(Collection<String> aKeys)
                                     throws AnalysisEngineProcessException

      Notifies this FlowController that some Analysis Engines are no longer available to route CASes to.
      Parameters:
        `aKeys` - the keys of the delegates to be removed
      Throws:
        `AnalysisEngineProcessException` - -
      See Also:
        `FlowController.removeAnalysisEngines(Collection)`

    - #### collectionProcessComplete

          public void collectionProcessComplete()
                                         throws AnalysisEngineProcessException

      Throws:
        `AnalysisEngineProcessException`

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