All Classes and Interfaces
Class
Description
Exception to notify the CPM to disable a Cas Processor.
/** Exception to notify the CPM to terminate itself.
Dialog showing standard UIMA splash screen and OK button.
The Class AboutHandler.
The Class AboutUimaHandler.
This listener listens only for
AnnotationFS change events.The base interface extended by all CAS (Common Analysis System) interfaces in the UIMA SDK.
Base class from which CAS implementations should extend.
The Class AbstractDialog.
The Class AbstractDialogKeyVerify.
The Class AbstractDialogKeyVerifyJavaNames.
The Class AbstractDialogMultiColTable.
Abstract base class for document implementations.
The Class AbstractImportablePartSection.
The Class AbstractModelPart.
Create a new file resource in the provided container.
The Class AbstractNewWizardPage.
The Class AbstractSection.
The Class AbstractSectionParm.
The Class AddAllowedValueDialog.
The Class AddCapabilityFeatureDialog.
The Class AddCapabilityTypeDialog.
The Class AddExternalResourceDependencyDialog.
The Class AddExternalResourceDialog.
The Class AddFeatureDialog.
The Class AddIndexDialog.
The Class AddIndexKeyDialog.
The Class AddLanguageHandler.
The Class AddParameterDialog.
The Class AddRemoteServiceDialog.
The Class AddSofaDialog.
The Class AddTypeDialog.
The Class AddTypeToPriorityListDialog.
This class handles the "Add UIMA Nature" action, which appear in the context menu of a project.
This class is a VinciFrame with extensions for support of XML attributes.
This class extends FrameLeaf with ability to set attributes.
Reference implementation of
AnalysisEngine.This builder makes it easier to create an aggregate analysis engine.
The Class AggregatePage.
The Class AggregateSection.
Represents an allowed value for an "enumerated" type.
Reference implementation of
AllowedValue.Model part: Map of all defined types Key = string = typename, fully qualified Value = CAS
TypeSystem Type object.
Analysis Components are the primitive "building blocks" from which UIMA solutions are built.
Implementation base class for AnalysisComponents.
Factory that builds
AnalysisComponent instances from AnalysisEngineDescription,
CasConsumerDescription, or CollectionReaderDescription objects.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.A collection of static methods for creating UIMA
AnalysisEngineDescriptions and AnalysisEngines.Resource Factory that handles
AnalysisEngineDescription and TaeDescription
elements.Provides functionality common to Analysis Engine implementations.
This delegate is responsible to to configure the VM and to create command line args which will be
passed to the
RemoteLaunchers main method.The Analysis Engine Main Tab is responsible to display/edit the UIMA related settings, such as
project, descriptor file, input folders, etc.
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.The Class AnalysisEnginePanel.
A class that is useful for generating an Analysis Engine performance report from a
ProcessTrace object.A pool of Analysis Engines, which supports reconfiguration.
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.
The tab group to set up all the parameters which are necessary to run an analysis engine.
Static utility methods relating to analysis engines.
Deprecated.
Do not use anymore.
Deprecated.
since v2.0
A
AnalysisSequenceCapabilityNode is a node element of the
CapabilityLanguageFlowObject.Updated by JCasGen Fri Nov 22 17:01:19 CET 2024
XML source: /Users/bluefire/git/uima-uimaj-release/uimafit-core/target/jcasgen/typesystem.xml
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
Checks two annotations for equality.
TODO: add type comment for
AnnotationDisplayCustomizationFrame.TODO: add javadoc here.
An editor to annotate text.
The
AnnotationEditor action contributor.The Class AnnotationEditorPreferenceConstants.
The Class AnnotationEditorPreferenceInitializer.
Preference page to manage preferences for the Annotation Editor.
Base view for views which show information about the
CAS opened in the editor.The Class AnnotationExtent.
Convenience methods to create annotations
A tree view of Annotations and associated features.
A tree view of Annotations and associated features.
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).This outline view displays all
AnnotationFSs of the current mode/type from the
binded editor.This is the
AnnotationPropertyPage. this page configures the project dependent and
type dependent annotation appearance in the AnnotationEditor.The annotation collection contains only
AnnotationFSs objects which are selected by a
IStructuredSelection.TODO: add javadoc here.
The
AnnotationStyle describes the look of an certain annotation type in the
AnnotationEditor.The styles that can be used to draw an annotation.
Annotation Style Change Listener base class which converts annotation style change events from a
Preference Store to AnnotationStyle object change events.
The Class AnnotationStyleView.
Represents an annotation tree.
Implementation of annotation tree.
Represents a node in an annotation tree.
TODO: add javadoc here.
The
AnnotationTreeNodeList class can build a tree of AnnotationTreeNode objects.The Class AnnotationTypeNode.
Dialog that loads analyzed documents stored in XMI or XCAS format and allows them to be viewed
using the Java-based CAS viewer or a web browser, in either an HTML/Javascript format or in the
inline XML format.
Main Annotation Viewer GUI.
Utility that uses XSL stylesheets to produce an HTML view (w/ Javascript) of an annotated
document.
Deprecated.
To be removed without replacement.
Base class for all annotators.
Deprecated.
As of release 2.3.0, use CasAnnotator_ImplBase or JCasAnnotator_ImplBase instead
Adapter that allows Annotators to implement the AnalysisComponent interface.
An
AnnotatorConfigurationException is thrown by an annotator if the settings of its
configuration parameters are invalid.Deprecated.
As of release 2.3.0, use {link UimaContext} instead
Deprecated.
Use {link UimaContext} instead
Deprecated.
Use {link UimaContext} instead
An
AnnotatorInitializationException may be thrown by an annotator's initialize
method, indicating that the annotator failed to successfully initialize itself.The Class AnnotatorOpenEventHandler.
Deprecated.
To be removed without replacement.
An
AnnotatorProcessException may be thrown by an annotator's process method,
indicating that a failure occurred during processing.The Class AnnotatorRerunEventHandler.
The Class AnnotatorRunCPCEventHandler.
The Class AnnotatorRunOnCasEventHandler.
Deprecated.
To be removed without replacement.
Listens for tree selections and tells the mediator it is OK to enable the class selction button.
// * @see AnTreeEvent
Feature structure array interface.
Deprecated.
use FSArray instead
TODO: add type comment for
ArrayNode.Some utilities for dealing with Arrays.
The Class ArrayValue.
Component responsible for continuously filling a work queue with bundles containing Cas'es.
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.The AssertionFailedException is thrown by Debug.java in response to failed assertion checks.
A simple name, value pair that is specified as part of a
Style to further define its
behavior.Class for representing a list of attributes for an XML element.
protectIndexes returns instances of this, rather than AutoCloseable, to permit users to use try
with resources without a catch for Exception.
Auto-folding menu.
Provides utility methods for Binary <=> Base64 conversion.
Special exception type thrown by Base64Converter.
Base interface for annotators in UIMA SDK v1.x.
Class for conjuring a Vinci service by host/port (that is, without interaction with the naming
service).
The Base
CollectionReader interface.The Base CPM interface is a lower-level interface to the Collection Processing Manager.
Main thread that launches CPE and manages it.
This "baseline" part-of-speech tagger isn't very sophisticated!
Class for running VinciServables in the Vinci framework.
Runnable class used by BaseServer to concurrently service requests.
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..
Simple binary tree class.
JCas class model for BooleanArray
Boolean array interface.
Deprecated.
use BooleanArray instead
Implementation of boolean match constraint.
Implementation of a Bounded Queue, a queue with a fixed number of slots.
Draws brackets around an annotation.
The
BrowserUtil class provides one static method -
openUrlInDefaultBrowser, which opens the given URL in the default web browser for
the current user of the system.Constants representing Built in type collections
String Sets:
creatableArrays
primitiveTypeNames == noncreatable primitives
creatableBuiltinJcas (e.g. empty/non-empty FloatList
non creatable primitives (e.g. can't do createFS for primitive int)
non creatable and builtin Arrays
Gets and caches an array list of all the built-in tcas types.
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
Capability.A
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.The Class CapabilityPage.
The Class CapabilitySection.
A simple right-aligned label for field captioning.
Caret change handler.
Object-oriented CAS (Common Analysis System) API.
A Swing component that displays annotations in a text pane with highlighting.
Base class to be extended by Annotators that use the
CAS interface.Base class for CAS annotators which initializes itself based on annotations.
Asserts related to the
CAS.Asserts related to the
CAS.Base class for CAS collection readers which initializes itself based on annotations.
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.
Base class for CAS consumers (actually a
CasAnnotator_ImplBase) which initializes itself based
on annotations.Adapter that allows CasConsumers to implement the AnalysisComponent interface.
An
CasConsumerDescription contains all of the information needed to instantiate and
use an CasConsumer.Specialized Resource Factory for producing CasConsumers.
Create a new file resource in the provided container.
The "New" wizard page allows setting the container for the new file as well as the file name.
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.
Provides the
ICasDocument for the
AnnotationEditor.The Class ElementInfo.
Dumps CAS content to a text file.
A general
RuntimeException which is thrown if something unexpected happens.TODO: add javadoc here
Preference page to manage preferences for the ide plugin.
This
PerspectiveFactory generates the initial layout for the NLP perspective.TODO: add javadoc here.
Base class for views which show information about the
CAS opened in the editor.The Class CasEditorViewPage.
Exception class for package org.apache.uima.cas.
Convenience methods to create
CAS objects.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.
Deprecated.
As of v2.0, CAS Initializers are deprecated.
Create a new file resource in the provided container.
The "New" wizard page allows setting the container for the new file as well as the file name.
Deprecated.
Since UIMA 2.9.0 the core class
CasIOUtils should be used.
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.
The Class CasMetaData.
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.Base class for a CAS multiplier which initializes itself based on annotations.
Implementation of the
CasObjectProcessor interface used for both Local and Remote
CasObjectProcessors.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.
Interface for setter and getter methods for the Cas Processor configuration as defined in the CPE
descriptor.
A wrapper containing CAS Processor configuration.
Contains configuration parameter settings for a CAS Processor.
The Class CasProcessorConfigurationParameterSettingsImpl.
Base class for all CpeCasProcessor objects in the reference implementation.
Base interface for implementing Deployer class used by the CPM to deply Cas Processors.
An object that holds configuration information used for building CPE Descriptor.
The Class CasProcessorDeploymentParamImpl.
An object that contains all
CasProcessorDeploymentParam instances.The Class CasProcessorDeploymentParamsImpl.
An object to contains configuration specific to error handling applicable to every CasProcossor.
The Class CasProcessorErrorHandlingImpl.
An object to contains configuration specific to error handling applicable to every CasProcessor.
The Class CasProcessorErrorRateThresholdImpl.
An object containing an arbitrary value that will passed to a program launched by the CPE.
The Class CasProcessorExecArgImpl.
An object containing all
CasProcessorExecArg
instances.The Class CasProcessorExecArgsImpl.
An object containing configuration for a program that the CPE will use to launch CasProcessor.
The Class CasProcessorExecutableImpl.
Object containing a filter expression used by the CPE to route CAS's to CasProcessor.
The Class CasProcessorFilterImpl.
An object that holds configuration related to handling max restarts for CasProcessors.
The Class CasProcessorMaxRestartsImpl.
An object that holds configuration that is part of the CPE descriptor.
The Class CasProcessorRunInSeperateProcessImpl.
An object that holds configuration that is part of the CPE descriptor.
The Class CasProcessorRuntimeEnvParamImpl.
An object that holds configuration that is part of the CPE descriptor.
The Class CasProcessorTimeoutImpl.
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.
A GUI that displays annotation results in a Swing tree viewer.
This class gets initialized with two type systems, and then provides resources to map type and
feature codes between them.
Utility methods for convenient access to the
CAS.CAS validation check.
The Class CDEpropertyPage.
TODO: add javadoc here.
Collection of utilities for character handling.
A map from subsequences of a character array to objects.
An unsafe String class based on a publicly accessible character array.
INTERNAL API
Custom property editor for
Charset.Running in a separate thread creates a checkpoint file at predefined intervals.
Object containing checkpoint configuration.
Serializable containing the checkpoint.
Reference implementation of
AnnotatorContext.Convenience class that is used to hold metadata associated with chunking and sequencing of
documents.
Utilities supporting a unified approach to loading classes,
incorporating the resource manager's class loader if available,
and making use of the Thread Context Class Loader (TCCL)
For backwards compatibility, if a class is not found using the
Thread Context Class Loader,
for classloading: try again using the
class loader for this class since that's what the previous impl did,
and some applications will break otherwise, with class-not-found.
Deprecated.
Use
ClassLoaderUtils instead.INTERNAL API - Helper functions to obtain a suitable class loader.
Window closing handler for annotation viewer.
The Class CloseLogViewHandler.
The Class CloseTypeSystemHandler.
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.
Adapter that allows CollectionReaders to implement the AnalysisComponent interface.
An
CollectionReaderDescription contains all of the information needed to instantiate
and use an CollectionReader.Specialized Resource Factory for producing CollectionReaders.
Create a new file resource in the provided container.
The "New" wizard page allows setting the container for the new file as well as the file name.
TODO: add type comment for
ColorIcon.The Class ColorManager.
The Class ColorParser.
The Class ColorPrefsOpenHandler.
The Class ColorPrefsSaveHandler.
Simple command line parsing utility.
A common superclass for hash maps and hash sets
Common parts of the Array interfaces.
Deprecated.
The Class CommonInputDialog.
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.
Interface for a comparable FSIterator.
Interface for a comparable IntListIterator.
Deprecated.
Not used anymore.
Updated by JCasGen Fri Nov 22 17:03:35 CET 2024
XML source: /Users/bluefire/git/uima-uimaj-release/uimaj-it-pear-with-typesystem/target/jcasgen/typesystem.xml
Updated by JCasGen Fri Nov 22 17:03:35 CET 2024
XML source: /Users/bluefire/git/uima-uimaj-release/uimaj-it-pear-with-typesystem/target/jcasgen/typesystem.xml
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.
Configuration Field class used for representation of resource parameters in dynamically created
MetaDataPanels.
Instances of this class model the 3 varients of configuration parameter sets.
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.The Class ConfigurableFeature.
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.
This annotation marks an analysis component member variable as a configuration parameter.
Completely specifies a configuration parameter on a UIMA resource.
Reference implementation of
ConfigurationParameter.The declarations of configuration parameters in a Resource.
A simple class for storing an array of configuration parameters along with an array of the
values that will fill in those configuration parameters
Initialize an instance of a class with fields that are annotated as
ConfigurationParameters from the parameter values given in a UimaContext.The values for
ConfigurationParameters in a Resource.Reference implementation of
ConfigurationParameterSettings.Constants used by the Vinci service.
CPE Constants
Some constants used by the UIMA framework.
Constants
Methods to create
FSMatchConstraints for filtered iterators or other
use.Implementation of the ConstraintFactory interface.
The Class ConsumerCasUtils.
The Class ConsumerPanel.
Filters out all annotations which are not contained by one of the provided annotations.
Create a fast way of repeatedly checking whether instances of one type are contained within the
boundaries on another type.
The Class ContentAssistField32.
The Class ContextForPartDialog.
common APIs supporting the copy on write aspect of index parts
implements ObjHashSet partially, for iterator use
implements OrderedFsSet_array partially, for iterator use
Build a Collection Processing Engine from a
CollectionReaderDescription and a
AnalysisEngineDescription.Implements object pooling mechanism to limit number of CAS instances.
An object that holds configuration that is part of the CPE descriptor.
An object that holds configuration that is part of the CPE descriptor.
The Class CpeCasProcessorsImpl.
An object that holds configuration that is part of the CPE descriptor.
The Class CpeCheckpointImpl.
An object that holds configuration that is part of the CPE descriptor.
Deprecated.
As of v2.0 CAS Initializers are deprecated.
Deprecated.
As of v2.0, CAS Initializers are deprecated.
The Class CpeCollectionReaderImpl.
An object that holds configuration that is part of the CPE descriptor.
The Class CpeCollectionReaderIteratorImpl.
An object that holds configuration that is part of the CPE descriptor.
The Class CpeComponentDescriptorImpl.
Object containing global cpe configuration.
An object that holds configuration that is part of the CPE descriptor.
The Class CpeConfigurationImpl.
To change the template for this generated type comment go to
Window>Preferences>Java>Code Generation>Code and Comments
Implements
CasProcessorDeployer.Java representation of a Collection Processing Engine (CPE) XML descriptor.
The Class CpeDescriptionImpl.
Factory class for creating CpeDescriptors and their constituent objects.
Component responsible for generating objects representing cpe descriptor configuration.
An object that holds configuration that is part of the CPE descriptor.
The Class CpeIncludeImpl.
An object that holds configuration that is part of the CPE descriptor.
The Class CpeIntegratedCasProcessorImpl.
An object that holds configuration that is part of the CPE descriptor.
The Class CpeLocalCasProcessorImpl.
The Class CpeObject.
An object that holds configuration that is part of the CPE descriptor.
The Class CpeRemoteCasProcessorImpl.
An object that holds configuration that is part of the CPE descriptor.
The Class CpeResourceManagerConfigurationImpl.
The Class CpeSofaMappingImpl.
The Class CpeSofaMappingsImpl.
This class provides an API to plug in custom timers.
The Class CPMChunkTimeoutException.
Responsible for creating and initializing processing threads.
This component catches uncaught errors in the CPM.
The Class CpmFrame.
The Class CpmLocalizedMessage.
The Class CpmPanel.
The Class CPMUtils.
The Class CreateFeatureStructureDialog.
TODO: add javadoc here.
Resource Factory that handles
CustomResourceSpecifier elements.A type of
ResourceSpecifier that specifically names the Java class that should be
created.Implementation of
CustomResourceSpecifier.The main class for the CAS Visual Debugger.
The Class DATACasUtils.
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.Updated by JCasGen Fri Nov 22 17:01:30 CET 2024
XML source: /Users/bluefire/git/uima-uimaj-release/uimafit-examples/target/jcasgen/typesystem.xml
Updated by JCasGen Fri Nov 22 17:01:30 CET 2024
XML source: /Users/bluefire/git/uima-uimaj-release/uimafit-examples/target/jcasgen/typesystem.xml
Miscellaneous debugging functionality such as error logging, assertion checking and exception
reporting.
The Class DebugControlThread.
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 main plugin class to be used in the desktop.
The class that has the startup code.
Utility to assign default colors to the annotation types in the TypeSystem.
Model part: names of the defined types, augmented with their supertypes This means that some of
the built-ins (those in the super chain) will be included.
Deletes all selected annotations.
Produces a deployer object for each type of deployment: local, remote and integrated.
INTERNAL API - Helper functions for operatin with descriptions.
Instance of this class handles parsing of the xml descriptor files.
Instances of this class model the varients of getting and setting metadata.
Model part: CAS corresponding to the descriptor being edited.
When you are running a suite of unit tests it is often nice to turn off logging.
A simple GUI for the RunTextAnalysis application library.
The JCas class definition for the CAS
DocumentAnnotation type.This document implementation is based on an uima cas object.
This class contains all project specific configuration parameters.
This class is responsible to read and write
DotCorpus objects from or to a byte stream.JCas class model for DoubleArray
Double array interface.
Deprecated.
use DoubleArray instead
A factory for drawing styles.
This class is used to provide additional information about the
AnnotationFS object to the
custom drawing strategies.This class handles the "Edit Installation Descriptor" action, which appear in the context menu of
a PEAR installation descriptor (install.xml)
Wizard to edit the PEAR Installation Descriptor.
The Class EditorAnnotationPropertyPage.
The Class EditSofaBindingsDialog.
The Class ElapsedTimeFormatter.
Trivial CasIterator that returns no CASes.
a marker interface for empty lists
Allow a
PrintStream to specify an encoding.INTERNAL API - Marks a class as having been processed by an uimaFIT class enhancer, such as the
uimafit-maven-plugin.
Enhance UIMA components with automatically generated uimaFIT annotations.
Contains information about the successful or unsuccessful processing of an entity (an element of
a collection) by the
CollectionProcessingManager.Pluggable interface that supports Entity View mode in the CasAnnotationViewer.
Object representing an Entity.
Special class interpreted by the CPM's ProcessingUnit as the end of processing.
The Class EP_LogThrowErrorImpl.
This is a special VinciFrame that simplifies returning error or exceptional conditions.
This AE evaluates the system part-of-speech tags against the gold part-of-speech tags.
ExceptionPrinter print out an exception with the place where the exception occurs
Contains command line and environment for launching a separate process.
Facilitates cleaning up resources associated with chunking/sequencing logic.
The Class ExportImportablePartDialog.
INTERNAL API - Extended
ExternalResourceDescription_impl which can carry
ExternalResourceDescriptions.Mark a field as external resource.
Allows an external resource to use the
ExternalResource annotation on member variables to
gain access to other external resources.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.Example for the use of external resources with uimaFIT.
Example annotator that uses the share model object.
Simple model that only stores the URI it was loaded from.
Example for the use of external resources with uimaFIT.
Example annotator that uses the share model object.
Simple model that only stores the URI it was loaded from.
Example for the use of external resources with uimaFIT.
Example annotator that uses the resource.
Simple example resource that can use another resource.
Helper methods for external resources.
Configurator class for
ExternalResource annotations.Get instance of external resource.
The Class ExtnlResBindSection.
The FatalException class is used to convert any checked exception into an unchecked exception to
terminate the current thread due to unrecoverable and unexpected error conditions.
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.
The Class FeatureMap.
Interface for a feature path.
An object in the CAS.
Interface for feature structures.
The Feature Structure Browser View displays a list of feature structures which belong to the
selected type.
The actual view page which contains the ui code for this view.
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
Provide the labels for the given
FeatureStructures.The Class FeatureStructureSelection.
Iterates over all selected
FeatureStructures.This class is able to transfer a
FeatureStructure objects.Insert comment for enclosing_type here.
The base interface for the value of a feature.
The Class FeatureValue.
Deprecated.
use
FeaturePathContains CAS Type and Feature objects to represent a feature path of the form
feature1/...
Sends kill -9 to a process
The Class FileAndShortName.
Workarounds for JFileChooser bugs on Windows Look and Feel.
FileCompare class provides a several methods, which compare two files or input streams.
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.The Class FileOpenEventHandler.
A type of
ResourceSpecifier that locates a resource file using its URL.Reference implementation of
FileResourceSpecifier.The Class FileSaveAsEventHandler.
The Class FileSaveEventHandler.
Composite component to allow file or directory input or selection.
Composite component to allow file or directory input or selection.
The listener interface for receiving fileSelector events.
The listener interface for receiving fileSelector events.
A simple collection reader that reads documents from a directory in the filesystem.
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.
Parses the filter expression associated with a Cas Processor in the cpe descriptor.
Specifies a constraint that matches against annotations in the CAS.
Indicates that a CAS has finished being processed by the aggregate.
An Action to open the Find/Annotate Dialog.
The Class FindComponentDialog.
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.Create a new file resource in the provided container.
The "New" wizard page allows setting the container for the new file as well as the file name.
Instances of this class model the varients of flow nodes in a uniform way.
The Class FlowSection.
Focus in annotation frame action handler.
Action handler for focus in index repository frame.
Focus in text frame action handler.
3 element return value for 2 panel forms.
The Class FormPanel.
Frame is an abstract class that is intended to be extended to implement a simple & lean
(restricted) XML document model.
Base class for components that can be included in Frame documents.
Class encapsulating leaf data from a Frame.
Interface required by Frame to support marshalling.
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(...)
Interface for a boolean constraint.
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.
Bridge between Java
Collections from different representations of collections
of UIMA FeatureStructures.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
Indicates that no type has been set.
Description of a collection of CAS feature structure indexes.
Create a new file resource in the provided container.
The "New" wizard page allows setting the container for the new file as well as the file name.
Deprecated.
Use
TypeSystemProvider instead.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. select, iterating over multiple views)
aggregation of indexes in type/subtype hierarchy
Supports creating corresponding iterators just for the non-empty ones
Supports reinit - evaluating when one or more formerly empty indexes is no longer empty, and recalculating the
iterator set
Supports move-to-leftmost when typeOrdering is to be ignored
-- when no typeorder key
-- when typeorder key, but select framework requests no typeordering for move to leftmost
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.
A node in the FS Tree Model
A node is - an Feature Structure array -- elements may be other nodes - a primitive value,
including Strings - a Feature Structure.
Interface for a String constraint.
Swing Tree Model for Feature Structures.
TODO: add type comment for
FSTreeNode.Handle selection of annotations in annotation frame.
Interface for type constraint.
The Class GeneralSection.
Generate descriptor files for uimaFIT-based UIMA components.
This class handles the "Generate PEAR" action, which appear in the context menu of a project with
the UIMA nature.
Wizard to generate a PEAR file.
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
INTERNAL API
Custom property editor that tries to look convert and value to a string by checking if there is a
registered property editor for the source value.
Deprecated.
Use org.apache.uima.tools.cvd.CVD instead.
This AE assumes that their is part-of-speech tagged text in the default view with the format
"word/tag word/tag...".
A simple graph class.
Interface for a generic node in a graph.
The Class GUI.
The Class GuiErrorImpl.
The Class GuiProgressMonitor.
Common part of most pages.
The Class HeaderPageWithSash.
the v2 CAS heap - used in modeling some binary (de)serialization
The Class HelpHandler.
Display help information on jcasgen-maven-plugin.
Call
Call
mvn jcasgen:help -Ddetail=true -Dgoal=<goal-name> to display parameter details.Display help information on PearPackagingMavenPlugin.
Call
Call
mvn pear:help -Ddetail=true -Dgoal=<goal-name> to display parameter details.Display help information on uimafit-maven-plugin.
Call
Call
mvn uimafit:help -Ddetail=true -Dgoal=<goal-name> to display parameter details.This class provides a way to hide output sent to System.out and System.err.
Like InternationalizedException, but is an interface with default methods.
Internationaliation utilities.
Common implementation of InternationalizedException and InternationalizedRuntimeException
The listener interface for receiving IAnnotationEditorModify events.
The listener interface for receiving IAnnotationStyle events.
The
ICasDocument represents texts with meta information.This interface is used to notifies clients about
FeatureStructure changes.A Cas Editor is an extension to the
IEditorPart interface and is responsible to view and
edit a CAS object.The listener interface for receiving ICasEditorInput events.
The Interface ICustomInformationControlContentHandler.
A map from ints representing FS id's (or "addresses") to those FSs There is one map instance per
CAS (all views).
The IDGenerator generate unique IDs.
The listener interface for receiving IEditorSelection events.
The Interface IError.
The Class ImageButton.
All images in the Cas Editor are referenced here.
Names of images and utility methods to get images.
The Interface IMerge.
The listener interface for receiving IModeMenu events.
An import declaration.
This import dialog can import text files into a corpus.
The Class ImportResBindSection.
Imports - used by aggregates types type priorities indexes external resource specifications.
An individual item within a
IndexBuildSpecification.Determines how a
CAS get indexed with a UIMA-compliant search engine.The Class IndexesPage.
The Class IndexImportSection.
Thrown by the Index to indicate that a failure has occurred during indexing.
The listener interface for receiving indexPopup events.
A rule that specifies indexing behavior.
The Class IndexSection.
Class comment for IndexTreeNode.java goes here.
Change the display of the FSTree if a type in an index is selected.
// * @see IndexTreeSelectionEvent
This interface provides a way of initializing a class with a
UimaContext.Please see
Initializable for a description of how this class is intended to be used.A simple CAS consumer that generates inline XML and writes it to a file.
This is wizard page to edit UIMA component basic information.
this interface defines common constants used in classes related to handling PEAR Installation
Descriptor.
This is wizard page to edit PEAR Installation Environment parameters.
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.This GUI is used to install a pear file locally in a directory chosen by the user and then run
the installed AE in CVD.
The
PEARFilter class allows to filter directories, as well as '.tear' and '.pear'
files.The
RunInstallation class implements a thread that is used to run the
installation.The Class InstallPearCli.
The
InstrumentationFacility interface defines a standard way for UIMA components to
be instrumented for performance evaluation.Reference implementation of
InstrumentationFacility.A map from ints to Feature Structures
Is Pear aware - stores non-pear versions but may return pear version in pear contexts
A map<int, int>
based on having a key and value int array, where the keys are sorted
Supports sharing a single key array with multiple value arrays
Implements Map - like interface: keys and values are ints
values can be anything except 0; 0 is the value returned by get if not found
All adds must occur before any gets; then a sort must be called unless the adds are in sort order
Threading: instances of this class may be accessed on multiple threads (different iterators may
be on different threads)
A map<int, int>
uses IntArrayRBTcommon
Int to Int Map, based on IntArrayRBT, used in no-duplicates mode
Implements Map - like interface:
keys and values are ints
Entry set not (yet) impl
no keySet()
no values()
A map<int, T>
based on JCasHashMap, but without the multi-threading support
This impl is for use in a single thread case only
Supports shrinking (reallocating the big table)
Implements Map - like interface: keys are non-0 ints - 0 is reserved for the empty key slot -
Integer.MIN_VALUE is reserved for removed slot
values can be anything, but null is the value returned by get if not found so values probably
should not be null
remove supported by replacing the value slot with null, and replacing the key slot with a
"removed" token.
A map<int, T>
based on ArrayList
This impl is for use in a single thread case only
Implements Map - like interface: keys are ints ≥ 0
values can be anything, but null is the value returned by get if not found so values probably
should not be null
remove not currently supported
Interface for CAS int arrays.
Deprecated.
use IntegerArray instead
Deprecated.
Not used anymore.
Common part of Red-black tree implementation based on integer arrays.
Utilities used by some of the IntX classes.
A set of non-zero positive ints.
Compare two integers.
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
The Class IntegerField.
like Entry<k, v> except the k is an int.
The Class InternalErrorCDE.
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.A set of non-zero ints.
Used in the CAS implementation.
Int iterator in the Java style, but returning/using ints.
Int iterator moving forwards and backwards, in the UIMA style.
Helper class to read array-based binary search trees with integers as keys and values.
map<int, int%gt; uses separate objects (IntRBTNode) as nodes
See the
RedBlackTree class.This class implements a set of integers.
A stack of integers.
Like
java.util.Vector, but elements are ints.Thrown by the
XMLParser to indicate that an XML document is invalid or does not specify a
valid object of the desired class.The Interface IProgressMonitor.
The listener interface for receiving IShowAnnotations events.
Special ClassLoader that helps us modeling different class loader topologies.
An Iterator with an extra method nextNvc, which skips the validity check
Notifies clients about type changes.
The interface implemented by an external editor.
This interface is used to redirect the editing functions from CDE to the external editor for a
new type of Resource Specifier.
The Interface IXMLColorConstants.
Component responsible for configuring command line for java based CasProcessor.
Deprecated.
replaced by
UimaTimerSimple implementation of
UimaTimer using System.currentTimeMillis().Java Cover Classes based Object-oriented CAS (Common Analysis System) API.
Base class to be extended by Annotators that use the
JCas interface.Base class for JCas annotators which initializes itself based on annotations.
Asserts related to the
JCas.Allows to add types and text to a CAS easily piece by piece.
Deprecated.
Use
TypeSystemProvider instead.Base class for JCas collection readers which initializes itself based on annotations.
Base class for JCas consumers (actually a
JCasAnnotator_ImplBase) which initializes itself based
on annotations.Convenience methods to create
JCas objects.Convenience base class for Flow objects that use the JCas interface.
Base class to be extended by FlowControllers that use the
JCas interface.Applies JCasGen to create Java files from XML type system descriptions.
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.
A class implementing iteration over a the documents of a collection.
An iterator over a collection of JCAS objects.
A class implementing iteration over a the documents of a collection.
Wraps a CasIterator as a JCasIterator
Base class to be extended by CAS Multipliers that use the
CAS interface.Base class for a JCas multiplier which initializes itself based on annotations.
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.
Utility methods for convenient access to the
JCas.JCas validation check.
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.
Class holds type plugin-wide collections and static methods.
The Class ErrorExit.
Interface implemented by JCAS code generation's templates.
The main plugin class to be used in the desktop.
Class holds type plugin-wide collections and static methods.
Utility class for registering MBeans with a JMX MBeanServer.
Deprecated.
To be removed without replacement
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)
A JTabbedPane which has a close ('X') icon on each tab.
Deprecated.
As of release 2.3.0, use JCasAnnotator_ImplBase instead
Deprecated.
As of release 2.3.0, use JCasAnnotator_ImplBase instead
Contains static convenience methods for using the UIMA JUnit extensions.
JUnitTestRunner is the start class for the comand line test with JUnit.
Object for storing each key/value within a frame.
The Class LabelCellEditor.
Provides information on the languages supported by a component.
A precondition on the language of the document.
Precondition that tests language of the document.
The Class LauncherPlugin.
Special unchecked exception type thrown by FrameLeaf when encountering data type conversion
errors.
INTERNAL API - Legacy support.
INTERNAL API - Legacy support plug-in API.
Provides the message level constants for logging and tracing
Helper methods to handle the life cycle of UIMA components.
Linear order on types.
Defines a pre-order on types.
Implementation of the
LinearTypeOrderBuilder interface.An implementation of the
LinearTypeOrder interface.This collection reader is meant for example purposes only.
Deprecated.
To become package private in
org.apache.uima.jcas.cas or possibly removed.A composite component comprising a JList and associated controls used to add and remove list
elements and to control their ordering.
Implements a low level ambiguous or unambiguous iterator over some type T which doesn't need to
be a subtype of Annotation. - This iterator skips types which are not Annotation or a subtype of
Annotation.
The Class LoadRecentDescFileEventHandler.
The Class LoadRecentTextFileEventHandler.
INTERNAL API
Custom property editor for
Locale that supports "-" as separator and sets the default
locale when null or "" is passed.The
LocalInstallationAgent allows localizing files of UIMA compliant components
within the single PEAR structure, and verifying localized component's files using UIMA framework
API.LOCAL Vinci Naming Service.
UIMA Logging interface implementation for Log4j
This version is for Log4j version 2, from Apache
Built using version 2.8
Simple file viewer for viewing log files.
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.
The Class LogThrowErrorImpl.
JCas class model for LongArray
Long array interface.
Deprecated.
use LongArray instead
Lowers the left side of the currently selected annotation by one.
Lowers the right side of the currently selected annotation by one.
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.
Class comment for MainFrame.java goes here.
Insert comment for enclosing_type here.
Save preferences on closing CVD.
Provides a
CAS object which is automatically reset before the test.Provides a
JCas object which is automatically reset before the test.Base interface for objects that expose a monitoring and management interface to a UIMA component
or some part of the UIMA framework.
This class manupulates the output of the system.
Show the CVD manual in a Swing html widget.
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.
Represents an element in a list of markup extents.
Updated by JCasGen Fri Nov 22 17:01:30 CET 2024
XML source: /Users/bluefire/git/uima-uimaj-release/uimafit-examples/target/jcasgen/typesystem.xml
Merges two or more annotations.
The Class MergerImpl.
The
MessageRouter class facilitates intra-process message routing.The
StdChannelListener interface declares methods that should be implemented by
each standard message channel listener.The Class Messages.
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.
A dynamically generated form panel with components generated from configuration parameters
specified as ResourceMetaData.
The Class MetaDataSection.
INTERNAL API - Kinds of meta data uimaFIT uses.
INTERNAL API - Utility methods to locate and access uimaFIT meta data.
A driver that scans given roots for source and/or class Java files that contain JCas classes
identifies which ones appear to be JCas classes (heuristic)
of these, identifies which ones appear to be v2
converts these to v3
also can receive a list of individual class names
also can do a single source file
Provides information on the MIME types supported by a component.
A precondition on the MIME Type of the entity.
Precondition that tests the MIME type of the Entity's content.
TODO: set feature value to null delete feature value structure create feature value structure.
Creates the mode context sub menu.
Class Loader for loading localized messages
See https://issues.apache.org/jira/browse/UIMA-1714
Delegates to other ClassLoaders, in the following order
the class loader that loaded the 2nd previous caller
the class loader that loaded the 3rd previous caller
etc.
Class comment for MultiAnnotViewerFrame goes here.
TODO: add type comment for
MultiMarkup.Main class implementing the multi page editor.
The Class JCasGenProgressMonitor.
The Class JCasGenThrower.
Manages the installation/deinstallation of global actions for multi-page editors.
An
AnalysisEngine implementation that can process multiple CAS objects
simultaneously.The Class MultiResourceSelectionDialog.
The Class MultiResourceSelectionDialogWithFlowOption.
A class that stores the name of an attribute and the Class of that attribute's value.
Provides a command-line interface for querying VNS.
Stores a name (String) and value (Object).
A type of
MetaDataObject that stores a name (String) and value (Object).Reference implementation of
NameValuePair.The Class NameValuePairImpl.
Implementation of the
CasDataProcessor interface used for both Local and Remote
CasDataProcessors.Network utilities.
Clear text area.
a marker interface for nonempty lists
Component responsible for configuring command line for non-java based CasProcessor.
The Class NonRuleBasedDamagerRepairer.
The Class NonThreadedProcessingUnit.
No-operation annotator.
A Map from non-null Objects of type T to ints int value 0 reserved to mean object is not in the
table.
This class is able to transfer an
Object object.A set of Objects of type T
This impl is for use in a single thread case only, when table is being updated.
The Class OFSocketTransportImpl.
Control aspects of the UIMA analysis component.
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 one is being used, the other one (ending in 2) may be put back into service for large sizes,
later. (7/2017)
A set of FSs, ordered using a comparator Not thread-safe, use on single thread only
Use: set-sorted indexes in UIMA
Entries kept in order in 1 big TOP[]
have ensureCapacity - grows by doubling up to multiplication-limit point, then by addition
Adds optimized:
- maintain high mark, if >, add to end
shifting optimization:
for removes: shift space to back or front, whichever is closer
for adds: shift space from back or front, whichever is closer
This one not in current use Maybe be put back into service when the array becomes large and it
starts outperforming the other
A set of FSs, ordered using a comparator Not thread-safe, use on single thread only
Use: set-sorted indexes in UIMA
Entries kept in order in 1 big ArrayList
Adds optimized:
- maintain high mark, if >, add to end
- batch adds other than above
-- do when reference needed
-- sort the to be added
- to add to pos p, shift elements in p to higher, insert
shifting optimization:
removes replace element with null
shift until hit null
nullBlock - a group of nulls (free space) together
- might be created by a batch add which
adds a block of space all at once
- might arise from encountering 1 or more "nulls" created
by removes
- id by nullBlockStart (inclusive) and nullBlockEnd (exclusive)
bitset: 1 for avail slot
used to compute move for array copy
This is used in a particular manner:
only used to create iterators over that subset
-- no insert/delete
The Class OutlinePageBook.
The Enum OutlineStyles.
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 Class OutputQueue_impl.
The Class OverviewPage.
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.
The Class ParameterDelegatesSection.
A resource that provides access to data, where the data can vary based on parameters.
The Class ParameterPage.
The Class ParameterSection.
display parameters on the settings page.
Deprecated.
The Constraint Parser is not supported in externally released versions of UIMA
UIMA pear runtime analysis engine wrapper.
inner class StringPair
This is the generic exception used to handle exceptions related to PEAR.
A util class for PEAR export operations.
Utility class which helps managing messages.
IRunnableWithProgress that creates a zip file containing a given set of resources *.Wizard page for exporting resource to a PEAR file.
Handles the PEAR installation descriptor (install.xml)
PEAR package command line interface.
PearPackagingMojo which generates an UIMA PEAR package.
The main plugin class.
The Class PearProjectCustomizationException.
A type of
ResourceSpecifier that locate an installed pear Resource.Reference implementation of
PearSpecifier.Mock-up of dialog for reporting performance stats.
Deprecated.
To be removed without replacement.
Deprecated.
To be removed without replacement.
The Class PickOverrideKeysAndParmName.
The Class PickTaeForTypesDialog.
The
PMController class allows to merge several input PEAR files in one PEAR file and
generate an aggregate analysis engine from the components encapsulated in the input PEARs.The
PMControllerHelper class implements utility methods that are utilized by the
PMControllerThe
PMUimaAgent class implements UIMA-based utility methods utilized by the
PMControllerMaintains a pool of connections to a given service and allows thread-safe querying of that
service.
Action handler for text pop-up menu items.
Handle text pop-up (mouse) events.
An set of non-zero integers, ability to iterate over them (possibly in a sorted way), with O(1)
operations for adding, removing, and testing for contains.
An set of non-zero integers, ability to iterate over them (possibly in a sorted way),
with O(1) operations for adding, removing, and testing for contains.
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.The Class PreferencePage.
The Class Prefs.
The Class PrefsMediator.
Reference implementation of
AnalysisEngine.A subtype of FeatureStructure that represents an array of primitive values (Strings, int, or
floats).
The Class Primitives.
This class is misnamed - refers really to Runtime Information.
Represents a primitive feature value - a string, integer, or float.
The Class PriorityListSection.
Interface for the custom deployer component responsible for launching and terminating fenced
CasProcessors.
Base interface for implementing a Container object responsible for managing Cas Processor
instances at runtime.
Manages a pool of CasProcessor instances.
Reference implementation of
ProcessingResourceMetaData.This component executes the processing pipeline.
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.
The Class ProgressMonitorImpl.
A util class to handle customization of IProject with the UIMA nature
INTERNAL API
A simple class containing information on how to render a property in XML.
QueryableFrame is a decorator class that extends Frame.
Convenience wrapper that is internally used by the CPM.
Part of map<int, T> RedBlackTree
Represents a key-value pair of a red-black tree.
List of recently used files.
Interface facilitating CollectionReader recovery from failures.
Map from int to T (Object)
An implementation of Red-Black Trees.
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.
INTERNAL API - Utility methods to access Java annotations.
Used by the resource manager to resolve relative URLs to absolute URLs.
Reference implementation of
RelativePathResolver.The RemoteLauncher runs the actual Analysis Engine in the launched VM.
The Class RemoveLanguageHandler.
String replacement utility.
Result class for string replacement.
Specialized document (Frame) for representing the result of resolving a service name to host/port
through VNS.
Resource is the general term for all UIMA components that can be acquired and used
by an application (or by other resources).Base class for external resources which initializes itself based on annotations.
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, and
CollectionReaderDescription.Reference implementation of
ResourceCreationSpecifier.Declaration of primitive external resource dependencies A 4 col table: bound/unbound, keys, opt
flag, and interface name.
A
ResourceFactory is used to acquire instances of Resources.Thrown by
Resource.initialize(ResourceSpecifier,Map) to indicate that a failure has
occurred during initialization.INTERNAL API - Helper resource used when an
ExternalResource annotation is used on an
array or collection field.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.Create a new file resource in the provided container.
The "New" wizard page allows setting the container for the new file as well as the file name.
INTERNAL API - Helper functions for dealing with resource managers and classloading
This API is experimental and is very likely to be removed or changed in future versions.
Deprecated.
This can be used to add component-level meta data such as version, vendor, etc.
Encapsulates all metadata for a
Resource.Reference implementation of
ResourceMetaData.Convenience methods to create resource metadata.
The Class ResourcePickerDialog.
This class represents a simple pool of
Resource instances.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.
The Class ResourcesPage.
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
The Class RestoreLangDefaultsHandler.
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.Updated by JCasGen Fri Nov 22 17:01:30 CET 2024
XML source: /Users/bluefire/git/uima-uimaj-release/uimafit-examples/target/jcasgen/typesystem.xml
Here, the type capabilities are annotated using the @TypeCapability annotation which are used by
the AnalysisEngineFactory to specify this information in the descriptors returned by, e.g.
This class demonstrates annotating member variables with the @ConfigurationParameter annotation.
This class provides a main method which shows how to generate an XML descriptor file using the
RoomNumberAnnotator class definition.
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.
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
An example application that reads documents from the file system, sends them though an Analysis
Engine(AE), and produces XML files with inline annotations.
This class demonstrates a very common (though simplified) experimental setup in which gold
standard data is available for some task and you want to evaluate how well your analysis engine
works against that data.
The Class RunnableApplication.
The
RunnableContainer interface.Deserializes an
XMLizable object from SAX events.Reference implementation of
SaxDeserializer.A SAX content handler that builds a VinciFrame corresponding to the SAX events received.
Annotator for CAS test cases.
Annotator for CAS test cases.
Annotator for CAS test cases.
The Class SearchMonitoringThread.
The Class SearchThread.
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?
The Class SelectTypeDialog.
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
Updated by JCasGen Fri Nov 22 17:01:30 CET 2024
XML source: /Users/bluefire/git/uima-uimaj-release/uimafit-examples/target/jcasgen/typesystem.xml
Updated by JCasGen Fri Nov 22 17:01:19 CET 2024
XML source: /Users/bluefire/git/uima-uimaj-release/uimafit-core/target/jcasgen/typesystem.xml
This simple AE copies tokens and sentences from one view to another.
This component extends the Bound Queue by guaranteeing delivery of CASes in sequential order.
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.
Serialize and Deserialize arbitrary objects to/from byte arrays, using standard Java object
serialization/deserialization support.
Specialized document (Frame) for representing result of querying VNS for the port on which a
service should be provided.
A serializable class containing the information passed to and returned from Analysis Engine
Services.
Special exception type thrown when a socket connection to VNS or the desired Vinci service could
not be established.
Special exception thrown by VinciClient indicating an "application level" error or exception.
Class representing a service's attributes, used by VNSCommandLine
Pool containing and managing instances of CasProcessors.
Primary interface into the services database.
Services of the same name get put in the same stack and stored within the ServiceTree.
Data structure for storing/indexing/querying the set of service entries.
An object that encapsulates all conversational state between a UIMA
Resource and a
particular client.The Class SetCodePageHandler.
The Class SetDataPathHandler.
The Class SetLanguageHandler.
The Class SetLogConfigHandler.
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 Class SettingsPage.
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
Show the multi-annotation text window.
The Class ShowAnnotationCustomizerHandler.
Creates the show annotations context sub menu.
The Class ShowTypesystemHandler.
The Class Shutdown.
Updated by JCasGen Fri Nov 22 17:03:35 CET 2024
XML source: /Users/bluefire/git/uima-uimaj-release/uimaj-it-pear-with-typesystem/target/jcasgen/typesystem.xml
EXPERIMENTAL CODE
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.
SimpleTransportable is an immutable Transportable object that simply writes a byte buffer for its
toStream implementation.
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.
The Class SliderField.
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
Reference implementation of the
CasProcessorDeployer component responsible for launch and
termination of the fenced CasProcessor.The Interface SocketTransport.
@SofaCapability(inputSofas = { GOLD_VIEW, SYSTEM_VIEW })
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.Convenience methods to handle SofA mappings.
The Class SofaMapSection.
The listener interface for receiving sofaSelection events.
A set of integers, maintained as a sorted array.
Stores detailed information about the original source document from which the current CAS was initialized.
This class usually specifies an continous are of text.
Allowing UIMA components to access beans from a
context.Utility methods for creating form- or grid-style layouts with SpringLayout.
The Interface StandardStrings.
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.
Simple static adapter method for converting stream into byte[]
Matches all annotations of an added type.
JCas class model for StringArray
String array interface.
Deprecated.
use StringArray instead
Pop-up event adapter for string valued features in the FS display.
Support for legacy string heap format.
Appears to be unused, 1-2015 schor
Straightforward, many-to-one map from Strings to ints, based on a Java
HashMap.The
StringUtil class provides utility methods for working with strings.An assorted collection of string utilities.
An indexing style.
The Class StyleConstants.
A GUI for editing style maps for the annotation viewer.
The Class StyleMapEntry.
Data structure used by the editor, which represents an entry in the style map.
The Class StyleMapTableModel.
A simple SAX parser for Style Map XML documents.
Subiterator implementation.
The Class SubPageSite.
This action triggers the switch of the outline style.
The SymbolTable class provides a generic symbol table.
Interface facilitating recovery of CollectionReaders to the last known entity
Return a java Properties object containing environment variables.
The Class SystemExitHandler.
Callback interface used in conjunction with JTabbedPaneWithCloseIcons.
Mediates GI elements in StyleMapEditor keeping buttons enabled or disabled depending on whether a
row is selected.
The listener interface for receiving tableSelection events.
Create a new file resource in the provided container.
The "New" wizard page allows setting the container for the new file as well as the file name.
The main plugin class to be used in the desktop.
Deprecated.
As of v2.0,
AnalysisEngineDescription should be used instead.Deprecated.
since v2.0
A general
RuntimeException which is thrown if something unexpected happens.The Class TagRule.
Interface for components that generate a String representation of a CAS.
Deprecated.
As of v2.0, use
CasToInlineXml instead.TeePrintStream duplicates a PrintStream.
Deprecated.
As of v2.0,
AnalysisEngine should be used instead.Deprecated.
As of v2.0, use
AnalysisEnginePool instead.Deprecated.
As of release 2.3.0, use CasAnnotator_ImplBase or JCasAnnotator_ImplBase instead
Listener for changes in text frame.
The Class TextColorDrawingStrategy.
Text pop-up action (for keyboard accessibility).
The Class TextFocusHandler.
An implementation of a text tokenizer for whitespace separated natural language text.
An implementation of a text tokenizer for whitespace separated natural lanuage text.
* This class tells the Mediator to check the length of the 3 text fields and adjust whether the 3
buttons are enabeld or not.
// * @see TfDocumentEvent
* This class tells the Mediator to check the length of the 3 text fields and adjust whether the 3
buttons are enabeld or not.
// * @see TfFileSelectorEvent
This class tells the Mediator to check the lenght of the 3 text fields and adjust whether the 3
buttons are enabeld or not.
// * @see TfFocusEvent
Updated by JCasGen Fri Nov 22 17:01:30 CET 2024
XML source: /Users/bluefire/git/uima-uimaj-release/uimafit-examples/target/jcasgen/typesystem.xml
Deprecated.
replaced by
UimaTimerSimple timer class.
Creates an instance of UimaTimer.
Encode a span of time.
Updated by JCasGen Fri Nov 22 17:01:30 CET 2024
XML source: /Users/bluefire/git/uima-uimaj-release/uimafit-examples/target/jcasgen/typesystem.xml
Updated by JCasGen Fri Nov 22 17:01:19 CET 2024
XML source: /Users/bluefire/git/uima-uimaj-release/uimafit-core/target/jcasgen/typesystem.xml
This class provides convenience methods for creating tokens and sentences and add them to a
JCas.The Class TokenDrawingStrategy.
The JCas Class model corresponding to the Cas TOP type.
Deprecated.
Interface implemented by documents that can be transported (marshalled).
Provides utility method for converting between differing transportable types.
Interface for implementing factories which instantiate Transportable objects, as required by
VinciServer & VinciClient classes.
This class contains all frame related constants used by the Vinci transport layer.
The listener interface for receiving transportControl events.
The Class TransportControlPanel.
The Class TreeFocusHandler.
The interface describing types in the type system.
A typical use of this annotation might look something like:
This class may not be used.
A combo box which contains UIMA Types.
Component providing conversion service.
A description of a CAS Type.
Reference implementation of
TypeDescription.The content provider for the type grouped annotation outline.
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
The Class TypeImportSection.
The Class TypeInfo.
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.The Class TypePage.
A declaration of priorities between CAS Types.
Reference implementation of
TypePriorities.Create a new file resource in the provided container.
The "New" wizard page allows setting the container for the new file as well as the file name.
Deprecated.
Use
TypeSystemProvider instead.The Class TypePriorityImportSection.
Declares a relative priority between CAS types.
Reference implementation of
TypePriorityList.The Class TypeSection.
The Class TypesWithNameSpaces.
The Class TypesWithNameSpaces32.
The Class CasTypeProposal.
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.Deprecated.
Use
TypeSystemProvider instead.Load a type system file.
Type system implementation.
Type System Property Page to set the default type system location of a project.
Writable version of type system.
Create a new file resource in the provided container.
The "New" wizard page allows setting the container for the new file as well as the file name.
Allows the UIMA framework to discover globally available resources such as JCas classes, type
system descriptions, etc.
Type Utilities - all static, so class is abstract to prevent creation Used by Feature Path
Class comment for TypeTreeNode.java goes here.
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.
Updated by JCasGen Fri Nov 22 17:01:30 CET 2024
XML source: /Users/bluefire/git/uima-uimaj-release/uimafit-examples/target/jcasgen/typesystem.xml
Annotates UIMA acronyms and provides their expanded forms.
Run an arbitrary "main" method in a class, after adding classes to the classpath that are
specified as libraries, or as jar files
Uses arguments: -Dorg.apache.uima.jarpath=XXXX where XXXX is a string of file paths to
directories connected using File.pathSeparator; each directory's contained JARs will be added to
the class path.
UIMAClassLoader is used as extension ClassLoader for UIMA to load additional components like
annotators and resources.
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.
Decompiler
- for testing
- for locating customizations
Operation:
Make an instance, optionally setting
- class loader to use (may pass byte array instead)
- directory where to write output (may output to string instead)
- class loader to use when resolving symbols during decompile
call decompile
- argument
- class name (without .class or .java suffix, fully qualified) or
- byte array
- return value is a byte array output stream with UTF-8 encoded value
decompileToFile - writes decompiled output to a xxx.java file in output directory
Not thread safe
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.
JSR47 log formatter for UIMA JSR47Logger
Provides a log format which looks like: timestamp; threadID; sourceInfo; Message level; message
e.g. 7/12/04 2:15:35 PM - 10: org.apache.uima.util.TestClass.main(62): INFO: You are not logged
in!
The Class UimaLoggerProgressMonitor.
Updated by JCasGen Fri Nov 22 17:01:30 CET 2024
XML source: /Users/bluefire/git/uima-uimaj-release/uimafit-examples/target/jcasgen/typesystem.xml
Example annotator that iterates over Meeting annotations and annotates a meeting as a UimaMeeting
if a UIMA acronym occurs in close proximity to that meeting.
UIMAResultPrinter is a ResultPrinter extension for the JUnit framework.
This is the superclass for all unchecked exceptions in UIMA.
A specialization of the general
SaxVinciFrameBuilder utility for UIMA analysis
engine services.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
UIMAStreamHandler is used to handle output streams set during runtime.
Interface for a timer, used to collect performance statistics for UIMA components.
TODO: add javadoc here.
The
UIMAUtil class provides convenient methods for handling UIMA specific objects.The source for this class is located in
src/main/versionJava/org/apache/uima/impl/UimaVersion.java
It is processed at build time to create a java source, by substituting
values from the build into some fields.
Draws an line under an annotation.
Undo manager for text area.
A type of
ResourceSpecifier that locates an existing Resource service
by its URI.Reference implementation of
URISpecifier.Static methods supporting proper handling of URIs
Provides utility methods for Java string <==> UTF-8 conversion.
Shared code refactored from other spots to reduce duplication and improve maintainability
Exception class for package org.apache.uima.util.
Deprecated.
use Misc instead
The Class Utility.
Utility class for generating UUIDs.
Command-line utility for validating a descriptor.
Interface identifying validation checks that can be located via the Java Service Locator
mechanism.
Asserts related to
ValidationCheck implementations.Exception by a particular validation check.
Fail the current check.
Skip the current check.
Exception generated while validating a CAS.
Individual result from a CAS validation check.
Container for
CasValidationResults.Validate a (J)CAS.
The Class ValuePair.
The Class ValueSection.
Represents a table row in a two column table (of environment variables).
Represents a list of environment variable to be displayed in a table.
Handles the display and management of an environment variables table.
This annotator can be placed at/near the beginning of a pipeline to ensure that a particular view
is created before it is used further downstream.
This annotator will copy the text of one view to another view.
The Class Vinci.
A factory for creating AF objects.
Main class for a Vinci Analysis Engine service.
Reference implementation of
AnalysisEngineServiceAdapter for Vinci.The Class VinciAnalysisEngineServiceStub.
Main class for a Vinci Analysis Engine service that uses the binary CAS serialization, rather
than XCAS.
The Class VinciBinaryAnalysisEngineServiceStub.
Utilities for converting a VinciFrame to and from a CasData.
Reference implementation of
CasProcessorDeployer This
component enables the CPE to deploy Cas Processors running as a Vinci service.Class for conjuring a Vinci service.
This class can be used to globally affect various behaviors of Vinci clients and servers under
its control (for example, which VNS to contact).
This is the "default" document class for use with the Vinci client and servable classes.
Deprecated.
Use PrimitiveValueImpl instead.
Takes a Vinci frame and generates SAX events that correspond to the data in the frame.
Interface for implementing Vinci Services.
Adapter class for VinciServable, which provides a do-nothing cleanExit() method and a
TransportableFactory that returns a VinciFrame.
"Standard" service container for a VinciServable.
Runnable class used by VinciServer to concurrently service requests.
Vinci service information
The Class VinciTAEClient.
Vinci Proxy to remote Cas Processor vinci service.
VNS (Vinci Naming Service) provides the "directory" of all available Vinci services.
Deprecated class whose functions are now entirely provided by VinciContext.
Constants used in documents communicated to and from VNS ("Vinci Naming Service").
Special exception type thrown by VinciClient/VinciServer when VNS itself reports an error.
Connects to and querries a given VNS server for a list a services bound to a given name.
The Class Waiter.
Implements a combination of
WeakHashMap and IdentityHashMap.Widens the left side of the currently selected annotation by one.
Widens the right side of the currently selected annotation by one.
Represents a VNS Workspace.
The Class WorkUnit.
XCAS Deserializer.
Load an XCAS file.
Exception class for package org.apache.uima.cas.impl.
The Class XCASSaveHandler.
The Class XCASSaveTSHandler.
XCAS serializer.
A SAX ContentHandler that reads XCAS and creates a CasData.
A simple CAS consumer that generates XCAS (XML representation of the CAS) files in the
filesystem.
XMI CAS deserializer.
Load a CAS from an XMI file.
Save CAS to disk as XMI.
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.
A simple CAS consumer that writes the CAS to XMI format.
Data structure representing an XML attribute.
Deserializes a CAS from a standoff-XML format.
Serializes a CAS to inline XML format.
The Class XMLConfiguration.
Methods for converting to / from regular strings and XML(entity ref)-encoded strings, as well as
HTML-formatted strings.
A multi-sofa annotator that does XML detagging.
The Class XMLDocumentProvider.
The Class XMLDoubleClickStrategy.
The Class XMLEditor.
Data structure used to encapsulate the different pieces of information that make up the name of
an XML element - namely, the Namespace URI, the local name, and the qname (qualified name).
Data structure used to encapsulate an XML element name (including Namespace URI, local name, and
the qname) as well as its attributes and character content.
File filter to accept only xml files (.xml extension)
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.
The Class XMLPartitionScanner.
The Class XMLScanner.
Utility class that generates XML output from SAX events or DOM nodes.
The Class XMLTagScanner.
Class for parsing an XML document and representing it using any of the various jVinci-compatible
document models.
Class for parsing an XML document and converting directly to XTalk.
Class comment for XMLTypeSystemConsts.java goes here.
The
XMLUtil class provides miscellaneous XML utilities.Some utilities for working with XML.
The Class XMLWhitespaceDetector.
Class for converting XTalk streams into SAX events.
Implements XTalk marshalling of Frames.