# All Classes and Interfaces

Class
Description
AbortCasProcessorException
Exception to notify the CPM to disable a Cas Processor.
AbortCPMException
/** Exception to notify the CPM to terminate itself.
AbstractCas
The base interface extended by all CAS (Common Analysis System) interfaces in the UIMA SDK.
AbstractCas_ImplBase
Base class from which CAS implementations should extend.
AggregateAnalysisEngine_impl
Reference implementation of `AnalysisEngine`.
AllowedValue
Represents an allowed value for an "enumerated" type.
AllowedValue_impl
Reference implementation of `AllowedValue`.
AllowPreexistingFS
AnalysisComponent
Analysis Components are the primitive "building blocks" from which UIMA solutions are built.
AnalysisComponent_ImplBase
Implementation base class for AnalysisComponents.
AnalysisEngine
An Analysis Engine is a component responsible for analyzing unstructured information, discovering and representing semantic content.
AnalysisEngineDescription
An `AnalysisEngineDescription` contains all of the information needed to instantiate and use an `AnalysisEngine`.
AnalysisEngineDescription_impl
Reference implementation of `AnalysisEngineDescription`.
AnalysisEngineFactory_impl
Resource Factory that handles `AnalysisEngineDescription` and `TaeDescription` elements.
AnalysisEngineImplBase
Provides functionality common to Analysis Engine implementations.
AnalysisEngineManagement
Monitoring and management interface to an AnalysisEngine.
AnalysisEngineManagement.State
AnalysisEngineManagementImpl
Implements Monitoring/Management interface to an AnalysisEngine.
AnalysisEngineManagementImplMBean
JMX MBean interface for monitoring AnalysisEngine performance stats.
AnalysisEngineMetaData
Encapsulates all of the metadata for an Analysis Engine.
AnalysisEngineMetaData_impl
Reference implementation of `AnalysisEngineMetaData`.
AnalysisEnginePerformanceReports
A class that is useful for generating an Analysis Engine performance report from a `ProcessTrace` object.
AnalysisEngineProcessException
An `AnalysisEngineProcessException` may be thrown by an Analysis Engine's process method, indicating that a failure occurred during processing.
AnalysisEngineProcessorAdapter
Base class for analysis engine processor adapters.
AnalysisEngineProcessorStub
A stub that calls a remote AnalysisEngine service.
AnalysisEngineService_impl
Convenience base class for Analysis Engine Services.
AnalysisEngineServiceAdapter
Base class for analysis engine service adapters.
AnalysisEngineServiceStub
A stub that calls a remote AnalysisEngine service.
AnalysisEngineUtils
Static utility methods relating to analysis engines.
AnalysisProcessData
Deprecated.
AnalysisProcessData_impl
Deprecated.
since v2.0
AnalysisSequenceCapabilityNode
A `AnalysisSequenceCapabilityNode` is a node element of the `CapabilityLanguageFlowObject`.
Annotation
the JCas class model for the CAS type uima.cas.Annotation.
Annotation_Type
Deprecated.
AnnotationBase
the JCas class model for the CAS type uima.cas.AnnotationBase.
AnnotationBase_Type
Deprecated.
AnnotationBaseFS
Annotation Base API.
AnnotationBaseImpl
Deprecated.
use AnnotationBase instead
AnnotationFS
Interface for Annotation Feature Structures.
AnnotationImpl
Deprecated.
use Annotation instead
AnnotationImplException
Exception class for package org.apache.uima.cas.impl.
AnnotationIndex<T extends AnnotationFS>
An annotation index provides additional iterator functionality that applies only to instances of `uima.tcas.Annotation` (or its subtypes).
AnnotationPredicates
AnnotationTree<T extends AnnotationFS>
Represents an annotation tree.
AnnotationTreeImpl<T extends AnnotationFS>
Implementation of annotation tree.
AnnotationTreeNode<T extends AnnotationFS>
Represents a node in an annotation tree.
AnnotationTreeNodeImpl<T extends AnnotationFS>
Annotator_ImplBase
Base class for all annotators.
Annotator_ImplBase
Deprecated.
As of release 2.3.0, use CasAnnotator_ImplBase or JCasAnnotator_ImplBase instead
AnnotatorConfigurationException
An `AnnotatorConfigurationException` is thrown by an annotator if the settings of its configuration parameters are invalid.
AnnotatorContext
Deprecated.
As of release 2.3.0, use UimaContext instead
AnnotatorContext_impl
Reference implementation of `AnnotatorContext`.
AnnotatorContextException
An `AnnotatorContextException` is thrown by an `AnnotatorContext` if it cannot complete the invoked operation due to a failure in the underlying implementation.
AnnotatorInitializationException
An `AnnotatorInitializationException` may be thrown by an annotator's initialize method, indicating that the annotator failed to successfully initialize itself.
AnnotatorProcessException
An `AnnotatorProcessException` may be thrown by an annotator's process method, indicating that a failure occurred during processing.
ArrayFS<E extends FeatureStructure>
Feature structure array interface.
ArrayFSImpl<E extends FeatureStructure>
Deprecated.
use FSArray instead
ASB
The Analysis Structure Broker (`ASB`) is the component responsible for the details of communicating with Analysis Engines that may potentially be distributed across different physical machines.
ASB_impl
A simple `ASB` implementation.
Attribute
A simple name, value pair that is specified as part of a `Style` to further define its behavior.
Attribute_impl
AutoCloseableNoException
protectIndexes returns instances of this, rather than AutoCloseable, to permit users to use try with resources without a catch for Exception.
BaseAnnotator
Base interface for annotators in UIMA SDK v1.x.
BaseCollectionReader
The Base `CollectionReader` interface.
BaseCPM
The Base CPM interface is a lower-level interface to the Collection Processing Manager.
BaseStatusCallbackListener
Interface for a Listener that receives notification from the `BaseCPM` as various events occur.
BinaryCasSerDes
Binary (mostly non compressed) CAS deserialization The methods in this class were originally part of the CASImpl, and were moved here to this class for v3 Binary non compressed CAS serialization is in class CASSerializer, but that class uses routines and data structures in this class.
BinaryCasSerDes4
User callable serialization and deserialization of the CAS in a compressed Binary Format This serializes/deserializes the state of the CAS, assuming that the type information remains constant.
BinaryCasSerDes4.Compression
BinaryCasSerDes4.CompressLevel
Compression alternatives
BinaryCasSerDes4.CompressStrat
BinaryCasSerDes6
User callable serialization and deserialization of the CAS in a compressed Binary Format This serializes/deserializes the state of the CAS.
BinaryCasSerDes6.CompressLevel
Compression alternatives
BinaryCasSerDes6.CompressStrat
BinaryCasSerDes6.ReuseInfo
Info reused for 1) multiple serializations of same cas to multiple targets (a speedup), or 2) for delta cas serialization, where it represents the fsStartIndex info before any mods were done which could change that info, or 3) for deserializing with a delta cas, where it represents the fsStartIndex info at the time the CAS was serialized out..
BooleanArray
JCas class model for BooleanArray
BooleanArrayFS
Boolean array interface.
BooleanArrayFSImpl
Deprecated.
use BooleanArray instead
BooleanConstraint
Implementation of boolean match constraint.
BuiltinTypeKinds
Constants representing Built in type collections String Sets: creatableArrays primitiveTypeNames == noncreatable primitives creatableBuiltinJcas (e.g.
ByteArray
JCas class model for ByteArray
ByteArrayFS
Byte array interface.
ByteArrayFSImpl
Deprecated.
use ByteArray instead
Capability
A `Capability` defines an operation that an Resource can carry out.
Capability_impl
Reference implementation of `Capability`
CapabilityLanguageFlow
A `CapabilityLanguageFlow` is a simple type of `FlowConstraints` that specifies the complete flow as a capabilityLanguage sequence.
CapabilityLanguageFlow_impl
A `CapabilityLanguageFlow` is a simple type of `FlowConstraints` that specifies the complete flow as a capabilityLanguage sequence.
CapabilityLanguageFlowController
FlowController for the CapabilityLanguageFlow, which uses a linear flow but may skip some of the AEs in the flow if they do not handle the language of the current document or if their outputs have already been produced by a previous AE in the flow.
CapabilityLanguageFlowObject
The `CapabilityLanguageAnalysisSequence` is used for a `CapabilityLanguageFlow`.
CAS
Object-oriented CAS (Common Analysis System) API.
CASAdminException
CasAnnotator_ImplBase
Base class to be extended by Annotators that use the `CAS` interface.
CasCompare
Used by tests for Binary Compressed de/serialization code.
CASCompleteSerializer
This is a small object which contains - CASMgrSerializer instance - a Java serializable form of the type system + index definitions - CASSerializer instance - a Java serializable form of the CAS including lists of which FSs are indexed
CasConsumer
Any component that operates on analysis results produced by a UIMA analysis engine.
CasConsumer_ImplBase
Base class for CAS Consumers in UIMA SDK v1.x, which developers should extend with their own CAS Consumer implementation classes.
CasConsumerDescription
An `CasConsumerDescription` contains all of the information needed to instantiate and use an `CasConsumer`.
CasConsumerDescription_impl
CasConsumerFactory_impl
Specialized Resource Factory for producing CasConsumers.
CasCopier
Utility class for doing deep copies of FeatureStructures from one CAS to another.
CasCreationUtils
Utilities for creating and setting up CASes.
CasData
Interface for directly accessing and manipulating the data in the Common Analysis Structure.
CasDataCollectionReader
A `CasDataCollectionReader` is used to iterate over the elements of a Collection.
CasDataCollectionReader_ImplBase
Base class from which to extend when writing Collection Readers that use the `CasData` interface to access the CAS.
CasDataConsumer
Any component that operates on analysis results produced by a UIMA CasDataProcessor.
CasDataConsumer_ImplBase
Base class from which to extend when writing CAS Consumers that use the `CasData` interface to access the CAS.
CasDataImpl
CasDataInitializer
Deprecated.
As of v2.0, CAS Initializers are deprecated.
CasDataInitializer_ImplBase
Deprecated.
As of v2.0, CAS Initializers are deprecated.
CasDataProcessor
Interface for CAS processors that want to interact directly with the `CasData`.
CasDataStatusCallbackListener
Interface for a Listener that receives notification from the `CollectionProcessingManager` as various events occur.
CasDataToXCas
Takes a CasData and generates XCAS SAX events.
CasDataUtils
Some utilities for dealing with CasData
CasDefinition
Encapsulates information that defines how to create a CAS.
CASException
Exception class for package org.apache.uima.cas.
CASFactory
Factory class to create CASMgr objects.
CasFlow_ImplBase
Convenience base class for Flow objects that use the CAS interface.
CasFlowController_ImplBase
Base class to be extended by FlowControllers that use the `CAS` interface.
CASImpl
Implements the CAS interfaces.
CASImpl.FsChange
Journaling changes for computing delta cas.
CasInitializer
Deprecated.
As of v2.0, CAS Initializers are deprecated.
CasInitializer_ImplBase
Deprecated.
As of v2.0, CAS Initializers are deprecated.
CasInitializerDescription
Deprecated.
As of v2.0, CAS Initializers are deprecated.
CasInitializerDescription_impl
Deprecated.
As of v2.0, CAS Initializers are deprecated.
CasInitializerFactory_impl
Deprecated.
As of v2.0, CAS Initializers are deprecated.
CasIOUtils
A collection of static methods aimed at making it easy to
CasIterator
An iterator over a collection of CASes.
CasLoadMode
Used with CasIOUtils, maybe elsewhere, to indicate how CASes are to be loaded or saved.
CasManager
Manages creation and pooling of CAS instances within an AnalysisEngine.
CasManager_impl
Simple CAS Manager Implementation used in the AnalysisEngine framework.
CASMgr
Class comment for CASMgr.java goes here.
CASMgrSerializer
Container for serialized CAS typing information.
CasMultiplier_ImplBase
Base class to be extended by CAS Multipliers that use the `CAS` interface.
CasObjectProcessor
Interface for CAS Processors that want to use the full `CAS` implementation.
CasOwner
Represents the "owner" of a CAS.
CasPool
This class represents a simple pool of `CAS` instances.
CasPoolManagement
Management interface to a `CasPool`.
CasPoolManagementImpl
Implements Monitoring/Management interface to a CasPool.
CasPoolManagementImplMBean
JMX MBean interface for monitoring CASPool state.
CasProcessor<E extends Throwable>
A functional interface for a CAS processor.
CasProcessor
Base interface for a component that can process a CAS.
CasProcessorAnnotator
CasProcessorConfigurationParameterSettings
Contains configuration parameter settings for a CAS Processor.
CasProcessorDeploymentParam
An object that holds configuration information used for building CPE Descriptor.
CasProcessorDeploymentParams
An object that contains all `CasProcessorDeploymentParam` instances.
CasProcessorErrorHandling
An object to contains configuration specific to error handling applicable to every CasProcossor.
CasProcessorErrorRateThreshold
An object to contains configuration specific to error handling applicable to every CasProcessor.
CasProcessorExecArg
An object containing an arbitrary value that will passed to a program launched by the CPE.
CasProcessorExecArgs
An object containing all `CasProcessorExecArg` instances.
CasProcessorExecutable
An object containing configuration for a program that the CPE will use to launch CasProcessor.
CasProcessorFilter
Object containing a filter expression used by the CPE to route CAS's to CasProcessor.
CasProcessorMaxRestarts
An object that holds configuration related to handling max restarts for CasProcessors.
CasProcessorRunInSeperateProcess
An object that holds configuration that is part of the CPE descriptor.
CasProcessorRuntimeEnvParam
An object that holds configuration that is part of the CPE descriptor.
CasProcessorTimeout
An object that holds configuration that is part of the CPE descriptor.
CASRuntimeException
Runtime exception class for package org.apache.uima.cas.
CasSeqAddrMaps
Used by Binary serialization form 4 and 6 Manage the conversion of FSs to relative sequential index number, and back Manage the difference in two type systems both size of the FSs and handling excluded types During serialization, these maps are constructed before serialization.
CASSerializer
This object has 2 purposes.
CasSerializerSupport
CAS serializer support for XMI and JSON formats.
CasSerializerSupport.CasSerializerSupportSerialize
CasState
states the CAS can be in
CasToInlineXml
Generates an *approximate* inline XML representation of a CAS.
CasTypeSystemMapper
This class gets initialized with two type systems, and then provides resources to map type and feature codes between them.
ChildUimaContext_impl
Reference implementation of `AnnotatorContext`.
CollectionException
Thrown to indicate that there is a problem with some aspect of a Collection.
CollectionProcessingEngine
A `CollectionProcessingEngine` (CPE) processes a collection of artifacts (for text analysis applications, this will be a collection of documents) and produces collection-level results.
CollectionProcessingManager
A `CollectionProcessingManager` (CPM) manages the application of an `AnalysisEngine` to a collection of artifacts.
CollectionReader
A `CollectionReader` is used to iterate over the elements of a Collection.
CollectionReader_ImplBase
Base class for Collection Readers, which developers should extend with their own Collection Reader implementation classes.
CollectionReaderDescription
An `CollectionReaderDescription` contains all of the information needed to instantiate and use an `CollectionReader`.
CollectionReaderDescription_impl
CollectionReaderFactory_impl
Specialized Resource Factory for producing CollectionReaders.
CommonArrayFS<E>
Common parts of the Array interfaces.
CommonArrayFSImpl
Deprecated.
CommonList
This class is the super class of list nodes (both empty and non empty)
CommonPrimitiveArray<T>
This interface is implemented by arrays of non-FeatureStructure components boolean, byte, short, int, long, float, double, String, JavaObject Internal Use Only.
CommonSerDes
Common de/serialization
CommonSerDes.Header
HEADERS Serialization versioning There are 1 or 2 words used for versioning.
CommonSerDes.Reading
byte swapping reads of integer forms
CommonSerDesSequential
Common de/serialization for plain binary and compressed binary form 4 which both used to walk the cas using the sequential, incrementing id approach Lifecycle: There is 0/1 instance per CAS, representing the FSs at some point in time in that CAS.
ComponentInfo
Information that a CAS needs to know about the component that's currently operating on it.
CompositeResourceFactory
A type of `ResourceFactory` that produces resources by delegating to other Resource Factories.
CompositeResourceFactory_impl
A registry containing (ResourceSpecifier Class, `ResourceFactory`) pairs.
ConcurrentHashMapWithProducer<K,V>
A concurrent map supporting a value-creating get.
ConfigurableDataResource_impl
A simple `DataResource` implementation that can read data from a file via a URL.
ConfigurableDataResourceSpecifier
A type of `ResourceSpecifier` that locates a resource file using its URL.
ConfigurableDataResourceSpecifier_impl
Reference implementation of `FileResourceSpecifier`.
ConfigurableResource
A `Resource` that has configuration parameters that can be changed after the Resource has been instantiated.
ConfigurableResource_ImplBase
Implementation base class for `ConfigurableResource`s.
ConfigurationGroup
A group of `ConfigurationParameter`s.
ConfigurationGroup_impl
Reference implementation of `ConfigurationGroup`.
ConfigurationManager
Manages the configuration parameters of all components within a possibly aggregate `Resource`.
ConfigurationManager_impl
Basic standalone Configuration Manager implmentation.
ConfigurationManagerImplBase
Convenience base class for Configuration Manager implementations.
ConfigurationParameter
Completely specifies a configuration parameter on a UIMA resource.
ConfigurationParameter_impl
Reference implementation of `ConfigurationParameter`.
ConfigurationParameterDeclarations
The declarations of configuration parameters in a Resource.
ConfigurationParameterDeclarations_impl
ConfigurationParameterSettings
The values for `ConfigurationParameter`s in a Resource.
ConfigurationParameterSettings_impl
Reference implementation of `ConfigurationParameterSettings`.
Constants
Some constants used by the UIMA framework.
Constants
Constants
ConstraintFactory
Methods to create `FSMatchConstraint`s for filtered iterators or other use.
ConstraintFactoryImpl
Implementation of the ConstraintFactory interface.
ConsumerCasUtils
CopyOnWriteIndexPart<T extends FeatureStructure>
common APIs supporting the copy on write aspect of index parts
CpeCasProcessor
An object that holds configuration that is part of the CPE descriptor.
CpeCasProcessors
An object that holds configuration that is part of the CPE descriptor.
CpeCheckpoint
An object that holds configuration that is part of the CPE descriptor.
CpeCollectionReader
An object that holds configuration that is part of the CPE descriptor.
CpeCollectionReaderCasInitializer
Deprecated.
As of v2.0 CAS Initializers are deprecated.
CpeCollectionReaderIterator
An object that holds configuration that is part of the CPE descriptor.
CpeComponentDescriptor
An object that holds configuration that is part of the CPE descriptor.
CpeConfiguration
An object that holds configuration that is part of the CPE descriptor.
CpeDescription
Java representation of a Collection Processing Engine (CPE) XML descriptor.
CpeDescriptorException
CpeInclude
An object that holds configuration that is part of the CPE descriptor.
CpeIntegratedCasProcessor
An object that holds configuration that is part of the CPE descriptor.
CpeLocalCasProcessor
An object that holds configuration that is part of the CPE descriptor.
CpeRemoteCasProcessor
An object that holds configuration that is part of the CPE descriptor.
CpeResourceManagerConfiguration
An object that holds configuration that is part of the CPE descriptor.
CpeSofaMapping
CpeSofaMappings
CpeTimer
CppUimajEngine
CustomResourceFactory_impl
Resource Factory that handles `CustomResourceSpecifier` elements.
CustomResourceSpecifier
A type of `ResourceSpecifier` that specifically names the Java class that should be created.
CustomResourceSpecifier_impl
Implementation of `CustomResourceSpecifier`.
DataIO
Methods for working with Data during I/O
DataResource
`DataResource` is a simple resource that provides access to data.
DataResource_impl
A simple `DataResource` implementation that can read data from a file via a URL.
DebugFSLogicalStructure
DebugFSLogicalStructure.IndexInfo
Class holding information about an FSIndex Includes the "label" of the index, and a ref to the CAS this index contents are in.
DebugFSLogicalStructure.ViewInfo
Class holding info about a View/Sofa.
DebugNameValuePair
DocumentAnnotation
The JCas class definition for the CAS `DocumentAnnotation` type.
DoubleArray
JCas class model for DoubleArray
DoubleArrayFS
Double array interface.
DoubleArrayFSImpl
Deprecated.
use DoubleArray instead
EmptyCasIterator
Trivial CasIterator that returns no CASes.
EmptyFloatList
EmptyFSList<T extends TOP>
EmptyIntegerList
EmptyList
a marker interface for empty lists
EmptyStringList
EntityProcessStatus
Contains information about the successful or unsuccessful processing of an entity (an element of a collection) by the `CollectionProcessingManager`.
ExternalResourceBinding
Binds an `ExternalResourceDependency` to an `ExternalResourceDescription`.
ExternalResourceBinding_impl
ExternalResourceDependency
An `ExternalResourceDependency` object describes an resources's requirements on an external resource.
ExternalResourceDependency_impl
Reference implementation of `ExternalResourceDependency`.
ExternalResourceDescription
An `ExternalResourceDescription` object describes a resource that is loaded in the `ResourceManager` and may be shared between components.
ExternalResourceDescription_impl
Reference implementation of `AnalysisEngineDescription`.
Feature
The interface that describes features in the type system.
FeatureDescription
A description of a CAS feature.
FeatureDescription_impl
Reference implementation of `FeatureDescription`.
FeatureImpl
The implementation of features in the type system.
FeatureImpl_jcas_only
The implementation of jcas-only features in the type system.
FeaturePath
Interface for a feature path.
FeatureStructure
An object in the CAS.
FeatureStructure
Interface for feature structures.
FeatureStructureImpl
FeatureStructureImpl
Deprecated.
use TOP instead
FeatureStructureImplC
Feature structure implementation (for non JCas and JCas) Each FS has - int data - used for boolean, byte, short, int, long, float, double data -- long and double use 2 int slots - may be null if all slots are in JCas cover objects as fields - ref data - used for references to other Java objects, such as -- strings -- other feature structures -- arbitrary Java Objects - may be null if all slots are in JCas cover objects as fields - an id: an incrementing integer, starting at 1, per CAS, of all FSs created for that CAS - a ref to the casView where this FS was created - a ref to the TypeImpl for this class -- can't be static - may be multiple type systems in use
FeatureStructureImplC.PrintReferences
FeatureValue
The base interface for the value of a feature.
FeatureValuePath
Deprecated.
use `FeaturePath`
FeatureValuePathImpl
Contains CAS Type and Feature objects to represent a feature path of the form feature1/.../featureN.
FileLanguageResource_impl
An implementation of `ParameterizedDataResource` for language-based resources.
FileLanguageResourceSpecifier
A type of `ResourceSpecifier` that locates a resource file using its URL, where the URL depends on an ISO language identifier.
FileLanguageResourceSpecifier_impl
Reference implementation of `FileLanguageResourceSpecifier`.
FileResourceSpecifier
A type of `ResourceSpecifier` that locates a resource file using its URL.
FileResourceSpecifier_impl
Reference implementation of `FileResourceSpecifier`.
FileUtil
The `FileUtil` class provides utility methods for working with general files.
FileUtil.DirFileFilter
The `DirFileFilter` class allows to filter files based on specified directory path and filename extension.
FileUtil.ExtFilenameFilter
The `ExtFileFilter` allows to filter file names based on the specified filename extension.
FileUtil.FileTimeComparator
The `FileTimeComparator` class allows comparing 'last modified' time in 2 given `File` objects.
FileUtil.NameFileFilter
The `NameFileFilter` class allows to filter files based on specified file name.
FileUtils
Some utilities for handling files.
Filter
Specifies a constraint that matches against annotations in the CAS.
Filter_impl
FinalStep
Indicates that a CAS has finished being processed by the aggregate.
FixedFlow
A `FixedFlow` is a simple type of `FlowConstraints` that specifies the complete flow as a fixed sequence.
FixedFlow_impl
Reference implementation of `FixedFlow`.
FixedFlowController
Simple FlowController that invokes components in a fixed sequence.
FloatArray
Java Cas model for Cas FloatArray.
FloatArrayFS
Interface for CAS float arrays.
FloatArrayFSImpl
Deprecated.
use FloatArray instead
FloatList
Flow
A Flow object is responsible for routing a single CAS through an Aggregate Analysis Engine.
FlowConstraints
A `FlowConstraints` object represents constraints on the order of execution of delegate Analysis Engines within an aggregate Analysis Engine.
FlowContainer
Container for Flow objects, to handle CAS conversions and performance timing.
FlowController
FlowControllers are components that decide how to route CASes within Aggregate Analysis Engines.
FlowController_ImplBase
Implementation base class for FlowControllers.
FlowControllerContainer
Container for a FlowController.
FlowControllerContext
A subtype of `UimaContext` used by `FlowController` components.
FlowControllerContext_impl
Implementation of FlowControllerContext.
FlowControllerDeclaration
Declares which FlowController is used by the Aggregate Analysis Engine.
FlowControllerDeclaration_impl
Declares which FlowController is used by the Aggregate Analysis Engine.
FlowControllerDescription
A `FlowControllerDescription` contains all of the information needed to instantiate and use a `FlowController`.
FlowControllerDescription_impl
Implementation of `FlowControllerDescription`.
FSArray<T extends FeatureStructure>
Java Class model for Cas FSArray type extends FeatureStructure for backwards compatibility when using FSArray with no typing.
FSArrayList<T extends TOP>
An ArrayList type containing Feature Structures, for UIMA Has all the methods of List Implements the select(...) APIs
FSBooleanConstraint
Interface for a boolean constraint.
FSBooleanConstraintImpl
See interface for documentation.
FSClassRegistry
There is one **class** instance of this per UIMA core class loader.
FSClassRegistry.JCasClassInfo
One instance per JCas class defined for it, per class loader - per class loader, because different JCas class definitions for the same name are possible, per class loader Kept in maps, per class loader.
FSComparator
UNUSED V3 backwards compat only Delete REplace with Comparator<FeatureStructure> or the like.
FSComparators
There are 4 kinds of comparators for the combinations of comparing - with or without the "id" - with or without type order (with only includes typeOrder if there is such a key included)
FSConstraint
Interface for feature structure constraints.
FSFloatConstraint
Interface for a float constraint.
FSGenerator<T extends FeatureStructure>
Deprecated.
unused in v3, only present to avoid compile errors in unused v2 classes
FsGenerator3
A Functional Interface for generating V3 Java Feature Structures
FsGeneratorArray
A Functional Interface for generating Java Feature Structures NO LONGER USED
FSHashSet<T extends TOP>
a hash set of Feature Structures Is Pear aware - stores non-pear versions but may return pear version in pear contexts Updated by JCasGen Fri Jan 20 11:55:59 EST 2017 XML source: C:/au/svnCheckouts/branches/uimaj/v3-alpha/uimaj-types/src/main/descriptors/java_object_type_descriptors.xml
FSImplComparator
UNUSED V3, backwards compat only Interface to compare two feature structures, represented by their addresses.
FSIndex<T extends FeatureStructure>
Feature structure index access interface.
FsIndex_annotation<T extends AnnotationFS>
Implementation of annotation indexes.
FsIndex_bag<T extends FeatureStructure>
Used for UIMA FS Bag Indexes Uses ObjHashSet to hold instances of FeatureStructures
FsIndex_flat<T extends FeatureStructure>
Common part of flattened indexes, used for both snapshot iterators and flattened sorted indexes built from passed in instance of FsIndex_iicp
FsIndex_set_sorted<T extends FeatureStructure>
Common index impl for set and sorted indexes.
FsIndex_singletype<T extends FeatureStructure>
The common (among all index kinds - set, sorted, bag) info for an index over 1 type (excluding subtypes) SubClasses FsIndex_bag, FsIndex_flat, FsIndex_set_sorted, define the actual index repository for each kind.
FsIndex_snapshot<T extends FeatureStructure>
Implementation of light-weight wrapper of normal indexes, which support special kinds of iterators base on the setting of IteratorExtraFunction
FsIndexCollection
Description of a collection of CAS feature structure indexes.
FsIndexCollection_impl
FsIndexCollectionProvider
FSIndexComparator
This interface describes objects which specify the comparison used in indexes for keys.
FSIndexComparatorImpl
Specifies the comparison to be used for an index, in terms of - the keys and the typeorder, in an order - the standard/reverse ordering
FsIndexDescription
A description of a CAS feature structure index.
FsIndexDescription_impl
FsIndexKeyDescription
A description of a key defining a CAS feature structure index.
FsIndexKeyDescription_impl
FSIndexRepository
Repository of indexes over feature structures.
FSIndexRepositoryImpl
There is one instance of this class per CAS View.
FSIndexRepositoryMgr
Repository of indexes.
FSIntConstraint
Interface for an integer constraint.
FSIterator<T extends FeatureStructure>
Iterator over feature structures.
FsIterator_multiple_indexes<T extends FeatureStructure>
Common code for both aggregation of indexes (e.g.
FsIterator_singletype<T extends FeatureStructure>
FsIterator_subtypes_ordered<T extends FeatureStructure>
Performs an ordered iteration among a set of iterators, each one corresponding to the type or subtype of the uppermost type.
FsIterator_subtypes_snapshot<T extends FeatureStructure>
FSIteratorImplBase<T extends FeatureStructure>
Version 2 compatibility only, not used internally in version 3 Base class for FSIterator implementations.
FSLinkedHashSet<T extends TOP>
a hash set of Feature Structures Is Pear aware - stores non-pear versions but may return pear version in pear contexts Updated by JCasGen Fri Jan 20 11:55:59 EST 2017 XML source: C:/au/svnCheckouts/branches/uimaj/v3-alpha/uimaj-types/src/main/descriptors/java_object_type_descriptors.xml
FSList<T extends TOP>
T extends TOP, v2 already mandated TOP for set/get
FSMatchConstraint
Interface for feature structure matching constraints.
FSRefIterator
FSStringConstraint
Interface for a String constraint.
FSTypeConstraint
Interface for type constraint.
GenericAnnotator
Deprecated.
As of release 2.3.0, use CasAnnotator_ImplBase or JCasAnnotator_ImplBase instead
GenericAnnotator_ImplBase
Deprecated.
As of release 2.3.0, use CasAnnotator_ImplBase or JCasAnnotator_ImplBase instead
Heap
the v2 CAS heap - used in modeling some binary (de)serialization
I18nExceptionI
Like InternationalizedException, but is an interface with default methods.
Id2FS
A map from ints representing FS id's (or "addresses") to those FSs There is one map instance per CAS (all views).
Import
An import declaration.
Import_impl
IndexBuildItem
An individual item within a `IndexBuildSpecification`.
IndexBuildItem_impl
IndexBuildSpecification
Determines how a `CAS` get indexed with a UIMA-compliant search engine.
IndexBuildSpecification_impl
IndexingException
Thrown by the Index to indicate that a failure has occurred during indexing.
IndexRule
A rule that specifies indexing behavior.
IndexRule_impl
InstallationController
The `InstallationController` class allows installing PEAR files that contain UIMA compliant components.
InstallationController.InstallationMonitor
The `InstallationMonitor` interface defines methods required for notifying of component installation status and location of the installed PEAR packages.
InstallationController.PackageSelector
The `PackageSelector` interface defines methods required for manually or automatically selecting installed PEAR package root directories and PEAR package files.
InstallationController.TestStatus
The `TestStatus` class encapsulates attributes related to the results of the 'serviceability' verification test.
InstallationDescriptor
The `InstallationDescriptor` class encapsulates all elements and parameters included in the XML Installation Descriptor file.
InstallationDescriptor.ActionInfo
The `ActionInfo` class defines 'installation action' attributes.
InstallationDescriptor.ArgInfo
The `ArgInfo` class defines attributes of a service command argument.
InstallationDescriptor.ComponentInfo
The `ComponentInfo` class defines UIMA component attributes.
InstallationDescriptor.ServiceInfo
The `ServiceInfo` class defines attributes of a 'service' component.
InstallationDescriptorHandler
The `InstallationDescriptorHandler` class allows parsing XML installation descriptor files, creating instances of the `InstallationDescriptor` class.
InstallationProcessor
The `InstallationProcessor` class implements operations specified in the installation descriptor.
InstallationTester
The `InstallationTester` application allows performing simple verification of the installed UIMA compliant component by using standard UIMA framework interface.
InstrumentationFacility
The `InstrumentationFacility` interface defines a standard way for UIMA components to be instrumented for performance evaluation.
Int2FS<T extends TOP>
A map from ints to Feature Structures Is Pear aware - stores non-pear versions but may return pear version in pear contexts
IntArrayFS
Interface for CAS int arrays.
IntArrayFSImpl
Deprecated.
use IntegerArray instead
IntegerArray
The Java Class model corresponding to the Cas IntegerArray_JCasImpl type.
IntegerArrayList
An ArrayList type containing ints, for UIMA - implements a subset of the List API, Iterable<Integer>, IntListIterator.
IntegerList
IntEntry<T>
like Entry<k, v> except the k is an int.
InternationalizedException
The `InternationalizedException` class adds internationalization support to the standard functionality provided by `java.lang.Exception`.
InternationalizedRuntimeException
The `InternationalizedRuntimeException` class adds internationalization support to the standard functionality provided by `java.lang.RuntimeException`.
InvalidXMLException
Thrown by the `XMLParser` to indicate that an XML document is invalid or does not specify a valid object of the desired class.
IteratorNvc<E>
An Iterator with an extra method nextNvc, which skips the validity check
JCas
Java Cover Classes based Object-oriented CAS (Common Analysis System) API.
JCasAnnotator_ImplBase
Base class to be extended by Annotators that use the `JCas` interface.
JCasClassProvider
JCasFlow_ImplBase
Convenience base class for Flow objects that use the JCas interface.
JCasFlowController_ImplBase
Base class to be extended by FlowControllers that use the `JCas` interface.
JCasHashMap
Version 3 (2016, for Java 8) of map between id's (ints) JCasCover Objects Note: in the general case, the cover object may *not* be a JCas one, but rather the general one This happens if there is no JCas cover object defined for the type.
JCasImpl
implements the supporting infrastructure for JCas model linked with a Cas.
JCasIterator
An iterator over a collection of JCAS objects.
JCasIteratorWrapper
Wraps a CasIterator as a JCasIterator
JCasMultiplier_ImplBase
Base class to be extended by CAS Multipliers that use the `CAS` interface.
JCasPool
This class represents a simple pool of `JCas` instances.
JCasProcessor<E extends Throwable>
A functional interface for a JCas processor.
JCasProcessorAnnotator
JCasRegistry
Maintains a registry of JCas cover classes that have been loaded in order to be able to assign a unique low-value positive int index to each loaded JCas class.
JFSIndexRepository
Provides the same function as the FSIndexRepository except that the variants that take a "type" argument take type arguments obtainable easily from the JCas type.
JFSIndexRepositoryImpl
JMSMessagingSpecifier
JsonCasSerializer
CAS serializer for JSON formats.
JsonCasSerializer.JsonContextFormat
The serialization can optionally include context information in addition to the feature structures.
JsonContentHandlerJacksonWrapper
Utility class that generates JSON output for UIMA descriptors and CASs This class is built as a wrapper for a popular open-source implementation of JSON capabilities, "Jackson".
JsonMetaDataSerializer
JSR47Logger_impl
UIMA Logging interface implementation for Java Logging Toolkit JSR-47 (JDK 1.4) JUL Ignores Markers and MDC (not supported in the JUL)
JTextAnnotator
Deprecated.
As of release 2.3.0, use JCasAnnotator_ImplBase instead
JTextAnnotator_ImplBase
Deprecated.
As of release 2.3.0, use JCasAnnotator_ImplBase instead
Language
LanguagePrecondition
A precondition on the language of the document.
LanguagePrecondition_impl
Precondition that tests language of the document.
Level
Provides the message level constants for logging and tracing
LinearTypeOrder
Linear order on types.
LinearTypeOrderBuilder
Defines a pre-order on types.
LinearTypeOrderBuilderImpl
Implementation of the `LinearTypeOrderBuilder` interface.
LinearTypeOrderBuilderImpl.TotalTypeOrder
An implementation of the `LinearTypeOrder` interface.
List_of_ints
a List API that returns ints instead of T
LLUnambiguousIteratorImpl<T extends FeatureStructure>
Implements a low level ambiguous or unambiguous iterator over some type T which doesn't need to be a subtype of Annotation.
LocalInstallationAgent
The `LocalInstallationAgent` allows localizing files of UIMA compliant components within the single PEAR structure, and verifying localized component's files using UIMA framework API.
Log4jLogger_impl
UIMA Logging interface implementation for Log4j This version is for Log4j version 2, from Apache Built using version 2.8
Logger
A `Logger` is a component used to log messages.
Logger_common_impl
UIMA Logging interface common implementation Specific loggers extend this class
Logger_impl
UIMA Logging interface implementation without using an logging toolkit Logger names are not used The call getInstance() returns a common shared instance.
LoggerPrintStream
A PrintStream implementation that writes to a UIMA logger.
LongArray
JCas class model for LongArray
LongArrayFS
Long array interface.
LongArrayFSImpl
Deprecated.
use LongArray instead
LowLevelCAS
Defines the low-level CAS APIs.
LowLevelException
Exception class for package org.apache.uima.cas.impl.
LowLevelIndex<T extends FeatureStructure>
Low-level FS index object.
LowLevelIndexRepository
Low-level index repository access.
LowLevelIterator<T extends FeatureStructure>
Low-level FS iterator.
LowLevelIterator_empty<T extends FeatureStructure>
An empty Low-level FS iterator
LowLevelTypeSystem
Low-level version of the type system APIs.
MailMessagingSpecifier
ManagementObject
Base interface for objects that expose a monitoring and management interface to a UIMA component or some part of the UIMA framework.
Mapping
Mapping from a CAS feature name to its name in the index.
Mapping_impl
Marker
An object obtained from the `CAS` that is used to query when FSs were created or modified with respect to the marker.
MarkerImpl
A MarkerImpl holds a high-water "mark" in the CAS, for all views.
MessageReport
MessageRouter
The `MessageRouter` class facilitates intra-process message routing.
MessageRouter.StdChannelListener
The `StdChannelListener` interface declares methods that should be implemented by each standard message channel listener.
MessagingSpecifier
MetaDataObject
An object used to represent metadata of a `Resource`.
MetaDataObject_impl
Abstract base class for all MetaDataObjects in the reference implementation.
MetaDataObject_impl.MetaDataAttr
MetaDataObject_impl.SerialContext
Information, kept globally (by thread) for one serialization Inherited by some custom impls, e.g.
MetaDataObject_impl.Serializer
methods used for serializing
MetaDataObjectSerializer_json
MethodHandlesLookup
MimeTypePrecondition
A precondition on the MIME Type of the entity.
MimeTypePrecondition_impl
Precondition that tests the MIME type of the Entity's content.
Misc
MQMessagingSpecifier
MultiprocessingAnalysisEngine_impl
An `AnalysisEngine` implementation that can process multiple `CAS` objects simultaneously.
NameClassPair
A class that stores the name of an attribute and the Class of that attribute's value.
NameValuePair
Stores a name (String) and value (Object).
NameValuePair
A type of `MetaDataObject` that stores a name (String) and value (Object).
NameValuePair_impl
Reference implementation of `NameValuePair`.
NonEmptyFloatList
NonEmptyFSList<T extends TOP>
NonEmptyIntegerList
NonEmptyList
a marker interface for nonempty lists
NonEmptyStringList
OperationalProperties
Operational Properties for a UIMA component.
OperationalProperties_impl
OptimizeStrings
Share common underlying char[] among strings: Optimize sets of strings for efficient storage Apply it to a set of strings.
OutOfTypeSystemData
This class is used by the XCASDeserializer to store feature structures that do not fit into the type system of the CAS it is deserializing into.
OutputQueue
An object that holds configuration that is part of the CPE descriptor.
PackageBrowser
The `PackageBrowser` class allows browsing both archived and unarchived PEAR packages, finding package files and directories, loading installation descriptor files and returning run-time environment settings required for installed components.
PackageCreator
Utility class to generate a pear package.
PackageCreatorException
Exception thrown if the PEAR package generation fails.
PackageInstaller
The `PackageInstaller` class is the main user API for installing PEAR packages.
PackageInstallerException
Exception thrown if PEAR installation fails.
PackageSelectorGUI
The `PackageSelectorGUI` class provides simple Swing-based file dialog windows for selecting root directories of installed PEAR packages, as well as PEAR package files, which contain components that need to be installed.
PackageSelectorGUI.PackageDirFilter
The `PackageDirFilter` class allows filtering directories.
PackageSelectorGUI.PackageFileFilter
The `PackageFileFilter` class allows filtering PEAR package files.
ParallelStep
Indicates that a CAS should be routed to a multiple AnalysisEngines and that the relative order in which these execute does not matter.
Parameter
A general parameter having a name and a value, which are both strings.
Parameter_impl
ParameterizedDataResource
A resource that provides access to data, where the data can vary based on parameters.
ParsingException
Deprecated.
The Constraint Parser is not supported in externally released versions of UIMA
PearAnalysisEngineWrapper
UIMA pear runtime analysis engine wrapper.
PearAnalysisEngineWrapper.StringPair
inner class StringPair
PearSpecifier
A type of `ResourceSpecifier` that locate an installed pear `Resource`.
PearSpecifier_impl
Reference implementation of `PearSpecifier`.
Precondition
A `Precondition` of a Resource is a condition that an Entity and/or its analysis in the `CAS` must satisfy before that Entity can be processed by the Resource.
PrimitiveAnalysisEngine_impl
Reference implementation of `AnalysisEngine`.
PrimitiveArrayFS
A subtype of FeatureStructure that represents an array of primitive values (Strings, int, or floats).
PrimitiveArrayFSImpl
PrimitiveValue
Represents a primitive feature value - a string, integer, or float.
PrimitiveValueImpl
ProcessingResourceMetaData
Metadata that describes a "Processing" `Resource` - that is, one that reads or writes to the `CAS`.
ProcessingResourceMetaData_impl
Reference implementation of `ProcessingResourceMetaData`.
ProcessTrace
A `ProcessTrace` object keeps a record of events that have occurred and information, such as timing, about those events.
ProcessTrace_impl
Reference implementation of `ProcessTrace`.
ProcessTraceEvent
Captures information, including timing, about an event that occurred during processing.
ProcessTraceEvent_impl
Reference implementation of `ProcessTraceEvent`.
ProcessUtil
The `ProcessUtil` class encapsulates utilities that help in dealing with `Process` objects.
ProcessUtil.Runner
The `ProcessUtil.Runner` class allows collecting, printing and distributing console output (stdout and stderr) of the specified `Process` without blocking the caller.
ProcessUtil.StdStreamListener
The `StdStreamListener` interface defines 2 methods that should be implemented by a standard stream listener to get console messages ('stderr' and 'stdout' streams) printed by selected process.
Progress
Progress statistics for a process.
ProgressImpl
PropertyXmlInfo
A simple class containing information on how to render a property in XML.
RecoverableCollectionReader
Interface facilitating CollectionReader recovery from failures.
ReferenceArrayFS
A subtype of FeatureStructure that represents an array of primitive values (Strings, int, or floats).
ReferenceArrayFSImpl
ReferenceValue
A FeatureValue that represents a reference, via ID, to another FeatureStructure.
ReferenceValueImpl
RelativePathResolver
Used by the resource manager to resolve relative URLs to absolute URLs.
RelativePathResolver_impl
Reference implementation of `RelativePathResolver`.
Resource
`Resource` is the general term for all UIMA components that can be acquired and used by an application (or by other resources).
Resource_ImplBase
Implementation base class for `Resource`s.
ResourceAccessException
Thrown to indicate a failure has occurred in attempting to access an external resource.
ResourceConfigurationException
Thrown to indicate that a `Resource`'s configuration parameters could not be set.
ResourceCreationSpecifier
A `ResourceCreationSpecifier` is the supertype of `AnalysisEngineDescription`, `CasConsumerDescription`, `CollectionReaderDescription`, and `CasInitializerDescription`.
ResourceCreationSpecifier_impl
Reference implementation of `ResourceCreationSpecifier`.
ResourceFactory
A `ResourceFactory` is used to acquire instances of `Resource`s.
ResourceInitializationException
Thrown by `Resource.initialize(ResourceSpecifier,Map)` to indicate that a failure has occurred during initialization.
ResourceManager
A `ResourceManager` holds a collection of `Resource` objects, each registered under a specified key.
ResourceManager_impl
Reference implementation of `ResourceManager`.
ResourceManager_impl.ResourceRegistration
Ties an External Resource instance to - its description -- name -- textual description -- a ResourceSpecifier describing how to create it -- (optional) the String name of the Java class that implements the resource) - its defining UIMA Context These are used to validate multiple declarations, and to get a resource to tie it to a binding
ResourceManagerConfiguration
Defines a set of external resources and their bindings to `ExternalResourceDependencies`.
ResourceManagerConfiguration_impl
ResourceManagerPearWrapper
Deprecated.
ResourceMetaData
Encapsulates all metadata for a `Resource`.
ResourceMetaData_impl
Reference implementation of `ResourceMetaData`.
ResourceProcessException
Thrown to indicate that a `Resource` has encountered a problem during its processing.
ResourceService_impl
Convenience base class for Resource Service implementations.
ResourceServiceAdapter
Insulates applications from the knowledge that they are interacting with a `ResourceService_impl` rather than a local instance of a `Resource`.
ResourceServiceException
Thrown to indicate that an error has occurred during communication with a remote resource service.
ResourceServiceSpecifier
A `ResourceServiceSpecifier` is a type of `ResourceSpecifier` that contains information that can be used to locate an existing resource available as a service.
ResourceServiceStub
A stub that calls a remote AnalysisEngine service.
ResourceSpecifier
A `ResourceSpecifier` contains information that can be used acquire a reference to a `Resource`, whether that is done by instantiating the resource locally or locating an existing resource available as a service.
ResourceSpecifierFactory
A factory used to create `ResourceSpecifier` instances and instances of other objects needed to compose `ResourceSpecifier`s.
ResourceSpecifierFactory_impl
Reference implementation of `ResourceSpecifierFactory`.
ResourceSpecifierList
A type of `ResourceSpecifier` that is an aggregate of other `ResourceSpecifier`s.
ResourceState_impl
This class is not referenced by anything 9/2013
ResultNotSupportedException
This exception is thrown by an Analysis Engine when it receives a request to generate results that it cannot produce.
ResultSpecification
A `ResultSpecification` is a set of desired outputs from a Analysis Engine or Annotator.
ResultSpecification_impl
Reference implementation of `ResultSpecification`.
RootUimaContext_impl
Implementation of the root `UimaContext`.
RsFeat
Represents the languages associated with one explicit type:feature in a result spec
RsFeats
represents the updateable list of features, each with a particular language spec a given feature only appears once in the list, with the union of all languages
RsFullFeatNames
Implements a globally shared weak-reference map between types & features to the corresponding Full Feature name Used to avoid creating new full feature names when compiling result feature specs.
RsLang
Class used to canonicalize language string
RsLangs
A set of languages, each represented by a canonical string object The set is stored without any subsumed elements Instances of this class are shareable Duplicate-on-update strategy Requires that all update operations to it return the possibly new RsLangs object, and that calls are always of the form rsLangInstance = rsLangInstance.[some-update-operation] Requires that all copy operations set the shared bit: copiedInstance = origInstance.setShared(); A instance marked isShared == true is immutable Updates cause duplication.
RsType
Holds types and/or features with language specs These are expected to be sparse with respect to the complete type system
RsTypesMap
This object holds the set of RsTypes for a result spec There is one instance of this per ResultSpecification_impl
SaxDeserializer
Deserializes an `XMLizable` object from SAX events.
SaxDeserializer_impl
Reference implementation of `SaxDeserializer`.
SelectFSs<T extends FeatureStructure>
Collection of builder style methods to specify selection of FSs from indexes Documentation is in a chapter in the UIMA Version 3 User's Guide.
SelectFSs_impl<T extends FeatureStructure>
Collection of builder style methods to specify selection of FSs from indexes shift handled in this routine Comment codes: AI = implies AnnotationIndex Iterator varieties and impl bounded? type order not unambig? strict? skipEq Priority? Needed? no coveredBy covering sameas for not-bounded, - ignore strict and skipEq -- except: preceding implies skipping annotations whose end > positioning begin - order-not-needed only applies if iicp size > 1 - unambig ==> use Subiterator -- subiterator wraps: according to typePriority and order-not-needed - no Type Priority - need to pass in as arg to fsIterator_multiple_indexes == if no type priority, need to prevent rattling off the == type while compare is equal == affects both FsIterator_aggregation_common and FsIterator_subtypes_ordered for 3 other boundings: - use subiterator, pass in strict and skipeq finish this javadoc comment edit T extends FeatureStructure, not TOP, because of ref from FSIndex which uses FeatureStructure for backwards compatibility
SelectViaCopyToArray<T extends FeatureStructure>
Classes which provide a toArrayForSelect() method that returns a FeatureStructure[] can implement this to enable the class to be used as a "select" source T extends FeatureStructure because FSArray with no typing needs to default to FeatureStructure for backwards compatibility
SerialFormat
The various forms of serialization (typically of the CAS)
Serialization
This class has no fields or instance methods, but instead has only static methods.
SerializationMeasures
Structure: StatDetail str has neh for offset, length, dictionary hits/misses indexedFs has neh for diffs modHeap named, has neh for diffs, heap for values
SerializationMeasures.StatDetail
Statistical details There's instances of this class for - the main heap - the aux heaps - the string offsets, the string lengths Heap: xxxx [name-of-delta: [Total: <TotalBytes>(negative%) Histo: a(neg%) b(neg%) c(neg%) d(neg%) e(neg%)]] 2 styles: one uses only one counter, no delta - used for byte, short, and long heaps other is for main heap, uses 4 deltas.
ServiceDataCargo
A serializable class containing the information passed to and returned from Analysis Engine Services.
Session
An object that encapsulates all conversational state between a UIMA `Resource` and a particular client.
Session_impl
SessionNamespaceView_impl
Settings
A `Settings` object holds the properties used for external parameter overrides.
Settings_impl
Class that reads properties files containing external parameter overrides used by the ExternalOverrideSettings_impl class.
SharedResourceObject
The `SharedResourceObject` interface must be implemented by all classes that provide access to resource data.
ShortArray
JCas class model for ShortArray
ShortArrayFS
Short array interface.
ShortArrayFSImpl
Deprecated.
use ShortArray instead
SimplePackageSelector
The `SimplePackageSelector` class provides simple command line dialog for selecting root directories of installed PEAR packages, as well as PEAR package files, which contain components that need to be installed.
SimplePrecondition
`SimplePrecondition` defines a few simple conditions that can be evaluated against a `CAS`.
SimplePrecondition_impl
Reference implementation of `SimplePrecondition`.
SimpleResourceFactory
A simple implementation of a `ResourceFactory`.
SimpleStep
Indicates that a CAS should be routed to a single AnalysisEngine.
SimpleStepWithResultSpec
Deprecated.
For backwards compatibility with Capability Language Flow only.
SkipCasException
Exception to notify the CPM to skip a Cas Processor for the current CAS.
Slf4jLogger_impl
UIMA Logging interface implementation for SLF4j This design gets a logger in static initialization, in order to see what the back end is.
SlotKinds
NOTE: adding or altering slots breaks backward compatability and the ability do deserialize previously serialized things This definition shared with BinaryCasSerDes4 Define all the slot kinds.
SlotKinds.SlotKind
SlotKindsConstants
Users "implement" this interface to get access to these constants in their code
Sofa
SofaFS
Interface for "Subject of Analysis" (Sofa) feature structures.
SofaFSImpl
Deprecated.
use Sofa instead
SofaID
Deprecated.
As of v2.0, this is no longer needed.
SofaID_impl
Deprecated.
SofaMapping
Sofa Name mapping is required to connect the output Sofas from one component to the input Sofa of another component.
SofaMapping_impl
Implementation of `SofaMapping`.
SourceDocumentInformation
Stores detailed information about the original source document from which the current CAS was initialized.
StatusCallbackListener
Interface for a Listener that receives notification from the `CollectionProcessingManager` as various events occur.
Step
Represents the next destination or destinations to which a CAS should be routed.
StringArray
JCas class model for StringArray
StringArrayFS
String array interface.
StringArrayFSImpl
Deprecated.
use StringArray instead
StringHeapDeserializationHelper
Support for legacy string heap format.
StringList
StringMap
Appears to be unused, 1-2015 schor
StringUtil
The `StringUtil` class provides utility methods for working with strings.
Style
An indexing style.
Style_impl
Subiterator<T extends AnnotationFS>
Subiterator implementation.
Subiterator.BoundsUse
SynchPoint
Interface facilitating recovery of CollectionReaders to the last known entity
TaeDescription
Deprecated.
As of v2.0, `AnalysisEngineDescription` should be used instead.
TaeDescription_impl
Deprecated.
since v2.0
TCasFormatter
Interface for components that generate a String representation of a CAS.
TCasToInlineXml
Deprecated.
As of v2.0, use `CasToInlineXml` instead.
TextAnalysisEngine
Deprecated.
As of v2.0, `AnalysisEngine` should be used instead.
TextAnnotator
Deprecated.
As of release 2.3.0, use CasAnnotator_ImplBase or JCasAnnotator_ImplBase instead
TOP
The JCas Class model corresponding to the Cas TOP type.
TOP_Type
Deprecated.
Type
The interface describing types in the type system.
TypeClass
This class may not be used.
TypeDescription
A description of a CAS Type.
TypeDescription_impl
Reference implementation of `TypeDescription`.
TypeImpl
The implementation of types in the type system.
TypeImpl_annot
A version of TypeImpl for Annotations and subtypes of Annotations
TypeImpl_annotBase
A version of TypeImpl for the AnnotationBase type and its subtypes
TypeImpl_array
TypeImpl_list
TypeImpl_primitive
TypeImpl_string
String or String Subtype
TypeImpl_stringSubtype
TypeNameSpace
An object holding the namespace string for a type.
TypeNameSpaceImpl
TypeOrFeature
A reference to a Type or Feature in the Analysis Engine's TypeSystem.
TypeOrFeature_impl
Reference implementation of `TypeOrFeature`.
TypePriorities
A declaration of priorities between CAS Types.
TypePriorities_impl
Reference implementation of `TypePriorities`.
TypePrioritiesProvider
TypePriorityList
Declares a relative priority between CAS types.
TypePriorityList_impl
Reference implementation of `TypePriorityList`.
TypeSystem
The interface to the type system.
TypeSystem2Xml
Dumps a Type System object to XML.
TypeSystemConstants
This interface defines static final constants for Type Systems For the built-in types and features: - the type and feature codes - the adjOffsets
TypeSystemDescription
Description of a CAS TypeSystem.
TypeSystemDescription_impl
Reference implementation of `TypeSystemDescription`.
TypeSystemDescriptionProvider
TypeSystemImpl
Type system implementation.
TypeSystemMgr
Writable version of type system.
TypeSystemUtil
TypeSystemUtils
Type Utilities - all static, so class is abstract to prevent creation Used by Feature Path
TypeSystemUtils.PathValid
UIMA_IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or inappropriate argument.
UIMA_IllegalStateException
Signals that a method has been invoked at an illegal or inappropriate time.
UIMA_UnsupportedOperationException
Thrown to indicate that the requested operation is not supported.
UimaContext
Provides access to external resources (other than the CAS).
UimaContext_ImplBase
Instances of this class shared by multiple threads
UimaContextAdmin
Admin interface to the UIMA Context.
UimaContextHolder
This class holds the UimaContext for the current thread, or a parent thread.
UimacppAnalysisComponent
UimacppAnalysisEngineImpl
Reference implementation of `AnalysisEngine`.
UimacppEngine
UimacppException
Use this class to signalize a fatal (internal) error to the API user.
UIMAException
This is the superclass for all checked exceptions in UIMA.
UIMAFramework
This is an application's main interface point to the UIMA Framework.
UIMAFramework_impl
This is the main interface point to the UIMA reference implemention.
UIMARuntimeException
This is the superclass for all unchecked exceptions in UIMA.
UimaSerializable
This interface is implemented by JCas classes that need to be called by the framework when a serialization is about to happen.
UimaSerializableFSs
This interface is implemented by JCas classes that need to be called by the framework when a serialization is about to happen where the _save_to_cas_data() method update Features which have references to Feature Structures
UimaTimer
Interface for a timer, used to collect performance statistics for UIMA components.
UIMAUtil
The `UIMAUtil` class provides convenient methods for handling UIMA specific objects.
URISpecifier
A type of `ResourceSpecifier` that locates an existing `Resource` service by its URI.
URISpecifier_impl
Reference implementation of `URISpecifier`.
UriUtils
Static methods supporting proper handling of URIs
Util
Shared code refactored from other spots to reduce duplication and improve maintainability
XCASDeserializer
XCAS Deserializer.
XCASParsingException
Exception class for package org.apache.uima.cas.impl.
XCASSerializer
XCAS serializer.
XCasToCasDataSaxHandler
A SAX ContentHandler that reads XCAS and creates a CasData.
XmiCasDeserializer
XMI CAS deserializer.
XmiCasSerializer
CAS serializer for XMI format; writes a CAS in the XML Metadata Interchange (XMI) format.
XmiSerializationSharedData
A container for data that is shared between the `XmiCasSerializer` and the `XmiCasDeserializer`.
XmiSerializationSharedData.NameMultiValue
XmiSerializationSharedData.OotsElementData
Data structure holding all information about an XMI element containing an out-of-typesystem FS.
XmiSerializationSharedData.XmiArrayElement
Data structure holding the index and the xmi:id of an array or list element that is a reference to an out-of-typesystem FS.
XmlCasDeserializer
Deserializes a CAS from a standoff-XML format.
XmlCasSerializer
Serializes a CAS to inline XML format.
XMLInputSource
An input source used by the `XMLParser` to read XML documents for parsing.
XMLizable
An interface to be implemented by UIMA classes that can be written to and parsed from XML.
XmlizationInfo
A simple class used to describe how to render this object as XML.
XMLParser
A UIMA `XMLParser` parses XML documents and generates UIMA components represented by the XML.
XMLParser_impl
Reference implementation of `XMLParser`.
XMLParser.ParsingOptions
Option settings for the parser.
XMLSerializer
Utility class that generates XML output from SAX events or DOM nodes.
XMLTypeSystemConsts
Class comment for XMLTypeSystemConsts.java goes here.
XMLUtil
The `XMLUtil` class provides miscellaneous XML utilities.