All Classes and Interfaces
Class
Description
Exception to notify the CPM to disable a Cas Processor.
/** Exception to notify the CPM to terminate itself.
The base interface extended by all CAS (Common Analysis System) interfaces in the UIMA SDK.
Base class from which CAS implementations should extend.
Reference implementation of
AnalysisEngine.Represents an allowed value for an "enumerated" type.
Reference implementation of
AllowedValue.Analysis Components are the primitive "building blocks" from which UIMA solutions are built.
Implementation base class for AnalysisComponents.
An Analysis Engine is a component responsible for analyzing unstructured information, discovering
and representing semantic content.
An
AnalysisEngineDescription contains all of the information needed to instantiate
and use an AnalysisEngine.Reference implementation of
AnalysisEngineDescription.Resource Factory that handles
AnalysisEngineDescription and TaeDescription
elements.Provides functionality common to Analysis Engine implementations.
Monitoring and management interface to an AnalysisEngine.
Implements Monitoring/Management interface to an AnalysisEngine.
JMX MBean interface for monitoring AnalysisEngine performance stats.
Encapsulates all of the metadata for an Analysis Engine.
Reference implementation of
AnalysisEngineMetaData.A class that is useful for generating an Analysis Engine performance report from a
ProcessTrace object.An
AnalysisEngineProcessException may be thrown by an Analysis Engine's process
method, indicating that a failure occurred during processing.Base class for analysis engine processor adapters.
A stub that calls a remote AnalysisEngine service.
Convenience base class for Analysis Engine Services.
Base class for analysis engine service adapters.
A stub that calls a remote AnalysisEngine service.
Static utility methods relating to analysis engines.
Deprecated.
Deprecated.
since v2.0
A
AnalysisSequenceCapabilityNode is a node element of the
CapabilityLanguageFlowObject.the JCas class model for the CAS type uima.cas.Annotation.
Deprecated.
the JCas class model for the CAS type uima.cas.AnnotationBase.
Deprecated.
Annotation Base API.
Deprecated.
use AnnotationBase instead
Interface for Annotation Feature Structures.
Deprecated.
use Annotation instead
Exception class for package org.apache.uima.cas.impl.
An annotation index provides additional iterator functionality that applies only to instances of
uima.tcas.Annotation (or its subtypes).Represents an annotation tree.
Implementation of annotation tree.
Represents a node in an annotation tree.
Base class for all annotators.
Deprecated.
As of release 2.3.0, use CasAnnotator_ImplBase or JCasAnnotator_ImplBase instead
An
AnnotatorConfigurationException is thrown by an annotator if the settings of its
configuration parameters are invalid.Deprecated.
As of release 2.3.0, use UimaContext instead
Reference implementation of
AnnotatorContext.An
AnnotatorContextException is thrown by an AnnotatorContext if it cannot
complete the invoked operation due to a failure in the underlying implementation.An
AnnotatorInitializationException may be thrown by an annotator's initialize
method, indicating that the annotator failed to successfully initialize itself.An
AnnotatorProcessException may be thrown by an annotator's process method,
indicating that a failure occurred during processing.Feature structure array interface.
Deprecated.
use FSArray instead
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.A simple
ASB implementation.A simple name, value pair that is specified as part of a
Style to further define its
behavior.protectIndexes returns instances of this, rather than AutoCloseable, to permit users to use try
with resources without a catch for Exception.
Base interface for annotators in UIMA SDK v1.x.
The Base
CollectionReader interface.The Base CPM interface is a lower-level interface to the Collection Processing Manager.
Interface for a Listener that receives notification from the
BaseCPM as various events
occur.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.
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.
Compression alternatives
User callable serialization and deserialization of the CAS in a compressed Binary Format
This serializes/deserializes the state of the CAS.
Compression alternatives
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..
JCas class model for BooleanArray
Boolean array interface.
Deprecated.
use BooleanArray instead
Implementation of boolean match constraint.
Constants representing Built in type collections
String Sets:
creatableArrays
primitiveTypeNames == noncreatable primitives
creatableBuiltinJcas (e.g.
JCas class model for ByteArray
Byte array interface.
Deprecated.
use ByteArray instead
A
Capability defines an operation that an Resource can carry out.Reference implementation of
CapabilityA
CapabilityLanguageFlow is a simple type of FlowConstraints that specifies
the complete flow as a capabilityLanguage sequence.A
CapabilityLanguageFlow is a simple type of FlowConstraints that specifies
the complete flow as a capabilityLanguage sequence.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.
The
CapabilityLanguageAnalysisSequence is used for a
CapabilityLanguageFlow.Object-oriented CAS (Common Analysis System) API.
Base class to be extended by Annotators that use the
CAS interface.Used by tests for Binary Compressed de/serialization code.
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
Any component that operates on analysis results produced by a UIMA analysis engine.
Base class for CAS Consumers in UIMA SDK v1.x, which developers should extend with their own CAS
Consumer implementation classes.
An
CasConsumerDescription contains all of the information needed to instantiate and
use an CasConsumer.Specialized Resource Factory for producing CasConsumers.
Utility class for doing deep copies of FeatureStructures from one CAS to another.
Utilities for creating and setting up CASes.
Interface for directly accessing and manipulating the data in the Common Analysis Structure.
A
CasDataCollectionReader is used to iterate over the elements of a Collection.Base class from which to extend when writing Collection Readers that use the
CasData
interface to access the CAS.Any component that operates on analysis results produced by a UIMA CasDataProcessor.
Base class from which to extend when writing CAS Consumers that use the
CasData interface
to access the CAS.Deprecated.
As of v2.0, CAS Initializers are deprecated.
Deprecated.
As of v2.0, CAS Initializers are deprecated.
Interface for CAS processors that want to interact directly with the
CasData.Interface for a Listener that receives notification from the
CollectionProcessingManager as various events occur.Takes a CasData and generates XCAS SAX events.
Some utilities for dealing with CasData
Encapsulates information that defines how to create a CAS.
Exception class for package org.apache.uima.cas.
Factory class to create CASMgr objects.
Convenience base class for Flow objects that use the CAS interface.
Base class to be extended by FlowControllers that use the
CAS interface.Implements the CAS interfaces.
Journaling changes for computing delta cas.
Deprecated.
As of v2.0, CAS Initializers are deprecated.
Deprecated.
As of v2.0, CAS Initializers are deprecated.
Deprecated.
As of v2.0, CAS Initializers are deprecated.
Deprecated.
As of v2.0, CAS Initializers are deprecated.
Deprecated.
As of v2.0, CAS Initializers are deprecated.
A collection of static methods aimed at making it easy to
An iterator over a collection of CASes.
Used with CasIOUtils, maybe elsewhere, to indicate how CASes are to be loaded or saved.
Manages creation and pooling of CAS instances within an AnalysisEngine.
Simple CAS Manager Implementation used in the AnalysisEngine framework.
Class comment for CASMgr.java goes here.
Container for serialized CAS typing information.
Base class to be extended by CAS Multipliers that use the
CAS interface.Interface for CAS Processors that want to use the full
CAS implementation.Represents the "owner" of a CAS.
This class represents a simple pool of
CAS instances.Management interface to a
CasPool.Implements Monitoring/Management interface to a CasPool.
JMX MBean interface for monitoring CASPool state.
A functional interface for a CAS processor.
Base interface for a component that can process a CAS.
Contains configuration parameter settings for a CAS Processor.
An object that holds configuration information used for building CPE Descriptor.
An object that contains all
CasProcessorDeploymentParam instances.An object to contains configuration specific to error handling applicable to every CasProcossor.
An object to contains configuration specific to error handling applicable to every CasProcessor.
An object containing an arbitrary value that will passed to a program launched by the CPE.
An object containing all
CasProcessorExecArg
instances.An object containing configuration for a program that the CPE will use to launch CasProcessor.
Object containing a filter expression used by the CPE to route CAS's to CasProcessor.
An object that holds configuration related to handling max restarts for CasProcessors.
An object that holds configuration that is part of the CPE descriptor.
An object that holds configuration that is part of the CPE descriptor.
An object that holds configuration that is part of the CPE descriptor.
Runtime exception class for package org.apache.uima.cas.
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.
This object has 2 purposes.
CAS serializer support for XMI and JSON formats.
states the CAS can be in
Generates an *approximate* inline XML representation of a CAS.
This class gets initialized with two type systems, and then provides resources to map type and
feature codes between them.
Reference implementation of
AnnotatorContext.Thrown to indicate that there is a problem with some aspect of a Collection.
A
CollectionProcessingEngine (CPE) processes a collection of artifacts (for text
analysis applications, this will be a collection of documents) and produces collection-level
results.A
CollectionProcessingManager (CPM) manages the application of an
AnalysisEngine to a collection of artifacts.A
CollectionReader is used to iterate over the elements of a Collection.Base class for Collection Readers, which developers should extend with their own Collection
Reader implementation classes.
An
CollectionReaderDescription contains all of the information needed to instantiate
and use an CollectionReader.Specialized Resource Factory for producing CollectionReaders.
Common parts of the Array interfaces.
Deprecated.
This class is the super class of list nodes (both empty and non empty)
This interface is implemented by arrays of non-FeatureStructure components
boolean, byte, short, int, long, float, double, String, JavaObject
Internal Use Only.
Common de/serialization
HEADERS
Serialization versioning
There are 1 or 2 words used for versioning.
byte swapping reads of integer forms
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.
Information that a CAS needs to know about the component that's currently operating on it.
A type of
ResourceFactory that produces resources by delegating to other Resource
Factories.A registry containing (ResourceSpecifier Class,
ResourceFactory) pairs.A concurrent map supporting a value-creating get.
A simple
DataResource implementation that can read data from a file via a URL.A type of
ResourceSpecifier that locates a resource file using its URL.Reference implementation of
FileResourceSpecifier.A
Resource that has configuration parameters that can be changed after the Resource has
been instantiated.Implementation base class for
ConfigurableResources.A group of
ConfigurationParameters.Reference implementation of
ConfigurationGroup.Manages the configuration parameters of all components within a possibly aggregate
Resource.Basic standalone Configuration Manager implmentation.
Convenience base class for Configuration Manager implementations.
Completely specifies a configuration parameter on a UIMA resource.
Reference implementation of
ConfigurationParameter.The declarations of configuration parameters in a Resource.
The values for
ConfigurationParameters in a Resource.Reference implementation of
ConfigurationParameterSettings.Some constants used by the UIMA framework.
Constants
Methods to create
FSMatchConstraints for filtered iterators or other
use.Implementation of the ConstraintFactory interface.
common APIs supporting the copy on write aspect of index parts
An object that holds configuration that is part of the CPE descriptor.
An object that holds configuration that is part of the CPE descriptor.
An object that holds configuration that is part of the CPE descriptor.
An object that holds configuration that is part of the CPE descriptor.
Deprecated.
As of v2.0 CAS Initializers are deprecated.
An object that holds configuration that is part of the CPE descriptor.
An object that holds configuration that is part of the CPE descriptor.
An object that holds configuration that is part of the CPE descriptor.
Java representation of a Collection Processing Engine (CPE) XML descriptor.
An object that holds configuration that is part of the CPE descriptor.
An object that holds configuration that is part of the CPE descriptor.
An object that holds configuration that is part of the CPE descriptor.
An object that holds configuration that is part of the CPE descriptor.
An object that holds configuration that is part of the CPE descriptor.
Resource Factory that handles
CustomResourceSpecifier elements.A type of
ResourceSpecifier that specifically names the Java class that should be
created.Implementation of
CustomResourceSpecifier.Methods for working with Data during I/O
DataResource is a simple resource that provides access to data.A simple
DataResource implementation that can read data from a file via a URL.Class holding information about an FSIndex
Includes the "label" of the index, and a ref to the CAS this index contents are in.
Class holding info about a View/Sofa.
The JCas class definition for the CAS
DocumentAnnotation type.JCas class model for DoubleArray
Double array interface.
Deprecated.
use DoubleArray instead
Trivial CasIterator that returns no CASes.
a marker interface for empty lists
Contains information about the successful or unsuccessful processing of an entity (an element of
a collection) by the
CollectionProcessingManager.Binds an
ExternalResourceDependency to an
ExternalResourceDescription.An
ExternalResourceDependency object describes an resources's requirements on an
external resource.Reference implementation of
ExternalResourceDependency.An
ExternalResourceDescription object describes a resource that is loaded in the
ResourceManager and may be shared between components.Reference implementation of
AnalysisEngineDescription.The interface that describes features in the type system.
A description of a CAS feature.
Reference implementation of
FeatureDescription.The implementation of features in the type system.
The implementation of jcas-only features in the type system.
Interface for a feature path.
An object in the CAS.
Interface for feature structures.
Deprecated.
use TOP instead
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
The base interface for the value of a feature.
Deprecated.
use
FeaturePathContains CAS Type and Feature objects to represent a feature path of the form
feature1/.../featureN.
An implementation of
ParameterizedDataResource for language-based resources.A type of
ResourceSpecifier that locates a resource file using its URL, where the
URL depends on an ISO language identifier.Reference implementation of
FileLanguageResourceSpecifier.A type of
ResourceSpecifier that locates a resource file using its URL.Reference implementation of
FileResourceSpecifier.The
FileUtil class provides utility methods for working with general files.The
DirFileFilter class allows to filter files based on specified directory path
and filename extension.The
ExtFileFilter allows to filter file names based on the specified filename
extension.The
FileTimeComparator class allows comparing 'last modified' time in 2 given
File objects.The
NameFileFilter class allows to filter files based on specified file name.Some utilities for handling files.
Specifies a constraint that matches against annotations in the CAS.
Indicates that a CAS has finished being processed by the aggregate.
A
FixedFlow is a simple type of FlowConstraints that specifies the complete
flow as a fixed sequence.Reference implementation of
FixedFlow.Simple FlowController that invokes components in a fixed sequence.
Java Cas model for Cas FloatArray.
Interface for CAS float arrays.
Deprecated.
use FloatArray instead
A Flow object is responsible for routing a single CAS through an Aggregate Analysis Engine.
A
FlowConstraints object represents constraints on the order of execution of
delegate Analysis Engines within an aggregate Analysis Engine.Container for Flow objects, to handle CAS conversions and performance timing.
FlowControllers are components that decide how to route CASes within Aggregate Analysis Engines.
Implementation base class for FlowControllers.
Container for a FlowController.
A subtype of
UimaContext used by FlowController components.Implementation of FlowControllerContext.
Declares which FlowController is used by the Aggregate Analysis Engine.
Declares which FlowController is used by the Aggregate Analysis Engine.
A
FlowControllerDescription contains all of the information needed to instantiate
and use a FlowController.Implementation of
FlowControllerDescription.Java Class model for Cas FSArray type extends FeatureStructure for backwards compatibility when
using FSArray with no typing.
An ArrayList type containing Feature Structures, for UIMA
Has all the methods of List
Implements the select(...) APIs
Interface for a boolean constraint.
See interface for documentation.
There is one **class** instance of this per UIMA core class loader.
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.
UNUSED V3 backwards compat only Delete REplace with Comparator<FeatureStructure> or the
like.
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)
Interface for feature structure constraints.
Interface for a float constraint.
Deprecated.
unused in v3, only present to avoid compile errors in unused v2 classes
A Functional Interface for generating V3 Java Feature Structures
A Functional Interface for generating Java Feature Structures NO LONGER USED
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
UNUSED V3, backwards compat only Interface to compare two feature structures, represented by
their addresses.
Feature structure index access interface.
Implementation of annotation indexes.
Used for UIMA FS Bag Indexes Uses ObjHashSet to hold instances of FeatureStructures
Common part of flattened indexes, used for both snapshot iterators and flattened sorted indexes
built from passed in instance of FsIndex_iicp
Common index impl for set and sorted indexes.
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.
Implementation of light-weight wrapper of normal indexes, which support special kinds of
iterators base on the setting of IteratorExtraFunction
Description of a collection of CAS feature structure indexes.
This interface describes objects which specify the comparison used in indexes for keys.
Specifies the comparison to be used for an index, in terms of
- the keys and the typeorder, in an order
- the standard/reverse ordering
A description of a CAS feature structure index.
A description of a key defining a CAS feature structure index.
Repository of indexes over feature structures.
There is one instance of this class per CAS View.
Repository of indexes.
Interface for an integer constraint.
Iterator over feature structures.
Common code for both
aggregation of indexes (e.g.
Performs an ordered iteration among a set of iterators, each one corresponding to the type or
subtype of the uppermost type.
Version 2 compatibility only, not used internally in version 3 Base class for FSIterator
implementations.
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
T extends TOP, v2 already mandated TOP for set/get
Interface for feature structure matching constraints.
Interface for a String constraint.
Interface for type constraint.
Deprecated.
As of release 2.3.0, use CasAnnotator_ImplBase or JCasAnnotator_ImplBase instead
Deprecated.
As of release 2.3.0, use CasAnnotator_ImplBase or JCasAnnotator_ImplBase instead
the v2 CAS heap - used in modeling some binary (de)serialization
Like InternationalizedException, but is an interface with default methods.
A map from ints representing FS id's (or "addresses") to those FSs There is one map instance per
CAS (all views).
An import declaration.
An individual item within a
IndexBuildSpecification.Determines how a
CAS get indexed with a UIMA-compliant search engine.Thrown by the Index to indicate that a failure has occurred during indexing.
A rule that specifies indexing behavior.
The
InstallationController class allows installing PEAR files that contain UIMA
compliant components.The
InstallationMonitor interface defines methods required for notifying of
component installation status and location of the installed PEAR packages.The
PackageSelector interface defines methods required for manually or
automatically selecting installed PEAR package root directories and PEAR package files.The
TestStatus class encapsulates attributes related to the results of the
'serviceability' verification test.The
InstallationDescriptor class encapsulates all elements and parameters included
in the XML Installation Descriptor file.The
ActionInfo class defines 'installation action' attributes.The
ArgInfo class defines attributes of a service command argument.The
ComponentInfo class defines UIMA component attributes.The
ServiceInfo class defines attributes of a 'service' component.The
InstallationDescriptorHandler class allows parsing XML installation descriptor
files, creating instances of the InstallationDescriptor class.The
InstallationProcessor class implements operations specified in the installation
descriptor.The
InstallationTester application allows performing simple verification of the
installed UIMA compliant component by using standard UIMA framework interface.The
InstrumentationFacility interface defines a standard way for UIMA components to
be instrumented for performance evaluation.A map from ints to Feature Structures
Is Pear aware - stores non-pear versions but may return pear version in pear contexts
Interface for CAS int arrays.
Deprecated.
use IntegerArray instead
The Java Class model corresponding to the Cas IntegerArray_JCasImpl type.
An ArrayList type containing ints, for UIMA
- implements a subset of the List API, Iterable<Integer>, IntListIterator.
like Entry<k, v> except the k is an int.
The
InternationalizedException class adds internationalization support to the
standard functionality provided by java.lang.Exception.The
InternationalizedRuntimeException class adds internationalization support to the
standard functionality provided by java.lang.RuntimeException.Thrown by the
XMLParser to indicate that an XML document is invalid or does not specify a
valid object of the desired class.An Iterator with an extra method nextNvc, which skips the validity check
Java Cover Classes based Object-oriented CAS (Common Analysis System) API.
Base class to be extended by Annotators that use the
JCas interface.Convenience base class for Flow objects that use the JCas interface.
Base class to be extended by FlowControllers that use the
JCas interface.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.
implements the supporting infrastructure for JCas model linked with a Cas.
An iterator over a collection of JCAS objects.
Wraps a CasIterator as a JCasIterator
Base class to be extended by CAS Multipliers that use the
CAS interface.This class represents a simple pool of
JCas instances.A functional interface for a JCas processor.
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.
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.
CAS serializer for JSON formats.
The serialization can optionally include context information in addition to the feature
structures.
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".
UIMA Logging interface implementation for Java Logging Toolkit JSR-47 (JDK 1.4) JUL
Ignores Markers and MDC (not supported in the JUL)
Deprecated.
As of release 2.3.0, use JCasAnnotator_ImplBase instead
Deprecated.
As of release 2.3.0, use JCasAnnotator_ImplBase instead
A precondition on the language of the document.
Precondition that tests language of the document.
Provides the message level constants for logging and tracing
Linear order on types.
Defines a pre-order on types.
Implementation of the
LinearTypeOrderBuilder interface.An implementation of the
LinearTypeOrder interface.a List API that returns ints instead of T
Implements a low level ambiguous or unambiguous iterator over some type T which doesn't need to
be a subtype of Annotation.
The
LocalInstallationAgent allows localizing files of UIMA compliant components
within the single PEAR structure, and verifying localized component's files using UIMA framework
API.UIMA Logging interface implementation for Log4j
This version is for Log4j version 2, from Apache
Built using version 2.8
A
Logger is a component used to log messages.UIMA Logging interface common implementation Specific loggers extend this class
UIMA Logging interface implementation without using an logging toolkit Logger names are not used
The call getInstance() returns a common shared instance.
A PrintStream implementation that writes to a UIMA logger.
JCas class model for LongArray
Long array interface.
Deprecated.
use LongArray instead
Defines the low-level CAS APIs.
Exception class for package org.apache.uima.cas.impl.
Low-level FS index object.
Low-level index repository access.
Low-level FS iterator.
An empty Low-level FS iterator
Low-level version of the type system APIs.
Base interface for objects that expose a monitoring and management interface to a UIMA component
or some part of the UIMA framework.
Mapping from a CAS feature name to its name in the index.
An object obtained from the
CAS that is used to query when FSs were created or
modified with respect to the marker.A MarkerImpl holds a high-water "mark" in the CAS, for all views.
The
MessageRouter class facilitates intra-process message routing.The
StdChannelListener interface declares methods that should be implemented by
each standard message channel listener.An object used to represent metadata of a
Resource.Abstract base class for all MetaDataObjects in the reference implementation.
Information, kept globally (by thread) for one serialization
Inherited by some custom impls, e.g.
methods used for serializing
A precondition on the MIME Type of the entity.
Precondition that tests the MIME type of the Entity's content.
An
AnalysisEngine implementation that can process multiple CAS objects
simultaneously.A class that stores the name of an attribute and the Class of that attribute's value.
Stores a name (String) and value (Object).
A type of
MetaDataObject that stores a name (String) and value (Object).Reference implementation of
NameValuePair.a marker interface for nonempty lists
Operational Properties for a UIMA component.
Share common underlying char[] among strings: Optimize sets of strings for efficient storage
Apply it to a set of strings.
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.
An object that holds configuration that is part of the CPE descriptor.
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.Utility class to generate a pear package.
Exception thrown if the PEAR package generation fails.
The
PackageInstaller class is the main user API for installing PEAR packages.Exception thrown if PEAR installation fails.
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.The
PackageDirFilter class allows filtering directories.The
PackageFileFilter class allows filtering PEAR package files.Indicates that a CAS should be routed to a multiple AnalysisEngines and that the relative order
in which these execute does not matter.
A general parameter having a name and a value, which are both strings.
A resource that provides access to data, where the data can vary based on parameters.
Deprecated.
The Constraint Parser is not supported in externally released versions of UIMA
UIMA pear runtime analysis engine wrapper.
inner class StringPair
A type of
ResourceSpecifier that locate an installed pear Resource.Reference implementation of
PearSpecifier.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.Reference implementation of
AnalysisEngine.A subtype of FeatureStructure that represents an array of primitive values (Strings, int, or
floats).
Represents a primitive feature value - a string, integer, or float.
Reference implementation of
ProcessingResourceMetaData.A
ProcessTrace object keeps a record of events that have occurred and information,
such as timing, about those events.Reference implementation of
ProcessTrace.Captures information, including timing, about an event that occurred during processing.
Reference implementation of
ProcessTraceEvent.The
ProcessUtil class encapsulates utilities that help in dealing with
Process objects.The
ProcessUtil.Runner class allows collecting, printing and distributing console
output (stdout and stderr) of the specified Process without blocking the caller.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 statistics for a process.
A simple class containing information on how to render a property in XML.
Interface facilitating CollectionReader recovery from failures.
A subtype of FeatureStructure that represents an array of primitive values (Strings, int, or
floats).
A FeatureValue that represents a reference, via ID, to another FeatureStructure.
Used by the resource manager to resolve relative URLs to absolute URLs.
Reference implementation of
RelativePathResolver.Resource is the general term for all UIMA components that can be acquired and used
by an application (or by other resources).Implementation base class for
Resources.Thrown to indicate a failure has occurred in attempting to access an external resource.
Thrown to indicate that a
Resource's configuration parameters could not be set.A
ResourceCreationSpecifier is the supertype of
AnalysisEngineDescription,
CasConsumerDescription,
CollectionReaderDescription, and
CasInitializerDescription.Reference implementation of
ResourceCreationSpecifier.A
ResourceFactory is used to acquire instances of Resources.Thrown by
Resource.initialize(ResourceSpecifier,Map) to indicate that a failure has
occurred during initialization.A
ResourceManager holds a collection of Resource
objects, each registered under a specified key.Reference implementation of
ResourceManager.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
Defines a set of external resources and their bindings to
ExternalResourceDependencies.Deprecated.
Encapsulates all metadata for a
Resource.Reference implementation of
ResourceMetaData.Thrown to indicate that a
Resource has encountered a problem during its processing.Convenience base class for Resource Service implementations.
Insulates applications from the knowledge that they are interacting with a
ResourceService_impl rather than a local instance of a Resource.Thrown to indicate that an error has occurred during communication with a remote resource
service.
A
ResourceServiceSpecifier is a type of ResourceSpecifier that contains
information that can be used to locate an existing resource available as a service.A stub that calls a remote AnalysisEngine service.
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.A factory used to create
ResourceSpecifier instances and
instances of other objects needed to compose ResourceSpecifiers.Reference implementation of
ResourceSpecifierFactory.A type of
ResourceSpecifier that is an aggregate of other
ResourceSpecifiers.This class is not referenced by anything 9/2013
This exception is thrown by an Analysis Engine when it receives a request to generate results
that it cannot produce.
A
ResultSpecification is a set of desired outputs from a Analysis Engine or
Annotator.Reference implementation of
ResultSpecification.Implementation of the root
UimaContext.Represents the languages associated with one explicit type:feature in a result spec
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
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.
Class used to canonicalize language string
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.
Holds types and/or features with language specs
These are expected to be sparse with respect to the complete type system
This object holds the set of RsTypes for a result spec There is one instance of this per
ResultSpecification_impl
Deserializes an
XMLizable object from SAX events.Reference implementation of
SaxDeserializer.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.
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
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
The various forms of serialization (typically of the CAS)
This class has no fields or instance methods, but instead has only static methods.
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
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.
A serializable class containing the information passed to and returned from Analysis Engine
Services.
An object that encapsulates all conversational state between a UIMA
Resource and a
particular client.A
Settings object holds the properties used for external parameter overrides.Class that reads properties files containing external parameter overrides used by the
ExternalOverrideSettings_impl class.
The
SharedResourceObject interface must be implemented by all classes that provide
access to resource data.JCas class model for ShortArray
Short array interface.
Deprecated.
use ShortArray instead
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 defines a few simple conditions that can be evaluated against a
CAS.Reference implementation of
SimplePrecondition.A simple implementation of a
ResourceFactory.Indicates that a CAS should be routed to a single AnalysisEngine.
Deprecated.
For backwards compatibility with Capability Language Flow only.
Exception to notify the CPM to skip a Cas Processor for the current CAS.
UIMA Logging interface implementation for SLF4j
This design gets a logger in static initialization, in order to see what the back end is.
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.
Users "implement" this interface to get access to these constants in their code
Interface for "Subject of Analysis" (Sofa) feature structures.
Deprecated.
use Sofa instead
Deprecated.
As of v2.0, this is no longer needed.
Deprecated.
Sofa Name mapping is required to connect the output Sofas from one component to the input Sofa of
another component.
Implementation of
SofaMapping.Stores detailed information about the original source document from which the current CAS was initialized.
Interface for a Listener that receives notification from the
CollectionProcessingManager
as various events occur.Represents the next destination or destinations to which a CAS should be routed.
JCas class model for StringArray
String array interface.
Deprecated.
use StringArray instead
Support for legacy string heap format.
Appears to be unused, 1-2015 schor
The
StringUtil class provides utility methods for working with strings.An indexing style.
Subiterator implementation.
Interface facilitating recovery of CollectionReaders to the last known entity
Deprecated.
As of v2.0,
AnalysisEngineDescription should be used instead.Deprecated.
since v2.0
Interface for components that generate a String representation of a CAS.
Deprecated.
As of v2.0, use
CasToInlineXml instead.Deprecated.
As of v2.0,
AnalysisEngine should be used instead.Deprecated.
As of release 2.3.0, use CasAnnotator_ImplBase or JCasAnnotator_ImplBase instead
The JCas Class model corresponding to the Cas TOP type.
Deprecated.
The interface describing types in the type system.
This class may not be used.
A description of a CAS Type.
Reference implementation of
TypeDescription.The implementation of types in the type system.
A version of TypeImpl for Annotations and subtypes of Annotations
A version of TypeImpl for the AnnotationBase type and its subtypes
String or String Subtype
An object holding the namespace string for a type.
A reference to a Type or Feature in the Analysis Engine's TypeSystem.
Reference implementation of
TypeOrFeature.A declaration of priorities between CAS Types.
Reference implementation of
TypePriorities.Declares a relative priority between CAS types.
Reference implementation of
TypePriorityList.
The interface to the type system.
Dumps a Type System object to XML.
This interface defines static final constants for Type Systems
For the built-in types and features:
- the type and feature codes
- the adjOffsets
Description of a CAS TypeSystem.
Reference implementation of
TypeSystemDescription.Type system implementation.
Writable version of type system.
Type Utilities - all static, so class is abstract to prevent creation Used by Feature Path
Thrown to indicate that a method has been passed an illegal or inappropriate argument.
Signals that a method has been invoked at an illegal or inappropriate time.
Thrown to indicate that the requested operation is not supported.
Provides access to external resources (other than the CAS).
Instances of this class shared by multiple threads
Admin interface to the UIMA Context.
This class holds the UimaContext for the current thread, or a parent thread.
Reference implementation of
AnalysisEngine.Use this class to signalize a fatal (internal) error to the API user.
This is the superclass for all checked exceptions in UIMA.
This is an application's main interface point to the UIMA Framework.
This is the main interface point to the UIMA reference implemention.
This is the superclass for all unchecked exceptions in UIMA.
This interface is implemented by JCas classes that need to be called by the framework when a
serialization is about to happen.
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
Interface for a timer, used to collect performance statistics for UIMA components.
The
UIMAUtil class provides convenient methods for handling UIMA specific objects.A type of
ResourceSpecifier that locates an existing Resource service
by its URI.Reference implementation of
URISpecifier.Static methods supporting proper handling of URIs
Shared code refactored from other spots to reduce duplication and improve maintainability
XCAS Deserializer.
Exception class for package org.apache.uima.cas.impl.
XCAS serializer.
A SAX ContentHandler that reads XCAS and creates a CasData.
XMI CAS deserializer.
CAS serializer for XMI format; writes a CAS in the XML Metadata Interchange (XMI) format.
A container for data that is shared between the
XmiCasSerializer and the
XmiCasDeserializer.
Data structure holding all information about an XMI element containing an out-of-typesystem FS.
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.
Deserializes a CAS from a standoff-XML format.
Serializes a CAS to inline XML format.
An input source used by the
XMLParser to read XML documents for parsing.An interface to be implemented by UIMA classes that can be written to and parsed from XML.
A simple class used to describe how to render this object as XML.
A UIMA
XMLParser parses XML documents and generates UIMA components represented by
the XML.Reference implementation of
XMLParser.Option settings for the parser.
Utility class that generates XML output from SAX events or DOM nodes.
Class comment for XMLTypeSystemConsts.java goes here.
The
XMLUtil class provides miscellaneous XML utilities.