|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
File
object is accepted by this filter.
File
object is accepted by this filter.
CasProcessorDeploymentParam
param
CasProcessorExecArg
instance to the list.
ProcessTrace
.
CASAdminException
object.
XCASParsingException
object.
ResultSpecification
.
ResultSpecification
.
CasConsumer
to this CPM.
CasProcessor
to this CPM's list of consumers.
CasProcessor
to this CPM's list of consumers.
CpeCasProcessor
to the end of
the list containing CPE CasProcessors.
CpeCasProcessor
at a specified
location in the list of CPE CasProcessors.
CasProcessorExecArg
argument to be supplied
when launching a program.
StdChannelListener
interface, to the list
of standard message channel listeners.
ProcessTrace
.
ProcessTrace
.
StringBuffer
object.
SimpleResourceFactory
by adding a new mapping between a
ResourceSpecifier
class and a Resource
class.
SimpleResourceFactory
by adding a new mapping between a
ResourceSpecifier
class and a Resource
class.
MessageRouter.StdChannelListener
interface
to the list of standard channel listeners.
TypePriorityList
.
TypePriorityList
and adds it to this object.
Properties
object.
ResultSpecification
for the language x-unspecified.
ResultSpecification
for the specified languages.
ResultSpecification
for the language x-unspecified.
ResultSpecification
for the specified languages.
ResultSpecification
for the language
x-unspecified.
ResultSpecification
for the specified
languages.
StdStreamListener
interface to the list
of standard stream listeners.
ProcessTrace
with this one.
AnalysisEngineDescription
contains all of the information needed to instantiate
and use an AnalysisEngine
.ProcessTrace
object.AnalysisEngineProcessException
may be thrown by an Analysis Engine's process
method, indicating that a failure occurred during processing.UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
uima.tcas.Annotation
.AnnotatorConfigurationException
is thrown by an annotator if the settings of
its configuration parameters are invalid.UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
AnnotatorContextException
is thrown by an AnnotatorContext
if it cannot
complete the invoked operation due to a failure in the underlying implementation.UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
AnnotatorInitializationException
may be thrown by an annotator's initialize
method, indicating that the annotator failed to successfully initialize itself.UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
AnnotatorProcessException
may be thrown by an annotator's process method,
indicating that a failure occurred during processing.UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
ASB
) is the component responsible for the details
of communicating with Analysis Engines that may potentially be distributed across different
physical machines.Style
to further define its
behavior.CollectionReader
interface.BaseCPM
as various events
occur.CLASSPATH
for the installed component, including CLASSPATH
for all separate delegate components that are utilized by the main installed component, if any.
lib
directory.
lib
directory.
PATH
for the installed component, including PATH
for all
separate delegate components that are utilized by the main installed component, if any.
PackageBrowser.buildComponentClassPath()
, but without all jars from the lib dir.
Properties
table that contains (name, value) pairs of environment
variables settings for a given installation descriptor object.
Properties
table of required environment variables for the installed
component, including environment variables for all separate delegate components that are
utilized by the main installed component, if any.
Capability
defines an operation that an Resource can carry out.CapabilityLanguageFlow
is a simple type of FlowConstraints
that
specifies the complete flow as a capabilityLanguage sequence.UIMAFramework.getDefaultPerformanceTuningProperties()
.
CASAdminException
CAS
interface.CasConsumerDescription
contains all of the information needed to instantiate
and use an CasConsumer
.CasDataCollectionReader
is used to iterate over the elements of a Collection.CasData
interface to access the CAS.CasData
interface
to access the CAS.XmlDetagger
for an example.XmlDetagger
for an example.CasData
.CollectionProcessingManager
as various events occur.CAS
interface.XmlDetagger
for an example.XmlDetagger
for an example.XmlDetagger
for an example.CAS
interface.CAS
implementation.CAS
instances.CasPool
.CasProcessorDeploymentParam
instances.CasProcessorExecArg
instances.ProcessTrace
by removing all events.
MetaDataObject
.
CollectionReader
, after which it may no longer be used.
InputStream
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
CollectionProcessingEngine
(CPE) processes a collection of artifacts (for text
analysis applications, this will be a collection of documents) and produces collection-level
results.CollectionProcessingManager
(CPM) manages the application of an
AnalysisEngine
to a collection of artifacts.CollectionReader
is used to iterate over the elements of a Collection.CollectionReaderDescription
contains all of the information needed to
instantiate and use an CollectionReader
.ResourceFactory
that produces resources by delegating to other Resource
Factories.aCAS
is an instanceof CAS
.
aCAS
is an instanceof JCas
.
ResourceSpecifier
that locates a resource file using its URL.Resource
that has configuration parameters that can be changed after the Resource has
been instantiated.ConfigurableResource
s.ConfigurationParameter
s.Resource
.ConfigurationParameter
s in a Resource.FSMatchConstraint
s for filtered iterators or other
use.ResultSpecification
contains the specified Feature for
the language x-unspecified.
ResultSpecification
contains the specified Feature for
the specified language.
ResultSpecification
contains the specified Type for the
language x-unspecified.
ResultSpecification
contains the specified Type for the
specified language.
file
to location dir
.
start
to end
to the
destination destArray
with destination offset destOffset
.
start
to end
to the
destination destArray
with destination offset destOffset
.
start
to end
to the
destination destArray
with destination offset destOffset
.
start
to end
to the
destination destArray
with destination offset destOffset
.
start
to end
to the
destination destArray
with destination offset destOffset
.
start
to end
to the
destination destArray
with destination offset destOffset
.
start
to end
to the
destination destArray
with destination offset destOffset
.
start
to end
to the
destination destArray
with destination offset destOffset
.
AllowedValue
.
AnalysisEngineDescription
.
AnalysisEngineMetaData
.
Capability
.
CapabilityLanguageFlow
.
CasConsumerDescription
.
CollectionReaderDescription
.
ConfigurationGroup
.
ConfigurationParameter
.
ConfigurationParameterDeclarations
.
ConfigurationParameterSettings
.
CustomResourceSpecifier
.
ExternalResourceBinding
.
ExternalResourceDependency
.
ExternalResourceDescription
.
FeatureDescription
.
FileLanguageResourceSpecifier
.
FileResourceSpecifier
.
FixedFlow
.
FlowControllerDeclaration
FlowControllerDescription
FsIndexCollection
.
FsIndexDescription
.
FsIndexKeyDescription
.
Import
mainComponentDir
.
JMSMessagingSpecifier
.
MailMessagingSpecifier
.
MQMessagingSpecifier
.
NameValuePair
.
OperationalProperties
Parameter
PearSpecifier
.
ProcessingResourceMetaData
.
ResourceManagerConfiguration
.
ResourceMetaData
.
ResultSpecification
for use with this
AnalysisEngine.
ResultSpecification
for use with this
AnalysisEngine.
ResultSpecification
.
SAXParser
class and sets standard features.
SimplePrecondition
.
CAS.createView(String)
instead.
JCas.createView(String)
instead.
SofaMapping
.
ResourceSpecifierFactory.createAnalysisEngineDescription()
should be used instead.
TypeDescription
.
TypeOrFeature
.
TypePriorities
.
TypePriorityList
.
TypeSystemDescription
.
URISpecifier
.
ResourceSpecifier
that specifically names the
Java class that should be created.DataResource
is a simple resource that provides access to data.FSIndexRepository.getAllIndexedFS(Type)
.
Properties
object.
BaseCollectionReader.close()
.
Resource
.
CasProcessor
in this CPM's list of CasProcessors.
DocumentAnnotation
type.ResourceCreationSpecifier
.
ResourceCreationSpecifier
.
CAS.reset()
.
CollectionProcessingManager
.f
.
i
.
FSIndexComparator
true
iff the
comparators have the same keys and comparators.
DataResource
is equal to another DataResource
.
Throwable
object.
ExternalResourceDependency
to an
ExternalResourceDescription
.ExternalResourceDependency
object describes an resources's requirements on an
external resource.ExternalResourceDescription
object describes a resource that is loaded in the
ResourceManager
and may be shared between components.FileFilter
object.
extractFilesFromPEARFile
method, which allows
sending messages to the OUT and ERR queues.
extractPEARFile
method, which allows sending
messages to the OUT and ERR queues.
Feature
to an equivalent FeatureDescription
.
FeaturePath
ResourceSpecifier
that locates a resource file using its URL, where the
URL depends on an ISO language identifier.ResourceSpecifier
that locates a resource file using its URL.FileUtil
class provides utility methods for working with general files.DirFileFilter
class allows to filter files based on specified directory path
and filename extension.DirFileFilter
object for specified directory and file extension.
ExtFileFilter
allows to filter file names based on the specified filename
extension.ExtFileFilter
class for a given filename extension.
ExtFileFilter
class for a given filename extension.
FileTimeComparator
class allows comparing 'last modified' time in 2 given
File
objects.NameFileFilter
class allows to filter files based on specified file name.NameFileFilter
object for a given file name.
finalize
method.
FixedFlow
is a simple type of FlowConstraints
that specifies the
complete flow as a fixed sequence.FlowConstraints
.
FlowConstraints
object represents constraints on the order of execution of
delegate Analysis Engines within an aggregate Analysis Engine.UimaContext
used by FlowController
components.FlowControllerDescription
contains all of the information needed to instantiate
and use a FlowController
.reset()
instead.
ListIterator
around an FSListIterator.
ListIterator
around an FSListIterator.
f
.
i
.
index
.
index
.
CasProcessorDeploymentParam
instance
identified by aParamName.
CasProcessorExecArg
instance located
with provided index.
CasProcessorDeploymentParam
CasProcessorExecArg
instances.
CasProcessorExecArg
arguments
CpeCollectionReader
instances
representing ALL defined CollectionReaders.
CpeCasProcessor
objects in processing
pipeline.
AnalysisEngine
that is assigned to this CPM.
AnalysisEngine
.
AnalysisEngineMetaData
.
getFeatures()
instead.
componentType
.
Attribute
s for this style.
MetaDataObject
.
Capabilities
.
CAS
), from which the AnalysisEngine obtains the
information to be processed, and to which the AnalysisEngine writes new annotation information.
CasConsumers
s assigned to this CPM.
CasManager.addMetaData(ProcessingResourceMetaData)
.
CasDataInitializer
.
CasProcessorExecArg
argument identified by
a given position in the list.
CasProcessors
s assigned to this CPM, in the order in which they will
be called by the CPM.
CasProcessors
s in this CPE, in the order in which they will be
executed.
CpeCheckpoint
object containing checkpoint
configuration ( checkpoint file, frequency of checkpoints )
Progress.getUnit()
.
ASB
.
ASB
.
CAS.setCurrentComponentInfo(ComponentInfo)
.
CasProcessorConfigurationParameterSettings
object containing overrides to parameter settings for this CAS Processor.
CasProcessorConfigurationParameterSettings
object containing overrides to parameter settings for this CollectionReader.
CasProcessorConfigurationParameterSettings
object containing overrides to parameter settings for this CasInitializer.
AnnotatorContext
to be used by this Annotator.
CpeCasProcessor
found at given position.
CpeCasProcessors
instance containing
processing pipeline spec.
CpeComponentDescriptor
instance associated with this Cas Processor.
UimaTimer
interface.
DataResource
object that can be used to access the data that is appropriate for
the given parameter values.
ResourceSpecifier
s
that indicate which delegate AnalysisEngines comprise the aggregate.
ResourceSpecifier
s
that indicate which delegate AnalysisEngines comprise the aggregate.
Import
or ResourceSpecifier
objects.
Hashtable
that contains (compId, InsD) pairs for all separate delegate
components specified in a given installation table.
CasProcessorDeploymentParams
object
containing deployment parameters used for launching CasProcessor.
CpeComponentDescriptor
containing
CollectionReader descriptor path.
CpeComponentDescriptor
containing
CasInitializer descriptor path.
getDirectSubtypes(Type)
instead.
CasProcessorErrorHandling
object containing
strategies to deal with errors that may occur during processing.
ProcessTraceEvent
s, in the order in which they were created.
CasProcessorExecutable
program used by the
CPE to launch CasProcessor.
ExternalResourceDependencies
and
the ExternalResourceDescription
objects defined in this
configuration.
ResourceCreationSpecifier
's dependencies on external resources.
Filter
that identifies which instances of the named CAS type are
governed by the index rule for this item.
FlowConstraints
object.
FlowConstraints
object.
FlowConstraints
object.
FlowControllerContainer
known to this ASB.
ResourceCreationSpecifier
's implementation.
ResourceManagerConfiguration.getImports()
instead. There may be many imports; this method only
returns the first.
IndexBuildItem
objects that comprise this index build specification.
IndexRule
that defines how annotations matching this build item should
be indexed.
InputStream
to the data.
ActionInfo
objects that have a given action name.
INSTALLATION_DESCRIPTOR_FILE
file, and creates the
InstallationDescriptor
(InsD) object.
InputStream
object (for use in Eclipse plug-in).
PackageSelector
input.
UIMAFramework
instance currently in use.
InstrumentationFacility
that this annotator can use to record
information about its performance.
InstrumentationFacility
that a component can use to record information
about its performance.
CAS.getView(String)
followed by CAS.getJCas()
.
ExternalResourceDependency
being bound.
Capability
and
returns the ISO language identifiers that the Resource supports.
Exception
object associated with a given XML descriptor
file.
Exception
object associated with a given XML descriptor
URL.
Locale
.
Locale
.
Logger
to which this annotator should send its log output.
Logger
to which log output will be sent.
Logger
used by the UIMA framework.
Logger
used by a particular Class, for example an
Annotator.
null
, if the main component was not specified.
null
, if the main component was not specified.
null
, if the main component was not specified.
null
, if the main component was not specified.
Resource
.
ResourceMetaData
to assign to the newly constructed ResourceCreationSpecifier
.
Capability
and
returns the MIME types that the Resource can take as input.
ConfigurationGroup
object.
CasData
from this CollectionReader
.
CasData
objects from this CasDataCollectionReader
.
XMLizable
object that has been built from the SAX events this object has
already received.
OperationalProperties
.
XmiSerializationSharedData.OotsElementData
objects, each of which describes an
incoming XMI element that did not correspond to a Type in the TypeSystem.
PackageSelector
input.
Class
.
TypePriorityList
s that define the priorities.
CasProcesor
.
CasProcesor
.
CasInitializer
.
ProcessingResourceMetaData
object
that contains the type system, indexes, and type priorities definitions
for the CAS.
ProcessTrace
object, which is used to record which AnalysisEngine components
have executed and information, such as timing, about that execution.
ProcessTrace
object for the Entity's processing.
CollectionReader
, and the total amount that remains (if that information
is available).
XMLInputSource.getURL()
instead.
AnalysisComponent.process(AbstractCas)
method.
FlowController.computeFlow(AbstractCas)
method.
ResourceManager.getResource(String)
or ResourceManager.getResource(String,String[])
.
UIMAFramework.produceXXX(ResourceSpecifier,...)
methods is called
with this resource specifier.
ResourceFactory
.
ResourceManager
used by this AnalysisEngine.
ResourceManager
that this Resource uses to locate other Resources.
ResourceCreationSpecifier.getExternalResourceDependencies()
.
ResourceSpecifier
that describes how to create the resource.
ResourceSpecifierFactory
.
ResourceSpecifiers
that comprise this aggregate
ResourceSpecifierList
.
CAS.getSofa()
if you truly need to access the SofaFS object.
JCas.getSofa()
if you truly need to access the SofaFS object.
CAS.getView(String)
, and the
framework will automatically do the necessary Sofa mappings.
CAS.getView(String)
, and the
framework will automatically do the necessary Sofa mappings.
ResourceSpecifier
used to determine which FlowController is used
by the AnalysisEngine.
Progress.getUnit()
.
TypeSystem
that was passed to the most recent call to
Annotator_ImplBase.typeSystemInit(TypeSystem)
.
Progress.getCompleted()
and Progress.getTotal()
numbers.
cas
parameter.
cas
parameter.
XMLParser
, which is used to parse
ResourceSpecifier
objects from their XML representations.
f
.
i
.
DataResource
.
CollectionReader
.
IndexBuildSpecification
.CAS
get indexed with a UIMA-compliant search engine.UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
Resource
from a ResourceSpecifier
.
Annotator_ImplBase.getContext()
method.
cpeDescription
Applications do not need to call this
method.
Resource
from a ResourceSpecifier
.
CasData
.
CAS
.
Hashtable
objects that are used to substitute $dlg_comp_id$root
macros in URL and absolute path expressions.
InstallationController
class allows installing PEAR files that contain UIMA
compliant components.InstallationController
class for a given component
and a given installation root directory.
InstallationController
class for a given component
and a given installation root directory.
InstallationController
class for a given component
and a given installation root directory.
InstallationController
class for a given component and a given installation root directory.
InstallationMonitor
interface defines methods required for notifying of
component installation status and location of the installed PEAR packages.PackageSelector
interface defines methods required for manually or
automatically selecting installed PEAR package root directories and PEAR package files.TestStatus
class encapsulates attributes related to the results of the
'serviceability' verification test.InstallationDescriptor
class encapsulates all elements and parameters included
in the XML Installation Descriptor file.ActionInfo
class defines 'installation action' attributes.ArgInfo
class defines attributes of a service command argument.ComponentInfo
class defines UIMA component attributes.ServiceInfo
class defines attributes of a 'service' component.InstallationDescriptorHandler
class allows parsing XML installation descriptor
files, creating instances of the InstallationDescriptor
class.InstallationProcessor
class implements operations specified in the
installation descriptor.InstallationProcessor
class, using given main
component root path and a table of installed delegate components.
InstallationController
object
as the requestor.
InstallationTester
application allows performing simple verification of the
installed UIMA compliant component by using standard UIMA framework interface.InstallationTester
class, identifies a specified
component using UIMA API.
InstrumentationFacility
interface defines a standard way for UIMA components
to be instrumented for performance evaluation.InternationalizedException
class adds internationalization
support to the standard functionality provided by
java.lang.Exception
.InternationalizedException
with a null
message.
InternationalizedException
with the specified
cause and a null message.
InternationalizedException
with the specified
message.
InternationalizedException
with the specified
message and cause.
InternationalizedRuntimeException
class adds internationalization support to
the standard functionality provided by java.lang.RuntimeException
.InternationalizedRuntimeException
with a null message.
InternationalizedRuntimeException
with the specified cause and a
null message.
InternationalizedRuntimeException
with the specified message.
InternationalizedRuntimeException
with the specified message and
cause.
XMLParser
to indicate that an XML document is invalid or does not specify a
valid object of the desired class.UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
true
, if a given text file contains only ASCII characters, otherwise
returns false
.
true
, if a given input stream contains only ASCII characters, otherwise
returns false
.
CollectionReader
.
FeatureStructure.getIndexed()
instead
MetaDataObject
allows the values of its attributes to be
modified.
Marker
existed before the mark was set, and has been modified.
CAS
from which it was obtained
is reset.
UIMAFramework.getDefaultPerformanceTuningProperties()
.
JCas
interface.JCas
interface.CAS
interface.JCas
instances.JCasPool.JCasPool(int, AnalysisEngine)
instead.
f
.
i
.
ResourceManager
after this object has been
instantiated.
LocalInstallationAgent
allows localizing files of UIMA compliant components
within the single PEAR structure, and verifying localized component's files using UIMA framework
API.LocalInstallationAgent
class, using a given main
component root directory.
Logger
is a component used to log messages.f
.
i
.
CAS.getView(String)
, and the
framework will automatically do the necessary Sofa mappings.
CAS.getView(String)
, and the
framework will automatically do the necessary Sofa mappings.
CAS
that is used to query when FSs were
created or modified with respect to the marker.MessageRouter
class facilitates intra-process message routing.MessageRouter
class.
StdChannelListener
interface declares methods that should be implemented by
each standard message channel listener.Resource
.fs
.
CAS.NAME_DEFAULT_SOFA
, and the value has
changed. In general, user code should not need to refer to this name.
NameClassPair
with the specified name and class.
MetaDataObject
that stores a name (String) and value (Object).newCas
is an instanceof CAS
.
newCas
is an instanceof JCas
.
CollectionProcessingManager
instance.
CollectionProcessingManager
instance.
ConfigurationManager
used by this implementation.
ResourceManager
used by this implementation.
ResourceManagerPearWrapper
used by this implementation.
AnalysisEngine.newCAS()
but wraps the new CAS objects with the Java-object-based
JCas
interface.
Logger
, which can be passed for example to the
AnalysisEngine.setLogger(Logger)
method in order to have separate Analysis Engine
instances used separate loggers.
SaxDeserializer
object, which implements the SAX
ContentHandler
interface and can be used to deserialize an
XMLizable
object from the events sent from a SAX parser.
SaxDeserializer
.
UimaTimer
, which is used to collect performance
statistics for UIMA components.
UimaContext
.
org.apache.uima.pear.tools
package provides applications
and tools that allow installing PEAR packages containing UIMA-compliant
components, verifying serviceability of installed components by using
UIMA API and browsing PEAR packages.org.apache.uima.pear.util
package provides utilities that
facilitate common operations with general files, strings and XML files,
as well as simple process message routing and other useful operations.Resources
and ResourceSpecifiers
.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.PackageCreatorException
with the specified message.
PackageCreatorException
with the specified message.
PackageCreatorException
with the specified message and cause.
PackageCreatorException
with the specified message and cause.
PackageInstaller
class is the main user API for installing
PEAR packages.PackageInstallerException
with the specified message.
PackageInstallerException
with the specified message.
PackageInstallerException
with the specified message and cause.
PackageInstallerException
with the specified message and cause.
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.PackageDirFilter
class allows filtering directories.PackageFileFilter
class allows filtering PEAR package files.ConfigurationManager
object.
Resource.PARAM_CONFIG_PARAM_SETTINGS
ConfigurationParameterSettings
object that holds
configuration settings that will be used to configure this Resource, overriding any
conflicting settings specified in this Resource's Descriptor.
Settings
object that holds the external override settings.
AnalysisEngine.process(CAS)
that will be supported.
Properties
object that
holds settings that tune the performance of the framework.
RelativePathResolver
that this DataResource should use to resolve relative resource
URLs.
Resource.PARAM_RESOURCE_MANAGER
ResourceManager
that this Resource should use to locate and access other Resources.
AnalysisEngine.PARAM_NUM_SIMULTANEOUS_REQUESTS
) to become available to
serve a AnalysisEngine.process(CAS)
request.
UimaContext
that
is to be used by this Resource to access its external resource and configuration parameters.
XMLParser.parseAnalysisEngineDescription(XMLInputSource)
should be used
instead.
XMLParser.parseAnalysisEngineDescription(XMLInputSource,ParsingOptions)
should be used instead.
ResourceSpecifier
that locate an installed pear Resource
.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.Properties
object as XML elements to a given
PrintWriter
, maintaining a given indentation level.
Properties
object as XML elements to a given
PrintWriter
, maintaining a specified tag order and a given indentation level.
Properties
object as XML elements to a given
PrintWriter
, maintaining a specified tag order and a given indentation level.
InstallationDescriptor
object in XML format to a given
PrintWriter
.
ps
.
System.err
.
pw
PrintWriter
, maintaining a given indentation level.
PrintWriter
, maintaining a given indentation level.
PrintWriter
, maintaining a given indentation level.
PrintWriter
, maintaining a given indentation level.
PrintWriter
, maintaining a given indentation level.
PrintWriter
, maintaining a given indentation level.
PrintWriter
, maintaining a given indentation level.
PrintWriter
, maintaining a given
indentation level.
PrintWriter
, maintaining a given
indentation level.
PrintStream
.
PrintWriter
, maintaining a given indentation
level.
PrintWriter
,
maintaining a given indentation level.
AnalysisEngine.process(CAS)
but uses the Java-object-based JCas
interface instead
of the general CAS
interface.
AnalysisEngine.process(CAS,ResultSpecification)
but uses the Java-object-based
JCas
interface instead of the general CAS
interface.
AnalysisEngine.process(CAS, ResultSpecification, ProcessTrace)
but uses the
Java-object-based JCas
interface instead of the general CAS
interface.
UIMAFramework.getDefaultPerformanceTuningProperties()
.
Resource
- that is, one
that reads or writes to the CAS
.ProcessTrace
object keeps a record of events that have occurred and information,
such as timing, about those events.ProcessUtil
class encapsulates utilities that help in dealing with
Process
objects.ProcessUtil.Runner
class allows collecting, printing and distributing
console output (stdout and stderr) of the specified Process
without blocking the
caller.Process
object and assigns default process
name.
Process
object and a given process name.
Process
object, a given process name, and a
given boolean
flag that enables/disables console printing.
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.AnalysisEngine
instance from a ResourceSpecifier
.
AnalysisEngine
instance from a ResourceSpecifier
.
AnalysisEngine
instance from a ResourceSpecifier
.
AnalysisEngine
instance from a ResourceSpecifier
.
CasConsumer
instance from a ResourceSpecifier
.
CasConsumer
instance from a ResourceSpecifier
.
CasConsumer
instance from a ResourceSpecifier
.
XmlDetagger
for an example.
CasInitializer
instance from a ResourceSpecifier
.
CasInitializer
instance from a ResourceSpecifier
.
CollectionProcessingEngine
instance from a cpeDescription
.
CollectionProcessingEngine
instance from a cpeDescription
.
CollectionProcessingEngine
instance from a cpeDescription
.
CollectionReader
instance from a ResourceSpecifier
.
CollectionReader
instance from a ResourceSpecifier
.
CollectionReader
instance from a ResourceSpecifier
.
Resource
instance from a ResourceSpecifier
.
Resource
instance from a ResourceSpecifier
.
Resource
instance of a specified class from a
ResourceSpecifier
.
Resource
instance of a specified class from a
ResourceSpecifier
.
Resource
instance from a ResourceSpecifier
.
UIMAFramework.produceAnalysisEngine(ResourceSpecifier)
should be used
instead.
UIMAFramework.produceAnalysisEngine(ResourceSpecifier,Map)
should be used
instead.
UIMAFramework.produceAnalysisEngine(ResourceSpecifier,ResourceManager,Map)
should be used instead.
UIMAFramework.produceAnalysisEngine(ResourceSpecifier,int,int)
should be
used instead.
Annotator_ImplBase.destroy()
followed by
Annotator_ImplBase.initialize(AnnotatorContext)
and Annotator_ImplBase.typeSystemInit(TypeSystem)
.
CasOwner.releaseCas(AbstractCas)
.
CasProcessorDeploymentParam
CasProcessorExecArg
instance found in the
list in a given position.
CpeCasProcessor
objects from processing
pipeline.
CasConsumer
from this CPM.
CpeCollectionReaderCasInitializer
from
CollectionReader
CasProcessor
to this CPM's list of consumers.
StdChannelListener
object from the list of standard channel
listeners.
CpeCasProcessor
object from processing
pipeline from a given position.
StdStreamListener
object from the list of standard stream
listeners.
MessageRouter.StdChannelListener
object from the list of
standard channel listeners.
TypePriorityList
.
ResultSpecification
.
fsIndexes
list.
fsIndexes
list.
fsIndexes
list.
externalResources
and
externalResourceBindings
lists.
externalResources
and
externalResourceBindings
lists.
externalResources
and
externalResourceBindings
lists.
TypePriorityList
objects directly onto this TypePriorities object's
priorityLists
.
TypePriorityList
objects directly onto this TypePriorities object's
priorityLists
.
TypePriorityList
objects directly onto this TypePriorities object's
priorityLists
.
types
list.
types
list.
types
list.
Resource
is the general term for all UIMA components that can be acquired and used
by an application (or by other resources).Resource
s.URISpecifier.getResourceType()
representing an Analysis Engine.
URISpecifier.getResourceType()
representing a CAS Consumer.
UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
Resource
's configuration parameters could not be set.UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
ResourceCreationSpecifier
is the supertype of
AnalysisEngineDescription
,
CasConsumerDescription
,
CollectionReaderDescription
, and
CasInitializerDescription
.ResourceFactory
is used to acquire instances of Resource
s.Resource.initialize(ResourceSpecifier,Map)
to indicate that a failure has
occurred during initialization.UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
ResourceManager
holds a collection of Resource
objects, each registered under a specified key.ExternalResourceDependencies
.ResourceManagerPearWrapper
is a
special Resource Manager, sharing all its fields with its parent,
except for the class path and data path fields.Resource
.Resource
has encountered a problem during its processing.UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
ResourceServiceSpecifier
is a type of ResourceSpecifier
that
contains information that can be used to locate an existing resource available as a service.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.ResourceSpecifier
instances and
instances of other objects needed to compose ResourceSpecifier
s.ResourceSpecifier
that is an aggregate of other
ResourceSpecifier
s.UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
ResultSpecification
is a set of desired outputs from a Analysis Engine or
Annotator.Runnable.run()
method, collecting and printing standard output
or standard error messages during the process execution.
InstallationDescriptor
object in a given XML file.
InstallationDescriptor
object to a given XML file.
XMLizable
object from SAX events.searchStrategy
property indicating that if there is no value
declared in a group, look in the default group
.
searchStrategy
property that is useful when ISO language and
country codes are used as configuration group names.
searchStrategy
property indicating that there is no fallback.
Resource
and a
particular client.AnalysisEngine
that is assigned to this CPM.
Attribute
s for this style.
MetaDataObject
.
Capabilities
.
UimaContext.mapToSofaID()
.
CasProcessorConfigurationParameterSettings
object containing overrides to parameter settings for this CAS Processor.
CasProcessorConfigurationParameterSettings
object containing overrides to parameter settings for this CollectionReader.
CasProcessorConfigurationParameterSettings
object containing overrides to parameter settings for this CasInitializer.
CpeComponentDescriptor
instance associated with this Cas Processor.
CasProcessorExecutable
executable program used
by the CPE to launch CasProcessor.
ExternalResourceDependencies
and
the ExternalResourceDescription
objects defined in this
configuration.
ResourceCreationSpecifier
's dependencies on external resources.
Filter
that identifies which instances of the named CAS type are
governed by the index rule for this item.
ResourceCreationSpecifier
executes.
ResourceCreationSpecifier
's implementation.
ResourceManagerConfiguration.setImports(Import[])
instead.
IndexBuildItem
objects that comprise this index build specification.
FeatureStructure.setIndexed(int[])
instead
IndexRule
that defines how annotations matching this build item should
be indexed.
Exception
object as the installation error
message.
InstallationMonitor
interface.
ExternalResourceDependency
being bound.
boolean
flag.
standard
, service
or network
.
ResourceMetaData
object associated with this Resource
.
ResourceCreationSpecifier
.
ConfigurationGroup
object.
OperationalProperties
.
PackageSelector
interface.
Precondition
s of this Capability
.
TypePriorityList
s that define the priorities.
UIMAFramework.produceXXX(ResourceSpecifier,...)
methods is called
with this resource specifier.
ResourceCreationSpecifier.getExternalResourceDependencies()
.
ResourceSpecifier
that describes how to create the resource.
Session
.
ResourceSpecifier
used to determine which FlowController is used by the
AnalysisEngine.
Settings
object holds the properties used for external parameter overrides.Exception
object as the verification error
message.
SharedResourceObject
interface must be implemented by all classes that provide
access to resource data.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
.ResourceFactory
.UIMAFramework.getDefaultPerformanceTuningProperties()
.
JCasImpl.createView(String)
to create a view, which will
also create the Sofa for that view.
CAS.getView(String)
.ResourceBundle
containing the standard UIMA
Exception messages.
ResourceBundle
containing the standard UIMA
Exception messages.
CollectionProcessingManager
as various events occur.StringUtil
class provides utility methods for working with strings.Properties
object values.
AnalysisEngineDescription
should be used instead. This interface
no longer defines any additional methods beyond those in AnalysisEngineDescription.CasToInlineXml
instead.MessageRouter
thread.
AnalysisEngine
should be used instead. This interface no longer
defines any additional methods beyond those in AnalysisEngine.String::replaceAll(String regex, String replacement)
method.
ProcessTrace
.
ContentHandler
.
ContentHandler
.
ContentHandler
.
annot
as root node.
Type
to an equivalent TypeDescription
.
TypeSystem
to an equivalent TypeSystemDescription
.
Annotator_ImplBase.getTypeSystem()
method, and also so that it can be passed back to the
Annotator_ImplBase.typeSystemInit(TypeSystem)
method by the default implementation of
Annotator_ImplBase.reconfigure()
.
UIMARuntimeException.STANDARD_MESSAGE_CATALOG
.
UIMARuntimeException.STANDARD_MESSAGE_CATALOG
.
UIMARuntimeException.STANDARD_MESSAGE_CATALOG
.
UIMARuntimeException.STANDARD_MESSAGE_CATALOG
.
UIMARuntimeException.STANDARD_MESSAGE_CATALOG
.
UIMARuntimeException.STANDARD_MESSAGE_CATALOG
.
JTafRuntimeException
with the specified nested exception.
UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMAException.STANDARD_MESSAGE_CATALOG
.
UIMARuntimeException.STANDARD_MESSAGE_CATALOG
.
UIMARuntimeException.STANDARD_MESSAGE_CATALOG
.
UIMAUtil
class provides convenient methods for handling UIMA specific objects.ResourceSpecifier
that locates an existing Resource
service by its URI.ResourceCreationSpecifier
is valid.
ResourceCreationSpecifier
is valid.
TestStatus
object with the test results.
InstallationTester
application.
XCASParsingException
XmiCasSerializer.XmiCasSerializer(TypeSystem, Map)
instead. The UimaContext reference
is never used by this implementation.
XmiCasSerializer.XmiCasSerializer(TypeSystem)
instead. The UimaContext reference is
never used by this implementation.
XmiCasSerializer
and the XmiCasDeserializer
.XMLParser
to read XML documents for parsing.XMLInputSource
from a descriptor file.
XMLInputSource
from a descriptor file.
XMLInputSource
from a URL.
XMLParser
parses XML documents and generates UIMA components represented by
the XML.XMLUtil
class provides miscellaneous XML utilities.Logger
used by this implementation.
Logger
of
the specified source class.
ResourceFactory
used by this implementation, which must implement
CompositeResourceFactory
.
ResourceSpecifierFactory
used by this implementation.
XMLParser
used by this implementation.
CollectionProcessingManager
.
ConfigurationManager
used by this implementation.
ResourceManager
used by this implementation.
ResourceManagerPearWrapper
used by this implementation.
Logger
instance.
UimaTimer
instance.
UimaContextAdmin
used by this implementation.
CollectionProcessingEngine
instance from a cpeDescription
.
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |