See: Description
Interface | Description |
---|---|
FSComparator |
Interface to compare two feature structures.
|
FSGenerator<T extends FeatureStructure> | |
FSImplComparator |
Interface to compare two feature structures, represented by their addresses.
|
FSIndexImpl |
Class comment for FSIndexImpl.java goes here.
|
FSRefIterator | |
LowLevelCAS |
Defines the low-level CAS APIs.
|
LowLevelIndex |
Low-level FS index object.
|
LowLevelIndexRepository |
Low-level index repository access.
|
LowLevelIterator |
Low-level FS iterator.
|
LowLevelTypeSystem |
Low-level version of the type system APIs.
|
StringMap |
Appears to be unused, 1-2015 schor
|
XMLTypeSystemConsts |
Class comment for XMLTypeSystemConsts.java goes here.
|
Class | Description |
---|---|
AnnotationBaseImpl |
Class comment for AnnotationImpl.java goes here.
|
AnnotationImpl |
Class comment for AnnotationImpl.java goes here.
|
AnnotationIndexImpl<T extends AnnotationFS> |
Implementation of annotation indexes.
|
AnnotationTreeImpl<T extends AnnotationFS> |
Implementation of annotation tree.
|
AnnotationTreeNodeImpl<T extends AnnotationFS> |
TODO: Create type comment for AnnotationTreeNodeImpl.
|
ArrayFSGenerator | |
ArrayFSImpl |
Implementation of the
ArrayFS interface. |
BinaryCasSerDes4 |
User callable serialization and deserialization of the CAS in a compressed Binary Format
This serializes/deserializes the state of the CAS, assuming that the type
information remains constant.
|
BinaryCasSerDes6 |
User callable serialization and deserialization of the CAS in a compressed Binary Format
This serializes/deserializes the state of the CAS.
|
BinaryCasSerDes6.ReuseInfo |
Info reused for
1) multiple serializations of same cas to multiple targets (a speedup), or
2) for delta cas serialization, where it represents the fsStartIndex info before any mods
were done which could change that info, or
3) for deserializing with a delta cas, where it represents the fsStartIndex info at the time
the CAS was serialized out..
|
BooleanArrayFSImpl |
Implementation of the
BooleanArrayFS interface. |
BooleanConstraint |
Implementation of boolean match constraint.
|
ByteArrayFSImpl |
Implementation of the
ByteArrayFS interface. |
CASCompleteSerializer |
This is a small object which contains
- CASMgrSerializer instance - a Java serializable form of the type system + index definitions
- CASSerializer instance - a Java serializable form of the CAS including lists of which FSs are indexed
|
CASImpl |
Implements the CAS interfaces.
|
CASMgrSerializer |
Container for serialized CAS typing information.
|
CasSeqAddrMaps |
Manage the conversion of Items (FSrefs) to relative sequential index number, and back
Manage the difference in two type systems
both size of the FSs and
handling excluded types
During serialization, these maps are constructed before serialization.
|
CASSerializer |
This object has 2 purposes.
|
CasSerializerSupport |
CAS serializer support for XMI and JSON formats.
|
CasSerializerSupport.CasSerializerSupportSerialize |
Methods used to serialize items
Separate implementations for JSON and Xmi
|
CasTypeSystemMapper |
This class gets initialized with two type systems, and then provides
resources to map type and feature codes between them.
|
CommonArrayFSImpl |
Common part of array impl for those arrays of primitives which exist in the main heap.
|
CommonAuxArrayFSImpl |
Common part of array impl for those arrays of primitives which use auxilliary heaps.
|
CommonSerDes |
Common de/serialization
|
CommonSerDes.Header |
HEADERS
Serialization versioning
There are 1 or 2 words used for versioning.
|
CommonSerDes.Reading |
byte swapping reads of integer forms
|
ConstraintFactoryImpl |
Implementation of the ConstraintFactory interface.
|
DebugFSLogicalStructure | |
DebugFSLogicalStructure.IndexInfo |
Class holding information about an FSIndex
Includes the "label" of the index, and a ref to the CAS this index contents are in.
|
DebugFSLogicalStructure.ViewInfo |
Class holding info about a View/Sofa.
|
DebugNameValuePair | |
DefaultAnnotationComparator |
Default implementation to compare two annotations.
|
DefaultFSAnnotationComparator |
Default implementation to compare two annotations.
|
DoubleArrayFSImpl |
Implementation of the
DoubleArrayFS interface. |
FeatureImpl |
The implementation of features in the type system.
|
FeatureStructureImpl |
Feature structure implementation.
|
FeatureStructureImplC |
Feature structure implementation.
|
FeatureValuePathImpl |
Contains CAS Type and Feature objects to represent a feature path of the form
feature1/.../featureN.
|
FloatArrayFSImpl |
Implementation of the
IntArrayFS interface. |
FSBagIndex<T extends FeatureStructure> |
Used for UIMA FS Bag Indexes
Uses IntVector or PositiveIntSet to hold values of FSs
|
FSBooleanConstraintImpl |
See interface for documentation.
|
FSClassRegistry | |
FSIndexComparatorImpl | |
FSIndexFlat<T extends FeatureStructure> |
Flattened indexes built as a speed-up alternative for Sorted indexes.
|
FSIndexFlat.FSIteratorFlat<TI extends FeatureStructure> | |
FSIndexRepositoryImpl |
There is one instance of this class per CAS View.
|
FSIntArrayIndex<T extends FeatureStructure> |
Used for sorted indexes only
Uses IntVector (sorted) as the index (of FSs)
|
FSIntIteratorImplBase<T extends FeatureStructure> |
Base class for int Iterators over indexes.
|
FSIteratorImplBase<T extends FeatureStructure> |
Base class for FSIterator implementations.
|
FSIteratorWrapper<T extends FeatureStructure> | |
FSIteratorWrapperDoubleCheck<T extends FeatureStructure> |
Only used for debugging
Takes two iterators, and compares them; returns the 1st, throws error if unequal
|
FSLeafIndexImpl<T extends FeatureStructure> |
The common (among all index kinds - set, sorted, bag) info for an index
Subtypes define the actual index repository (integers indexing the CAS) for each kind.
|
FSRBTSetIndex<T extends FeatureStructure> |
Used for UIMA FS Set Indexes
Uses CompIntArrayRBT red black tree to hold items
Same as FSRBTIndex, but duplicates are not inserted.
|
Heap |
A heap for CAS.
|
IntArrayFSImpl |
Implementation of the
IntArrayFS interface. |
IntIterator4set<T extends FeatureStructure> | |
LinearTypeOrderBuilderImpl |
Implementation of the
LinearTypeOrderBuilder interface. |
ListUtils |
Utilities for dealing with CAS List types.
|
LLUnambiguousIteratorImpl | |
LongArrayFSImpl |
Implementation of the
ArrayFS interface. |
MarkerImpl |
A MarkerImpl holds a high-water "mark" in the CAS,
for all views.
|
OutOfTypeSystemData |
This class is used by the XCASDeserializer to store feature structures that do not fit into the
type system of the CAS it is deserializing into.
|
Serialization |
This class has no fields or instance methods, but instead
has only static methods.
|
ShortArrayFSImpl |
Implementation of the
ArrayFS interface. |
SlotKinds |
NOTE: adding or altering slots breaks backward compatability and
the ability do deserialize previously serialized things
This definition shared with BinaryCasSerDes4
Define all the slot kinds.
|
SofaFSImpl |
Implementation of the
SofaFS interface. |
StringArrayFSImpl |
Implementation of the
ArrayFS interface. |
StringHeapDeserializationHelper |
Support for legacy string heap format.
|
StringTypeImpl |
Class comment for StringTypeImpl.java goes here.
|
Subiterator<T extends AnnotationFS> |
Subiterator implementation.
|
TypeImpl |
The implementation of types in the type system.
|
TypeNameSpaceImpl | |
TypeSystem2Xml |
Dumps a Type System object to XML.
|
TypeSystemImpl |
Type system implementation.
|
TypeSystemUtils |
Class comment for TypeSystemUtils.java goes here.
|
XCASDeserializer |
XCAS Deserializer.
|
XCASSerializer |
XCAS serializer.
|
XmiCasDeserializer |
XMI CAS deserializer.
|
XmiCasSerializer |
CAS serializer for XMI format; writes a CAS in the XML Metadata Interchange (XMI) format.
|
XmiSerializationSharedData |
A container for data that is shared between the
XmiCasSerializer and the XmiCasDeserializer . |
XmiSerializationSharedData.XmiArrayElement |
Data structure holding the index and the xmi:id of an array or list element that
is a reference to an out-of-typesystem FS.
|
Enum | Description |
---|---|
AllowPreexistingFS | |
BinaryCasSerDes4.Compression | |
BinaryCasSerDes4.CompressLevel |
Compression alternatives
|
BinaryCasSerDes4.CompressStrat | |
BinaryCasSerDes4.SlotKind |
Define all the slot kinds.
|
BinaryCasSerDes6.CompressLevel |
Compression alternatives
|
BinaryCasSerDes6.CompressStrat | |
CasState |
states the CAS can be in
|
FSIndexRepositoryImpl.IteratorExtraFunction |
Kinds of extra functions for iterators
|
SlotKinds.SlotKind | |
TypeSystemUtils.PathValid |
Exception | Description |
---|---|
AnnotationImplException |
Exception class for package org.apache.uima.cas.impl.
|
LowLevelException |
Exception class for package org.apache.uima.cas.impl.
|
XCASParsingException |
Exception class for package org.apache.uima.cas.impl.
|
Implementation and Low-Level API for the CAS Interfaces.
Internal APIs. Use these APIs at your own risk. APIs in this package are subject to change without notice, even in minor releases. Use of this package is not supported. If you think you have found a bug in this package, please try to reproduce it with the officially supported APIs before reporting it.
NOTE: This documentation is plain HTML, generated from a WYSIWIG editor "tinymce". The way to work on this: after setting up a small web page with the tinymce (running from a local file), use the Tools - source code to cut/paste between this file's source and that editor.
It is possible to run UIMA without creating Java cover objects for FSs. However, for convenience, many of the APIs return Java objects that provide, in turn, various APIs for accessing features, updating in indexes, etc.
There are two kinds of Java cover objects:
Both of these inherit from the FeatureStructure
Interface. Use of the JCas is optional; if the JCas cover classes are available (in the class path), they are used.
Indexes are defined for a pipeline, and are kept as part of the general CAS definition.
Each CAS View has its own instantiation of the defined indexes (there's one definition for all views), and as a result, a particular FS may be added-to-indexes and indexed in some views, and not in others.
There are 3 kinds of indexes: Sorted, Set, and Bag. The basic object type for an index is FSLeafIndexImpl
. This has 3 subtypes, one for each of the index types:
The leaf index is just for one type (and doesn't include entries for any subtypes).
Indexes are connected to specific index definitions; these definitions include a type which is the top type for elements of this index. The index definition logically includes that type and all of its subtypes.
An additional data struction, the IndexIteratorCachePair, is associated with each index definition. It holds references to the subtype FSLeafIndexImpls for all subtypes of an index; this list is created lazily, only when an iterator is created over this index at a particular type level (which can be the type the index was defined for, or any subtype). This lazy aspect is important, because UIMA is often used in cases where there's a giant type system, with lots of subtypes, only a few of which are used in a particular pipeline instance.
There are two tasks that indexes accomplish:
There are two main kinds of iterators:
There are two main kinds of iterators over UIMA indexes:
The basic int iterators are implemented with instances of the classes:
FSIntIteratorImplBase<T extends FeatureStructure>
- the common superclass
IntIterator4bag<T extends FeatureStructure>
IntIterator4set<T extends FeatureStructure>
IntIterator4sorted<T extends FeatureStructure>
All of these implement an iterator over the corresponding FSLeafIndexImpl for one type.
The class PointerIterator in FSIndexRepositoryImpl is an int iterator that combines iterators for type and their subtypes, into one aggregated iterator, taking into account the comparator sorting order among the various iterators. So, for instance, if you do a moveTo operation, it does a move to on all the individual iterators, and then figures out which of those is the left-most one in the comparator ordering.
PointerIteratorUnordered is a variant that also combines iterators for a type and its subtypes, but doesn't try to keep these in order. It is designed to be used when iterating through all instances of a type and its subtypes, in an arbitrary order, such as what the method getAllIndexedFS(type)
does.
SnapshotPointerIterator is a variant which creates a snapshot when the iterator is created, and then (ignoring any subsequent index updates) iterates over that. This iterator won't throw ConcurrentModificationException
.
The basic impls of IntIterator4bag/set/sorted are created by calls to pointerIterator; this method is implemented in each of the IntIterator4bag/set/sorted classes.
The 2nd argument passed is a ref to this FSIndexRepositoryImpl's int[] used to detect concurrent modification exception. If null is passed, then no testing for this is done. This kind of call happens with the use of the refIterator() methods, which are used internally when it is known that the iteration will not be modifying the indexes in any way.
Iterators which return Java cover object:
Plain FSIterators are created from index instances via the iterator()
method; corresponding int iterators are created from low-level indexes via ll_iterator()
. This method picks the appropriate underlying iterator based on
There are several overlapping interfaces (probably due to historical reasons) for these iterators.
First, interfaces for iterators returning ints:
Next, interfaces for iterators returning Java cover objects:
Copyright © 2006–2021 The Apache Software Foundation. All rights reserved.