# UIMA Overview

Overview

The Unstructured Information Management Architecture (UIMA) is an architecture and software framework for creating, discovering, composing and deploying a broad range of multi-modal analysis capabilities and integrating them with search technologies. The architecture is undergoing a standardization effort, referred to as the UIMA specification by a technical committee within OASIS.

The Apache UIMA framework is an Apache licensed, open source implementation of the UIMA Architecture, and provides a run-time environment in which developers can plug in and run their UIMA component implementations and with which they can build and deploy UIM applications. The framework itself is not specific to any IDE or platform.

It includes an all-Java implementation of the UIMA framework for the development, description, composition and deployment of UIMA components and applications. It also provides the developer with an Eclipse-based ( ) development environment that includes a set of tools and utilities for using UIMA. It also includes a C++ version of the framework, and enablements for Annotators built in Perl, Python, and TCL.

This chapter is the intended starting point for readers that are new to the Apache UIMA Project. It includes this introduction and the following sections:

- provides a list of the books and topics included in the Apache UIMA documentation with a brief summary of each.

- describes a recommended path through the documentation to help get the reader up and running with UIMA

- is intended for users of IBM UIMA, and describes the steps needed to upgrade to Apache UIMA.

- lists the changes that occurred between UIMA v1.x and UIMA v2.x (independent of the transition to Apache).

The main website for Apache UIMA is . Here you can find out many things, including:

- how to download (both the binary and source distributions

- how to participate in the development

- mailing lists - including the user list used like a forum for questions and answers

- a Wiki where you can find and contribute all kinds of information, including tips and best practices

- a sandbox - a subproject for potential new additions to Apache UIMA or to subprojects of it. Things here are works in progress, and may (or may not) be included in releases.

- links to conferences

## Apache UIMA Project Documentation Overview

The user documentation for UIMA is organized into several parts.

- Overviews - this documentation

- Eclipse Tooling Installation and Setup - also in this document

- Tutorials and Developer's Guides

- Tools Users' Guides

- References

The first 2 parts make up this book; the last 3 have individual books. The books are provided both as (somewhat large) html files, viewable in browsers, and also as PDF files. The documentation is fully hyperlinked, with tables of contents. The PDF versions are set up to print nicely - they have page numbers included on the cross references within a book.

If you view the PDF files inside a browser that supports imbedded viewing of PDF, the hyperlinks between different PDF books may work (not all browsers have been tested...).

The following set of tables gives a more detailed overview of the various parts of the documentation.

### Overviews

Overview of the Documentation | What you are currently reading. Lists the documents provided in the Apache UIMA documentation set and provides a recommended path through the documentation for getting started using UIMA. It includes release notes and provides a brief high-level description of the different software modules included in the Apache UIMA Project. See .
Conceptual Overview | Provides a broad conceptual overview of the UIMA component architecture; includes references to the other documents in the documentation set that provide more detail. See
UIMA FAQs | Frequently Asked Questions about general UIMA concepts. (Not a programming resource.) See .
Known Issues | Known issues and problems with the UIMA SDK. See .
Glossary | UIMA terms and concepts and their basic definitions. See .

### Eclipse Tooling Installation and Setup

Provides step-by-step instructions for installing Apache UIMA in the Eclipse Interactive Development Environment. See .

### Tutorials and Developer's Guides

Annotators and Analysis Engines | Tutorial-style guide for building UIMA annotators and analysis engines. This chapter introduces the developer to creating type systems and using UIMA's common data structure, the CAS or Common Analysis Structure. It demonstrates how to use built in tools to specify and create basic UIMA analysis components. See .
Building UIMA Collection Processing Engines | Tutorial-style guide for building UIMA collection processing engines. These manage the analysis of collections of documents from source to sink. See .
Developing Complete Applications | Tutorial-style guide on using the UIMA APIs to create, run and manage UIMA components from your application. Also describes APIs for saving and restoring the contents of a CAS using an XML format called XMI. See .
Flow Controller | When multiple components are combined in an Aggregate, each CAS flow among the various components. UIMA provides two built-in flows, and also allows custom flows to be implemented. See .
Developing Applications using Multiple Subjects of Analysis | A single CAS maybe associated with multiple subjects of analysis (Sofas). These are useful for representing and analyzing different formats or translations of the same document. For multi-modal analysis, Sofas are good for different modal representations of the same stream (e.g., audio and close-captions).This chapter provides the developer details on how to use multiple Sofas in an application. See .
Multiple CAS Views of an Artifact | UIMA provides an extension to the basic model of the CAS which supports analysis of multiple views of the same artifact, all contained with the CAS. This chapter describes the concepts, terminology, and the API and XML extensions that enable this. See .
CAS Multiplier | A component may add additional CASes into the workflow. This may be useful to break up a large artifact into smaller units, or to create a new CAS that collects information from multiple other CASes. See .
XMI and EMF Interoperability | The UIMA Type system and the contents of the CAS itself can be externalized using the XMI standard for XML MetaData. Eclipse Modeling Framework (EMF) tooling can be used to develop applications that use this information. See .

### Tools Users' Guides

Component Descriptor Editor | Describes the features of the Component Descriptor Editor Tool. This tool provides a GUI for specifying the details of UIMA component descriptors, including those for Analysis Engines (primitive and aggregate), Collection Readers, CAS Consumers and Type Systems. See .
Collection Processing Engine Configurator | Describes the User Interfaces and features of the CPE Configurator tool. This tool allows the user to select and configure the components of a Collection Processing Engine and then to run the engine. See .
Pear Packager | Describes how to use the PEAR Packager utility. This utility enables developers to produce an archive file for an analysis engine that includes all required resources for installing that analysis engine in another UIMA environment. See .
Pear Installer | Describes how to use the PEAR Installer utility. This utility installs and verifies an analysis engine from an archive file (PEAR) with all its resources in the right place so it is ready to run. See .
Pear Merger | Describes how to use the Pear Merger utility, which does a simple merge of multiple PEAR packages into one. See .
Document Analyzer | Describes the features of a tool for applying a UIMA analysis engine to a set of documents and viewing the results. See .
CAS Visual Debugger | Describes the features of a tool for viewing the detailed structure and contents of a CAS. Good for debugging. See .
JCasGen | Describes how to run the JCasGen utility, which automatically builds Java classes that correspond to a particular CAS Type System. See .
XML CAS Viewer | Describes how to run the supplied viewer to view externalized XML forms of CASes. This viewer is used in the examples. See .

### References

Introduction to the UIMA API Javadocs | Javadocs detailing the UIMA programming interfaces See
XML: Component Descriptor | Provides detailed XML format for all the UIMA component descriptors, except the CPE (see next). See .
XML: Collection Processing Engine Descriptor | Provides detailed XML format for the Collection Processing Engine descriptor. See
CAS | Provides detailed description of the principal CAS interface. See
JCas | Provides details on the JCas, a native Java interface to the CAS. See
PEAR Reference | Provides detailed description of the deployable archive format for UIMA components. See
XMI CAS Serialization Reference | Provides detailed description of the deployable archive format for UIMA components. See

## How to use the Documentation

1. Explore this chapter to get an overview of the different documents that are included with Apache UIMA.

2. Read to get a broad view of the basic UIMA concepts and philosophy with reference to the other documents included in the documentation set which provide greater detail.

3. For more general information on the UIMA architecture and how it has been used, refer to the IBM Systems Journal special issue on Unstructured Information Management, on-line at or to the section of the UIMA project website on Apache website where other publications are listed.

4. Set up Apache UIMA in your Eclipse environment. To do this, follow the instructions in .

5. Develop sample UIMA annotators, run them and explore the results. Read and follow it like a tutorial to learn how to develop your first UIMA annotator and set up and run your first UIMA analysis engines.

   - As part of this you will use a few tools including

     - The UIMA Component Descriptor Editor, described in more detail in and

     - The Document Analyzer, described in more detail in .

   - While following along in , reference documents that may help are:

     - for understanding the analysis engine descriptors

     - for understanding the JCas

6. Learn how to create, run and manage a UIMA analysis engine as part of an application. Connect your analysis engine to the provided semantic search engine to learn how a complete analysis and search application may be built with Apache UIMA. will guide you through this process.

   - As part of this you will use the document analyzer (described in more detail in and semantic search GUI tools (see .

7. Pat yourself on the back. Congratulations! If you reached this step successfully, then you have an appreciation for the UIMA analysis engine architecture. You would have built a few sample annotators, deployed UIMA analysis engines to analyze a few documents, searched over the results using the built-in semantic search engine and viewed the results through a built-in viewer – all as part of a simple but complete application.

8. Develop and run a Collection Processing Engine (CPE) to analyze and gather the results of an entire collection of documents. will guide you through this process.

   - As part of this you will use the CPE Configurator tool. For details see .

   - You will also learn about CPE Descriptors. The detailed format for these may be found in .

9. Learn how to package up an analysis engine for easy installation into another UIMA environment. and will teach you how to create UIMA analysis engine archives so that you can easily share your components with a broader community.

## Changes from Previous Major Versions

There are two previous version of UIMA, available from IBM's alphaWorks: version 1.4.x and version 2.0 (the 2.0 version was a "beta" only release). This section describes the changes relative to both of these releases. A migration utility is provided which updates your Java code and descriptors as needed for this release. See for instructions on how to run the migration utility.

Each Apache UIMA release includes RELEASE_NOTES and RELEASE_NOTES.html files that describe the changes that have occurred in each release. Please refer to those files for specific changes for each Apache UIMA release.

### Changes from IBM UIMA 2.0 to Apache UIMA 2.1

This section describes what has changed between version 2.0 and version 2.1 of UIMA; the following section describes the differences between version 1.4 and version 2.1.

#### Java Package Name Changes

All of the UIMA Java package names have changed in Apache UIMA. They now start with `org.apache` rather than `com.ibm`. There have been other changes as well. The package name segment `reference_impl` has been shortened to `impl`, and some segments have been reordered. For example `com.ibm.uima.reference_impl.analysis_engine` has become `org.apache.uima.analysis_engine.impl`. Tools are now consolidated under `org.apache.uima.tools` and service adapters under `org.apache.uima.adapter`.

The migration utility will replace all occurrences of IBM UIMA package names with their Apache UIMA equivalents. It will not replace prefixes of package names, so if your code uses a package called `com.ibm.uima.myproject` (although that is not recommended), it will not be replaced.

#### XML Descriptor Changes

The XML namespace in UIMA component descriptors has changed from `http://uima.watson.ibm.com/resourceSpecifier` to `http://uima.apache.org/resourceSpecifier`. The value of the `<frameworkImplementation>` must now be `org.apache.uima.java` or `org.apache.uima.cpp`. The migration script will apply these replacements.

#### TCAS replaced by CAS

In Apache UIMA the `TCAS` interface has been removed. All uses of it must now be replaced by the `CAS` interface. (All methods that used to be defined on `TCAS` were moved to `CAS` in v2.0.) The method `CAS.getTCAS()` is replaced with `CAS.getCurrentView()` and `CAS.getTCAS(String)` is replaced with `CAS.getView(String)` . The following have also been removed and replaced with the equivalent "CAS" variants: `TCASException`, `TCASRuntimeException`, `TCasPool`, and `CasCreationUtils.createTCas(...)`.

The migration script will apply the necessary replacements.

#### JCas Is Now an Interface

In previous versions, user code accessed the JCas class directly. In Apache UIMA there is now an interface, `org.apache.uima.jcas.JCas`, which all JCas-based user code must now use. Static methods that were previously on the JCas class (and called from JCas cover classes generated by JCasGen) have been moved to the new `org.apache.uima.jcas.JCasRegistry` class. The migration script will apply the necessary replacements to your code, including any JCas cover classes that are part of your codebase.

#### JAR File names Have Changed

The UIMA JAR file names have changed slightly. Underscores have been replaced with hyphens to be consistent with Apache naming conventions. For example `uima_core.jar` is now `uima-core.jar`. Also `uima_jcas_builtin_types.jar` has been renamed to `uima-document-annotation.jar`. Finally, the `jVinci.jar` file is now in the `lib` directory rather than the `lib/vinci` directory as was previously the case. The migration script will apply the necessary replacements, for example to script files or Eclipse launch configurations. (See for a list of file extensions that the migration utility will process by default.)

#### Semantic Search Engine Repackaged

The versions of the UIMA SDK prior to the move into Apache came with a semantic search engine. The Apache version does not include this search engine. The search engine has been repackaged and is separately available from . The intent is to hook up (over time) with other open source search engines, such as the Lucene search engine project in Apache.

### Changes from UIMA Version 1.x

Version 2.x of UIMA provides new capabilities and refines several areas of the UIMA architecture, as compared with version 1.

#### New Capabilities

New Primitive data types

UIMA now supports Boolean (bit), Byte, Short (16 bit integers), Long (64 bit integers), and Double (64 bit floating point) primitive types, and arrays of these. These types can be used like all the other primitive types.

Simpler Analysis Engines and CASes

Version 1.x made a distinction between Analysis Engines and Text Analysis Engines. This distinction has been eliminated in Version 2 - new code should just refer to Analysis Engines. Analysis Engines can operate on multiple kinds of artifacts, including text.

Sofas and CAS Views simplified

The APIs for manipulating multiple subjects of analysis (Sofas) and their corresponding CAS Views have been simplified.

Analysis Component generalized to support multiple new CAS outputs

Analysis Components, in general, can make use of new capabilities to return multiple new CASes, in addition to returning the original CAS that is passed in. This allows components to have Collection Reader-like capabilities, but be placed anywhere in the flow. See .

User-customized Flow Controllers

A new component, the Flow Controller, can be supplied by the user to implement arbitrary flow control for CASes within an Aggregate. This is in addition to the two built-in flow control choices of linear and language-capability flow. See .

#### Other Changes

New additional Annotator API ImplBase

As of version 2.1, UIMA has a new set of Annotator interfaces. Annotators should now extend CasAnnotator_ImplBase or JCasAnnotator_ImplBase instead of the v1.x TextAnnotator_ImplBase and JTextAnnotator_ImplBase. The v1.x annotator interfaces are unchanged and are still supported for backwards compatibility.

The new Annotator interfaces support the changed approaches for ResultSpecifications and the changed exception names (see below), and have all the methods that CAS Consumers have, including CollectionProcessComplete and BatchProcessComplete.

UIMA Exceptions rationalized

In version 1 there were different exceptions for the methods of an AnalysisEngine and for the corresponding methods of an Annotator; these were merged in version 2.

- AnnotatorProcessException (v1) → AnalysisEngineProcessException (v2)

- AnnotatorInitializationException (v1) → ResourceInitializationException (v2)

- AnnotatorConfigurationException (v1) → ResourceConfigurationException (v2)

- AnnotatorContextException (v1) → ResourceAccessException (v2)

The previous exceptions are still available, but new code should use the new exceptions.

The signature for typeSystemInit changed the throws clause to throw AnalysisEngineProcessException. For Annotators that extend the previous base, the previous definition of typeSystemInit will continue to work for backwards compatibility.

Changes in Result Specifications

In version 1, the `process(...)` method took a second argument, a ResultSpecification. Now it is set when changed and it's up to the annotator to store it in a local field and make it available when needed. This approach lets the annotator receive a specific signal (a method call) when the Result Specification changes. Previously, it would need to check on every call to see if it changed. The default impl base classes provide set/getResultSpecification(...) methods for this

Only one Capability Set

In version one, you can define multiple capability sets. These were not supported well, and for version two, this is now simplified - you should only use one capability set. (For backwards compatibility, if you use more, this won't cause a problem for now).

TextAnalysisEngine deprecated; use AnalysisEngine instead

TextAnalysisEngine has been deprecated - it is now no different than AnalysisEngine. Previous code that uses this should still continue to work, however.

Annotator Context deprecated; use UimaContext instead

The context for the Annotator is the same as the overall UIMA context. The impl base classes provide a getContext() method which returns now the UimaContext object.

DocumentAnalyzer tool uses XMI formats

The DocumentAnalyzer tool saves outputs in the new XMI serialization format. The AnnotationViewer and SemanticSearchGUI tools can read both the new XMI format and the previous XCAS format.

CAS Initializer deprecated

Example code that used CAS Initializers has been rewritten to not use this.

#### Backwards Compatibility

Other than the changes from IBM UIMA to Apache UIMA described above, most UIMA 1.x applications should not require additional changes to upgrade to UIMA 2.x. However, there are a few exceptions that UIMA 1.x users may need to be aware of:

- There have been some changes to ResultSpecifications. We do not guarantee 100% backwards compatibility for applications that made use of them, although most cases should work.

- For applications that deal with multiple subjects of analysis (Sofas), the rules that determine whether a component is Multi-View or Single-View have been made more consistent. A component is considered Multi-View if and only if it declares at least one inputSofa or outputSofa in its descriptor. This leads to the following incompatibilities in unusual cases:

  - It is an error if an annotator that implements the TextAnnotator or JTextAnnotator interface also declares inputSofas or outputSofas in its descriptor. Such annotators must be Single-View.

  - Annotators that implement GenericAnnotator but do not declare any inputSofas or outputSofas will now be passed the view of default Sofa instead of the Base CAS.

## Migrating from IBM UIMA to Apache UIMA

In Apache UIMA, several things have changed that require changes to user code and descriptors. A migration utility is provided which will make the required updates to your files. The most significant change is that the Java package names for all of the UIMA classes and interfaces have changed from what they were in IBM UIMA; all of the package names now start with the prefix `org.apache`.

### Running the Migration Utility

Before running the migration utility, be sure to back up your files, just in case you encounter any problems, because the migration tool updates the files in place in the directories where it finds them.

The migration utility is run by executing the script file `apache-uima/bin/ibmUimaToApacheUima.bat` (Windows) or `apache-uima/bin/ibmUimaToApacheUima.sh` (UNIX). You must pass one argument: the directory containing the files that you want to be migrated. Subdirectories will be processed recursively.

The script scans your files and applies the necessary updates, for example replacing the com.ibm package names with the new org.apache package names. For more details on what has changed in the UIMA APIs and what changes are performed by the migration script, see .

The script will only attempt to modify files with the extensions: java, xml, xmi, wsdd, properties, launch, bat, cmd, sh, ksh, or csh; and files with no extension. Also, files with size greater than 1,000,000 bytes will be skipped. (If you want the script to modify files with other extensions, you can edit the script file and change the `-ext` argument appropriately.)

If the migration tool reports warnings, there may be a few additional steps to take. The following two sections explain some simple manual changes that you might need to make to your code.

#### JCas Cover Classes for DocumentAnnotation

If you have run JCasGen it is likely that you have the classes `com.ibm.uima.jcas.tcas.DocumentAnnotation` and `com.ibm.uima.jcas.tcas.DocumentAnnotation_Type` as part of your code. This package name is no longer valid, and the migration utility does not move your files between directories so it is unable to fix this.

If you have not made manual modifications to these classes, the best solution is usually to just delete these two classes (and their containing package). There is a default version in the `uima-document-annotation.jar` file that is included in Apache UIMA. If you have made custom changes, then you should not delete the file but instead move it to the correct package `org.apache.uima.jcas.tcas`. For more information about JCas and DocumentAnnotation please see

#### JCas.getDocumentAnnotation

The deprecated method `JCas.getDocumentAnnotation` has been removed. Its use must be replaced with `JCas.getDocumentAnnotationFs`. The method `JCas.getDocumentAnnotationFs()` returns type `TOP`, so your code must cast this to type `DocumentAnnotation`. The reasons for this are described in .

### Manual Migration

The following are rare cases where you may need to take additional steps to migrate your code. You need only read this section if the migration tool reported a warning or if you are having trouble getting your code to compile or run after running the migration. For most users, attention to these things will not be required.

#### xi:include

The use of <xi:include> in UIMA component descriptors has been discouraged for some time, and in Apache UIMA support for it has been removed. If you have descriptors that use that, you must change them to use UIMA's <import> syntax instead. The proper syntax is described in .

#### Duplicate Methods Taking CAS and TCAS as Arguments

Because `TCAS` has been replaced by `CAS`, if you had two methods distinguished only by whether an argument type was `TCAS` or `CAS`, the migration tool will cause these to have identical signatures, which will be a compile error. If this happens, consider why the two variants were needed in the first place. Often, it may work to simply delete one of the methods.

#### Use of Undocumented Methods from the com.ibm.uima.util package

Undocumented Methods

Previous UIMA versions has some methods in the `com.ibm.uima.util` package that were for internal use and were not documented in the Javadoc. (There are also many methods in that package which are documented, and there is no issue with using these.) It is not recommended that you use any of the undocumented methods. If you do, the migration script will not handle them correctly. These have now been moved to `org.apache.uima.internal.util`, and you will have to manually update your imports to point to this location.

#### Use of UIMA Package Names for User Code

Package Names

If you have placed your own classes in a package that has exactly the same name as one of the UIMA packages (not recommended), this will cause problems when your run the migration script. Since the script replaces UIMA package names, all of your imports that refer to your class will get replaced and your code will no longer compile. If this happens, you can fix it by manually moving your code to the new Apache UIMA package name (i.e., whatever name your imports got replaced with). However, we recommend instead that you do not use Apache UIMA package names for your own code.

An even more rare case would be if you had a package name that started with a capital letter (poor Java style) AND was prefixed by one of the UIMA package names, for example a package named `com.ibm.uima.MyPackage`. This would be treated as a class name and replaced with `org.apache.uima.MyPackage` wherever it occurs.

#### CASException and CASRuntimeException now extend UIMA(Runtime)Exception

Changes to CAS Exceptions

This change may affect user code to a small extent, as some of the APIs on `CASException` and `CASRuntimeException` no longer exist. On the up side, all UIMA exceptions are now derived from the same base classes and behave the same way. The most significant change is that you can no longer check for the specific type of exception the way you used to. For example, if you had code like this:

    catch (CASRuntimeException e) {
      if (e.getError() == CASRuntimeException.ILLEGAL_ARRAY_SIZE) {
      // Do something in case this particular error is caught

you will need to replace it with the following:

    catch (CASRuntimeException e) {
      if (e.getMessageKey().equals(CASRuntimeException.ILLEGAL_ARRAY_SIZE)) {
      // Do something in case this particular error is caught

as the message keys are now strings. This change is not handled by the migration script.

## Apache UIMA Summary

### General

UIMA supports the development, discovery, composition and deployment of multi-modal analytics for the analysis of unstructured information and its integration with search technologies.

Apache UIMA includes APIs and tools for creating analysis components. Examples of analysis components include tokenizers, summarizers, categorizers, parsers, named-entity detectors etc. Tutorial examples are provided with Apache UIMA; additional components are available from the community.

Apache UIMA does not itself include a semantic search engine; instructions are included for incorporating the semantic search SDK from IBM's alphaWorks which can index the results of analysis and for using this semantic index to perform more advanced search.

### Programming Language Support

UIMA supports the development and integration of analysis algorithms developed in different programming languages.

The Apache UIMA project is both a Java framework and a matching C++ enablement layer, which allows annotators to be written in C++ and have access to a C++ version of the CAS. The C++ enablement layer also enables annotators to be written in Perl, Python, and TCL, and to interoperate with those written in other languages.

### Multi-Modal Support

The UIMA architecture supports the development, discovery, composition and deployment of multi-modal analytics, including text, audio and video. discuss this is more detail.

### Semantic Search Components

The Lucene search engine as of this writing (November, 2006) does not support searching with annotations. The site provides a download of a semantic search engine, a simple demo query tool, some documentation on the semantic search engine, and a component that connects the results of UIMA analysis to the indexer so that the annotations as well as key-words can be indexed.

Previous versions of the UIMA SDK (prior to the Apache versions) are available from IBM's alphaWorks. The source code for previous versions of the main UIMA framework is available on SourceForge.

## Summary of Apache UIMA Capabilities

Module | Description
UIMA Framework Core | A framework integrating core functions for creating, deploying, running and managing UIMA components, including analysis engines and Collection Processing Engines in collocated and/or distributed configurations. The framework includes an implementation of core components for transport layer adaptation, CAS management, workflow management based on declarative specifications, resource management, configuration management, logging, and other functions.
C++ and other programming language Interoperability | Includes C++ CAS and supports the creation of UIMA compliant C++ components that can be deployed in the UIMA run-time through a built-in JNI adapter. This includes high-speed binary serialization. Includes support for creating service-based UIMA engines. This is ideal for wrapping existing code written in different languages.
Framework Services and APIs | Note that interfaces of these components are available to the developer but different implementations are possible in different implementations of the UIMA framework.
CAS | These classes provide the developer with typed access to the Common Analysis Structure (CAS), including type system schema, elements, subjects of analysis and indices. Multiple subjects of analysis (Sofas) mechanism supports the independent or simultaneous analysis of multiple views of the same artifacts (e.g. documents), supporting multi-lingual and multi-modal analysis.
JCas | An alternative interface to the CAS, providing Java-based UIMA Analysis components with native Java object access to CAS types and their attributes or features, using the JavaBeans conventions of getters and setters.
Collection Processing Management (CPM) | Core functions for running UIMA collection processing engines in collocated and/or distributed configurations. The CPM provides scalability across parallel processing pipelines, check-pointing, performance monitoring and recoverability.
Resource Manager | Provides UIMA components with run-time access to external resources handling capabilities such as resource naming, sharing, and caching.
Configuration Manager | Provides UIMA components with run-time access to their configuration parameter settings.
Logger | Provides access to a common logging facility.
Tools and Utilities
JCasGen | Utility for generating a Java object model for CAS types from a UIMA XML type system definition.
Saving and Restoring CAS contents | APIs in the core framework support saving and restoring the contents of a CAS to streams using an XMI format.
PEAR Packager for Eclipse | Tool for building a UIMA component archive to facilitate porting, registering, installing and testing components.
PEAR Installer | Tool for installing and verifying a UIMA component archive in a UIMA installation.
PEAR Merger | Utility that combines multiple PEARs into one.
Component Descriptor Editor | Eclipse Plug-in for specifying and configuring component descriptors for UIMA analysis engines as well as other UIMA component types including Collection Readers and CAS Consumers.
CPE Configurator | Graphical tool for configuring Collection Processing Engines and applying them to collections of documents.
Java Annotation Viewer | Viewer for exploring annotations and related CAS data.
CAS Visual Debugger | GUI Java application that provides developers with detailed visual view of the contents of a CAS.
Document Analyzer | GUI Java application that applies analysis engines to sets of documents and shows results in a viewer.
Example Analysis Components
Database Writer | CAS Consumer that writes the content of selected CAS types into a relational database, using JDBC. This code is in cpe/PersonTitleDBWriterCasConsumer.
Annotators | Set of simple annotators meant for pedagogical purposes. Includes: Date/time, Room-number, Regular expression, Tokenizer, and Meeting-finder annotator. There are sample CAS Multipliers as well.
Flow Controllers | There is a sample flow-controller based on the whiteboard concept of sending the CAS to whatever annotator hasn't yet processed it, when that annotator's inputs are available in the CAS.
XMI Collection Reader, CAS Consumer | Reads and writes the CAS in the XMI format
File System Collection Reader | Simple Collection Reader for pulling documents from the file system and initializing CASes.
Components available from
Semantic Search CAS Indexer | A CAS Consumer that uses the semantic search engine indexer to build an index from a stream of CASes. Requires the semantic search engine (available from the same place).