| Package | Description | 
|---|---|
| org.apache.uima.cas | Common Analysis System(CAS) Interfaces | 
| org.apache.uima.cas.admin | |
| org.apache.uima.cas.impl | Implementation and Low-Level API for the CAS Interfaces. | 
| org.apache.uima.cas.text | Text Common Annotation System (TCAS) Interfaces. | 
| org.apache.uima.examples | |
| org.apache.uima.jcas | Interfaces for accessing the JCAS. | 
| org.apache.uima.jcas.cas | JCAS model for built-in CAS types | 
| org.apache.uima.jcas.impl | Provides the classes that support the Java Cas Model (JCM). | 
| org.apache.uima.jcas.tcas | |
| org.apache.uima.util | Utility classes and interfaces used by UIMA components. | 
| Modifier and Type | Interface and Description | 
|---|---|
| interface  | ArrayFS<E extends FeatureStructure>Feature structure array interface. | 
| interface  | FSIndex<T extends FeatureStructure>Feature structure index access interface. | 
| interface  | FSIterator<T extends FeatureStructure>Iterator over feature structures. | 
| interface  | SelectFSs<T extends FeatureStructure>Collection of builder style methods to specify selection of FSs from indexes Documentation is in
 a chapter in the UIMA Version 3 User's Guide. | 
| Modifier and Type | Interface and Description | 
|---|---|
| interface  | AnnotationBaseFSAnnotation Base API. | 
| interface  | ArrayFS<E extends FeatureStructure>Feature structure array interface. | 
| interface  | BooleanArrayFSBoolean array interface. | 
| interface  | ByteArrayFSByte array interface. | 
| interface  | CommonArrayFS<E>Common parts of the Array interfaces. | 
| interface  | DoubleArrayFSDouble array interface. | 
| interface  | FloatArrayFSInterface for CAS float arrays. | 
| interface  | IntArrayFSInterface for CAS int arrays. | 
| interface  | LongArrayFSLong array interface. | 
| interface  | ShortArrayFSShort array interface. | 
| interface  | SofaFSInterface for "Subject of Analysis" (Sofa) feature structures. | 
| interface  | StringArrayFSString array interface. | 
| Modifier and Type | Method and Description | 
|---|---|
| <T extends FeatureStructure> | FSIndexRepository. addFS(T fs)Add a feature structure to all appropriate indexes in the repository. | 
| <T extends FeatureStructure> | ArrayFS. copyFromArray(T[] src,
             int srcOffset,
             int destOffset,
             int length)Copy the contents of an external array into this array. | 
| <U extends FeatureStructure> | ArrayFS. copyToArray(int srcOffset,
           U[] dest,
           int destOffset,
           int length)Copy the contents of the array from  starttoendto the destinationdestArraywith destination offsetdestOffset. | 
| <T extends FeatureStructure> | CAS. createFilteredIterator(FSIterator<T> it,
                      FSMatchConstraint cons)Create an iterator over structures satisfying a given constraint. | 
| <T extends FeatureStructure> | CAS. createFS(Type type)Create a new FeatureStructure. | 
| default <T extends FeatureStructure> | CAS. emptyFSArray() | 
| default <T extends FeatureStructure> | CAS. emptyFSArray(Type type) | 
| <T extends FeatureStructure> | CAS. fs2listIterator(FSIterator<T> it)Wrap a standard Java  ListIteratoraround an FSListIterator. | 
| <U extends FeatureStructure> | ArrayFS. get(int i)Get the i-th feature structure from the array. | 
| default <T extends FeatureStructure> | FSIndexRepository. getAllIndexedFS(Class<T> clazz)Gets an FSIterator over all indexed (in this view) FeatureStructures of the specified Type (and
 any of its subtypes). | 
| <T extends FeatureStructure> | FSIndexRepository. getAllIndexedFS(Type aType)Gets an iterator over all indexed (in this View) FeatureStructures of the specified Type (and
 any of its subtypes). | 
| <T extends FeatureStructure> | FSIndexRepository. getIndex(String label)Retrieve an index according to a label. | 
| <T extends FeatureStructure> | FSIndexRepository. getIndex(String label,
        Type type)Retrieve an index according to a label and a type. | 
| <T extends FeatureStructure> | FSIndexRepository. getIndexes()Get all indexes in this repository. | 
| <T extends FeatureStructure> | FSIndexRepository. ll_getIndexes()Get all indexes in this repository as low level indexes | 
| <T extends FeatureStructure> | FSIndexRepository. removeFS(T fs)Remove a feature structure from all indexes in the repository. | 
| static <U extends FeatureStructure> | SelectFSs. select(FSIndex<U> index)Use this static method to capture the generic argument | 
| Modifier and Type | Method and Description | 
|---|---|
| T[] | SelectFSs. asArray(Class<? super T> clazz) | 
| FeatureStructure | FeatureStructure. getFeatureValue(Feature feat)Get a feature value. | 
| FeatureStructure | FeaturePath. getFSValue(FeatureStructure fs)Returns the FeatureStructure of a FeatureStructure valued feature path. | 
| FeatureStructure | SofaFS. getLocalFSData()Get the Local Subject of Analysis returns null if not previously set. | 
| FeatureStructure | CAS. getSofaDataArray()Get the Sofa data array. | 
| FeatureStructure[] | ArrayFS. toArray()Creates a new array the this array is copied to. | 
| Modifier and Type | Method and Description | 
|---|---|
| void | CAS. addFsToIndexes(FeatureStructure fs)Add a feature structure to all appropriate indexes in the repository associated with this CAS
 View. | 
| int | FSIndex. compare(FeatureStructure fs1,
       FeatureStructure fs2)Compare two feature structures according to the ordering relation of the index. | 
| boolean | FSIndex. contains(FeatureStructure fs)
 Check if the index contains an element equal to the given feature structure according to the
 comparators defined for this index. | 
| <T extends FeatureStructure> | ArrayFS. copyFromArray(T[] src,
             int srcOffset,
             int destOffset,
             int length)Copy the contents of an external array into this array. | 
| <U extends FeatureStructure> | ArrayFS. copyToArray(int srcOffset,
           U[] dest,
           int destOffset,
           int length)Copy the contents of the array from  starttoendto the destinationdestArraywith destination offsetdestOffset. | 
| T | FSIndex. find(FeatureStructure fs)Find an entry in the index "equal to" the given feature structure according to the comparators
 specified for this index. | 
| T | SelectFSs. get(FeatureStructure fs)Positions to the fs using moveTo(fs). | 
| T | SelectFSs. get(FeatureStructure fs,
   int offset)Positions to the fs using moveTo(fs), followed by a shifted(offset). | 
| Boolean | FeaturePath. getBooleanValue(FeatureStructure fs)Returns the Boolean value of a boolean valued feature path. | 
| Byte | FeaturePath. getByteValue(FeatureStructure fs)Returns the Byte value of a byte valued feature path. | 
| Double | FeaturePath. getDoubleValue(FeatureStructure fs)Returns the Double value of a double valued feature path. | 
| Float | FeaturePath. getFloatValue(FeatureStructure fs)Returns the Float value of a float valued feature path. | 
| FeatureStructure | FeaturePath. getFSValue(FeatureStructure fs)Returns the FeatureStructure of a FeatureStructure valued feature path. | 
| Integer | FeaturePath. getIntValue(FeatureStructure fs)Returns the Integer value of an integer valued feature path. | 
| Long | FeaturePath. getLongValue(FeatureStructure fs)Returns the Long value of a long valued feature path. | 
| Short | FeaturePath. getShortValue(FeatureStructure fs)Returns the Short value of a short valued feature path. | 
| String | FeaturePath. getStringValue(FeatureStructure fs)Returns the String value of a string valued feature path. | 
| TypeClass | FeaturePath. getTypClass(FeatureStructure fs)Deprecated. 
 use getTypeClass (spelling fix) | 
| Type | FeaturePath. getType(FeatureStructure fs)Returns the type of the feature path. | 
| TypeClass | FeaturePath. getTypeClass(FeatureStructure fs)Returns the type class of the feature path. | 
| String | FeaturePath. getValueAsString(FeatureStructure fs)Returns the feature path value as string for the given FeatureStructure. | 
| boolean | Marker. isModified(FeatureStructure fs)Test if a FeatureStructure in a CAS represented by this  Markerexisted before the
 mark was set, and has been modified. | 
| boolean | Marker. isNew(FeatureStructure fs) | 
| default FSIterator<T> | FSIndex. iterator(FeatureStructure fs)Return an iterator over the index. | 
| boolean | FSMatchConstraint. match(FeatureStructure fs)Match against feature structures. | 
| void | FSIterator. moveTo(FeatureStructure fs)Move the iterator to the first Feature Structure that matches the  fs. | 
| void | CAS. removeFsFromIndexes(FeatureStructure fs)Remove a feature structure from all indexes in the repository associated with this CAS View. | 
| void | FeatureStructure. setFeatureValue(Feature feat,
               FeatureStructure fs)Set a feature value to another FS. | 
| void | SofaFS. setLocalSofaData(FeatureStructure aFS)Set the Local Subject of Analysis to be a predefined ArrayFS. | 
| void | CAS. setSofaDataArray(FeatureStructure array,
                String mime)Set the Sofa data as an ArrayFS. | 
| T | SelectFSs. single(FeatureStructure fs)Positions to the fs using moveTo(fs). | 
| T | SelectFSs. single(FeatureStructure fs,
      int offset)Positions to the fs using moveTo(fs), followed by a shifted(offset). | 
| T | SelectFSs. singleOrNull(FeatureStructure fs)Positions to the fs using moveTo(fs). | 
| T | SelectFSs. singleOrNull(FeatureStructure fs,
            int offset)Positions to the fs using moveTo(fs), followed by a shifted(offset). | 
| SelectFSs<T> | SelectFSs. startAt(FeatureStructure fs)Starting Position specification - For ordered sources, specifies which FS to start at. | 
| SelectFSs<T> | SelectFSs. startAt(FeatureStructure fs,
       int shift)Starting Position specification - A combination of startAt followed by a shift
 
 Requires an ordered index not necessarily AnnotationIndex, not necessarily sorted This versions
 avoids a runtime cast check. | 
| Modifier and Type | Method and Description | 
|---|---|
| int | LinearTypeOrder. compare(FeatureStructure fs1,
       FeatureStructure fs2)Compare two Feature Structure's types | 
| Modifier and Type | Interface and Description | 
|---|---|
| interface  | CopyOnWriteIndexPart<T extends FeatureStructure>common APIs supporting the copy on write aspect of index parts | 
| interface  | FSGenerator<T extends FeatureStructure>Deprecated. 
 unused in v3, only present to avoid compile errors in unused v2 classes | 
| class  | FsIndex_bag<T extends FeatureStructure>Used for UIMA FS Bag Indexes Uses ObjHashSet to hold instances of FeatureStructures | 
| class  | FsIndex_flat<T extends FeatureStructure>Common part of flattened indexes, used for both snapshot iterators and flattened sorted indexes
 
 built from passed in instance of FsIndex_iicp | 
| class  | FsIndex_set_sorted<T extends FeatureStructure>Common index impl for set and sorted indexes. | 
| class  | FsIndex_singletype<T extends FeatureStructure>The common (among all index kinds - set, sorted, bag) info for an index over 1 type (excluding
 subtypes)
 
 SubClasses FsIndex_bag, FsIndex_flat, FsIndex_set_sorted, define the actual index repository for
 each kind. | 
| class  | FsIndex_snapshot<T extends FeatureStructure>Implementation of light-weight wrapper of normal indexes, which support special kinds of
 iterators base on the setting of IteratorExtraFunction | 
| class  | FsIterator_multiple_indexes<T extends FeatureStructure>Common code for both
   aggregation of indexes (e.g. | 
| class  | FsIterator_singletype<T extends FeatureStructure> | 
| class  | FsIterator_subtypes_ordered<T extends FeatureStructure>Performs an ordered iteration among a set of iterators, each one corresponding to the type or
 subtype of the uppermost type. | 
| class  | FsIterator_subtypes_snapshot<T extends FeatureStructure> | 
| class  | FSIteratorImplBase<T extends FeatureStructure>Version 2 compatibility only, not used internally in version 3 Base class for FSIterator
 implementations. | 
| class  | LLUnambiguousIteratorImpl<T extends FeatureStructure>Implements a low level ambiguous or unambiguous iterator over some type T which doesn't need to
 be a subtype of Annotation. | 
| interface  | LowLevelIndex<T extends FeatureStructure>Low-level FS index object. | 
| interface  | LowLevelIterator<T extends FeatureStructure>Low-level FS iterator. | 
| class  | LowLevelIterator_empty<T extends FeatureStructure>An empty Low-level FS iterator | 
| class  | SelectFSs_impl<T extends FeatureStructure>Collection of builder style methods to specify selection of FSs from indexes
 shift handled in this routine
 Comment codes:
   AI = implies AnnotationIndex
 
 Iterator varieties and impl
 
   bounded?  type      order not unambig? strict? skipEq    
             Priority? Needed? 
     no
   coveredBy
   covering
   sameas
 
   for not-bounded, 
     - ignore strict and skipEq
       -- except: preceding implies skipping annotations whose end > positioning begin
     - order-not-needed only applies if iicp size > 1
     - unambig ==> use Subiterator
         -- subiterator wraps: according to typePriority and order-not-needed
     - no Type Priority - need to pass in as arg to fsIterator_multiple_indexes
        == if no type priority, need to prevent rattling off the == type while compare is equal
        == affects both FsIterator_aggregation_common and FsIterator_subtypes_ordered
   for 3 other boundings:
     - use subiterator, pass in strict and skipeq
 
   finish this javadoc comment edit
   T extends FeatureStructure, not TOP, because of ref from FSIndex 
 which uses FeatureStructure for backwards compatibility | 
| Modifier and Type | Interface and Description | 
|---|---|
| interface  | AnnotationBaseImplDeprecated. 
 use AnnotationBase instead | 
| interface  | AnnotationImplDeprecated. 
 use Annotation instead | 
| interface  | BooleanArrayFSImplDeprecated. 
 use BooleanArray instead | 
| interface  | ByteArrayFSImplDeprecated. 
 use ByteArray instead | 
| interface  | CommonArrayFSImplDeprecated.   | 
| interface  | DoubleArrayFSImplDeprecated. 
 use DoubleArray instead | 
| interface  | FeatureStructureImplDeprecated. 
 use TOP instead | 
| interface  | FloatArrayFSImplDeprecated. 
 use FloatArray instead | 
| interface  | IntArrayFSImplDeprecated. 
 use IntegerArray instead | 
| interface  | LongArrayFSImplDeprecated. 
 use LongArray instead | 
| interface  | ShortArrayFSImplDeprecated. 
 use ShortArray instead | 
| interface  | SofaFSImplDeprecated. 
 use Sofa instead | 
| interface  | StringArrayFSImplDeprecated. 
 use StringArray instead | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | FeatureStructureImplCFeature 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 | 
| Modifier and Type | Field and Description | 
|---|---|
| static LowLevelIterator<FeatureStructure> | LowLevelIterator. FS_ITERATOR_LOW_LEVEL_EMPTYan empty iterator | 
| FSIndex<FeatureStructure> | DebugFSLogicalStructure.IndexInfo. fsIndex | 
| Modifier and Type | Method and Description | 
|---|---|
| <T extends FeatureStructure> | FSIndexRepositoryImpl. addFS(T fs) | 
| <T extends FeatureStructure> | CASImpl. createFilteredIterator(FSIterator<T> it,
                      FSMatchConstraint cons) | 
| <T extends FeatureStructure> | CASImpl. createFS(Type type)Create the appropriate Feature Structure Java instance - from whatever the generator for this
 type specifies. | 
| <T extends FeatureStructure> | FSIndexRepositoryImpl. createIndexNoQuestionsAsked(FSIndexComparator comp,
                           String label,
                           int indexType)This is public only until the xml specifier format supports specifying index kinds (set, bag
 etc.). | 
| <T extends FeatureStructure> | CASImpl. emptyFSArray() | 
| <T extends FeatureStructure> | CASImpl. emptyFSArray(Type type) | 
| <T extends FeatureStructure> | CASImpl. fs2listIterator(FSIterator<T> it) | 
| <T extends FeatureStructure> | FSIndexRepositoryImpl. getAllIndexedFS(Type type) | 
| <T extends FeatureStructure> | FSIndexRepositoryImpl. getIndex(String label) | 
| <T extends FeatureStructure> | FSIndexRepositoryImpl. getIndex(String label,
        Type type) | 
| <T extends FeatureStructure> | FSIndexRepositoryImpl. getIndexBySpec(int typeCode,
              int indexingStrategy,
              FSIndexComparatorImpl comp)Get the FsIndex_iicp for a given typeCode, indexingStrategy, and comparator (type ignored) | 
| <T extends FeatureStructure> | FSIndexRepositoryImpl. getLabels(FSIndexComparator comp)Get the labels for a specific comparator. | 
| <T extends FeatureStructure> | FSIndexRepositoryImpl. ll_getAllIndexedFS(Type type) | 
| <T extends FeatureStructure> | LowLevelIndexRepository. ll_getIndex(String indexName)Get an index by its name. | 
| <T extends FeatureStructure> | FSIndexRepositoryImpl. ll_getIndex(String indexName) | 
| <T extends FeatureStructure> | LowLevelIndexRepository. ll_getIndex(String indexName,
           int typeCode)Get an index by a name and type. | 
| <T extends FeatureStructure> | FSIndexRepositoryImpl. ll_getIndex(String indexName,
           int typeCode) | 
| Modifier and Type | Method and Description | 
|---|---|
| T[] | SelectFSs_impl. asArray(Class<? super T> clazz) | 
| static FeatureStructure[] | DebugFSLogicalStructure. getDebugLogicalStructure_SubAnnotations(AnnotationFS fs) | 
| FeatureStructure | CASImpl. getRefArrayValue(FSArray array,
                int i) | 
| FeatureStructure | CASImpl. getSofaDataArray() | 
| Modifier and Type | Method and Description | 
|---|---|
| void | FeatureStructureImplC. _setFeatureValueNcWj(int adjOffset,
                    FeatureStructure v)Nc - no check, Wj = with journaling if needed | 
| void | CASImpl. addFsToIndexes(FeatureStructure fs) | 
| protected void | FsIndex_singletype. assertFsTypeMatchesIndexType(FeatureStructure fs,
                            String operation) | 
| void | CASImpl. commitFS(FeatureStructure fs)Deprecated.  | 
| int | FSComparator. compare(FeatureStructure fs1,
       FeatureStructure fs2)Compare two FSs. | 
| int | FsIndex_bag. compare(FeatureStructure fs1,
       FeatureStructure fs2)Override the super impl which uses comparators. | 
| int | FsIndex_flat. compare(FeatureStructure fs1,
       FeatureStructure fs2) | 
| int | FsIndex_snapshot. compare(FeatureStructure o1,
       FeatureStructure o2) | 
| abstract int | FsIndex_singletype. compare(FeatureStructure o1,
       FeatureStructure o2)This is required to avoid compilation error (but not in Eclipse) due to ambiguous interface
 inheritance from both FeatureStructure and Comparator | 
| int | FsIndex_set_sorted. compare(FeatureStructure o1,
       FeatureStructure o2) | 
| int | LinearTypeOrderBuilderImpl.TotalTypeOrder. compare(FeatureStructure fs1,
       FeatureStructure fs2) | 
| int | FsIterator_subtypes_snapshot. compare(FeatureStructure fs1,
       FeatureStructure fs2) | 
| boolean | FsIndex_bag. contains(FeatureStructure fs) | 
| boolean | FsIndex_flat. contains(FeatureStructure fs) | 
| boolean | FsIndex_snapshot. contains(FeatureStructure fs) | 
| boolean | FsIndex_set_sorted. contains(FeatureStructure templateKey) | 
| int | CopyOnWriteIndexPart. copyToArray(T[] target,
           int startingIndexInTarget)Copy FS refs to target from this index part | 
| T | FsIndex_bag. find(FeatureStructure fs)This is a silly method for bag indexes in V3, since dupl add to indexes is not allowed. | 
| T | FsIndex_flat. find(FeatureStructure fs) | 
| T | FsIndex_snapshot. find(FeatureStructure fs) | 
| T | FsIndex_set_sorted. find(FeatureStructure templateKey)find any arbitrary matching FS
   two comparators:  cp, and cpx (has extra id comparing)
 
 First find an FS in the index that's the smallest that's GE to key using cpx
   - if none found, then all of the entries in the index are LessThan the key (using cpx); 
                    but one might be equal using cp
     -- if one or more would be equal using cp, it would be because 
           the only reason for the inequality using cpx was due to the _id miscompare. | 
| static Object | DebugFSLogicalStructure. floatListToArray(FeatureStructure fs) | 
| static Object | DebugFSLogicalStructure. fsListToArray(FeatureStructure fs) | 
| T | SelectFSs_impl. get(FeatureStructure fs) | 
| T | SelectFSs_impl. get(FeatureStructure fs,
   int offset) | 
| static Object | DebugFSLogicalStructure. getDebugLogicalStructure_FeatureStructure(FeatureStructure fs) | 
| static Object | DebugFSLogicalStructure. integerListToArray(FeatureStructure fs) | 
| boolean | CASImpl. isInCAS(FeatureStructure fs) | 
| boolean | MarkerImpl. isModified(FeatureStructure fs) | 
| boolean | MarkerImpl. isNew(FeatureStructure fs) | 
| LowLevelIterator<T> | FsIndex_singletype. iterator(FeatureStructure initialPositionFs) | 
| int | CASImpl. ll_getFSRef(FeatureStructure fs)Safety - any time the low level API to a FS is requested, hold on to that FS until CAS reset to
 mimic how v2 works. | 
| int | LowLevelCAS. ll_getFSRef(FeatureStructure fsImpl)Get the low-level reference from an existing FS object. | 
| boolean | BooleanConstraint. match(FeatureStructure fs) | 
| default void | LowLevelIterator. moveTo(FeatureStructure fs) | 
| void | LowLevelIterator_empty. moveToNoReinit(FeatureStructure fs) | 
| void | Subiterator. moveToNoReinit(FeatureStructure fs) | 
| void | FsIterator_subtypes_ordered. moveToNoReinit(FeatureStructure fs) | 
| void | LowLevelIterator. moveToNoReinit(FeatureStructure fs)Internal use same as moveTo(fs), but won't reset to use current contents of index if index has
 changed | 
| void | FsIterator_subtypes_snapshot. moveToNoReinit(FeatureStructure fs) | 
| void | FSIndexRepositoryImpl. removeFS(FeatureStructure fs) | 
| void | CASImpl. removeFsFromIndexes(FeatureStructure fs) | 
| void | FeatureStructureImplC. setFeatureValue(Feature feat,
               FeatureStructure v) | 
| void | CASImpl. setId2FSsMaybeUnconditionally(FeatureStructure... fss)Test case use | 
| void | CASImpl. setSofaDataArray(FeatureStructure array,
                String mime) | 
| T | SelectFSs_impl. single(FeatureStructure fs) | 
| T | SelectFSs_impl. single(FeatureStructure fs,
      int offset) | 
| T | SelectFSs_impl. singleOrNull(FeatureStructure fs) | 
| T | SelectFSs_impl. singleOrNull(FeatureStructure fs,
            int offset) | 
| SelectFSs_impl<T> | SelectFSs_impl. startAt(FeatureStructure fs) | 
| SelectFSs_impl<T> | SelectFSs_impl. startAt(FeatureStructure fs,
       int offset) | 
| static Object | DebugFSLogicalStructure. stringListToArray(FeatureStructure fs) | 
| Constructor and Description | 
|---|
| FsIterator_subtypes_snapshot(T[] snapshot,
                            LowLevelIndex<T> index,
                            boolean is_unordered,
                            Comparator<TOP> comparatorMaybeNoTypeWithoutId)Alternative source iterator, 1st arg is different (not an "index", just an array) - altSources
 are unordered, and NoType is ignored - also supports backwards iterators, these are ordered
 (Maybe fix this in the future - this is not necessarily required) | 
| SelectFSs_impl(FeatureStructure[] source,
              CAS cas) | 
| Modifier and Type | Interface and Description | 
|---|---|
| interface  | AnnotationFSInterface for Annotation Feature Structures. | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | SourceDocumentInformationStores detailed information about the original source document from which the current CAS was initialized. | 
| Modifier and Type | Method and Description | 
|---|---|
| <T extends FeatureStructure> | JCas. createFilteredIterator(FSIterator<T> it,
                      FSMatchConstraint cons)Create an iterator over structures satisfying a given constraint. | 
| <T extends FeatureStructure> | JCas. fs2listIterator(FSIterator<T> it)Wrap a standard Java  ListIteratoraround an FSListIterator. | 
| Modifier and Type | Method and Description | 
|---|---|
| FeatureStructure | JCas. getSofaDataArray()Get the Sofa data array. | 
| Modifier and Type | Method and Description | 
|---|---|
| void | JCas. addFsToIndexes(FeatureStructure fs)Add a feature structure to all appropriate indexes in the repository associated with this CAS
 View. | 
| default void | JCas. putJfsFromCaddr(int casAddr,
               FeatureStructure fs)Deprecated.  | 
| void | JCas. removeFsFromIndexes(FeatureStructure fs)Remove a feature structure from all indexes in the repository associated with this CAS View. | 
| void | JCas. setSofaDataArray(FeatureStructure array,
                String mime)Set the Sofa data as an ArrayFS. | 
| Modifier and Type | Method and Description | 
|---|---|
| Type | JCas. getCasType(Class<? extends FeatureStructure> clazz)Return the UIMA Type object corresponding to this JCas's JCas cover class (Note: different
 JCas's, with different type systems, may share the same cover class impl) | 
| Modifier and Type | Interface and Description | 
|---|---|
| interface  | ArrayFSImpl<E extends FeatureStructure>Deprecated. 
 use FSArray instead | 
| class  | FSArray<T extends FeatureStructure>Java Class model for Cas FSArray type extends FeatureStructure for backwards compatibility when
 using FSArray with no typing. | 
| interface  | SelectViaCopyToArray<T extends FeatureStructure>Classes which provide a toArrayForSelect() method that returns a FeatureStructure[] can implement
 this to enable the class to be used as a "select" source T extends FeatureStructure because
 FSArray with no typing needs to default to FeatureStructure for backwards compatibility | 
| Modifier and Type | Interface and Description | 
|---|---|
| interface  | ArrayFSImpl<E extends FeatureStructure>Deprecated. 
 use FSArray instead | 
| interface  | CommonListThis class is the super class of list nodes (both empty and non empty) | 
| interface  | CommonPrimitiveArray<T>This interface is implemented by arrays of non-FeatureStructure components
 
 boolean, byte, short, int, long, float, double, String, JavaObject
 
 Internal Use Only. | 
| interface  | EmptyLista marker interface for empty lists | 
| interface  | NonEmptyLista marker interface for nonempty lists | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | AnnotationBasethe JCas class model for the CAS type uima.cas.AnnotationBase. | 
| class  | BooleanArrayJCas class model for BooleanArray | 
| class  | ByteArrayJCas class model for ByteArray | 
| class  | DoubleArrayJCas class model for DoubleArray | 
| class  | EmptyFloatList | 
| class  | EmptyFSList<T extends TOP> | 
| class  | EmptyIntegerList | 
| class  | EmptyStringList | 
| class  | FloatArrayJava Cas model for Cas FloatArray. | 
| class  | FloatList | 
| class  | FSArray<T extends FeatureStructure>Java Class model for Cas FSArray type extends FeatureStructure for backwards compatibility when
 using FSArray with no typing. | 
| class  | FSArrayList<T extends TOP>An ArrayList type containing Feature Structures, for UIMA
   Has all the methods of List
       Implements the select(...) APIs 
    | 
| class  | FSHashSet<T extends TOP>a hash set of Feature Structures
 Is Pear aware - stores non-pear versions but may return pear version in pear contexts
 Updated by JCasGen Fri Jan 20 11:55:59 EST 2017
 XML source: C:/au/svnCheckouts/branches/uimaj/v3-alpha/uimaj-types/src/main/descriptors/java_object_type_descriptors.xml | 
| class  | FSLinkedHashSet<T extends TOP>a hash set of Feature Structures
 Is Pear aware - stores non-pear versions but may return pear version in pear contexts
 Updated by JCasGen Fri Jan 20 11:55:59 EST 2017
 XML source: C:/au/svnCheckouts/branches/uimaj/v3-alpha/uimaj-types/src/main/descriptors/java_object_type_descriptors.xml | 
| class  | FSList<T extends TOP>T extends TOP, v2 already mandated TOP for set/get | 
| class  | Int2FS<T extends TOP>A map from ints to Feature Structures
 
 Is Pear aware - stores non-pear versions but may return pear version in pear contexts | 
| class  | IntegerArrayThe Java Class model corresponding to the Cas IntegerArray_JCasImpl type. | 
| class  | IntegerArrayListAn ArrayList type containing ints, for UIMA
   - implements a subset of the List API, Iterable<Integer>, IntListIterator. | 
| class  | IntegerList | 
| class  | LongArrayJCas class model for LongArray | 
| class  | NonEmptyFloatList | 
| class  | NonEmptyFSList<T extends TOP> | 
| class  | NonEmptyIntegerList | 
| class  | NonEmptyStringList | 
| class  | ShortArrayJCas class model for ShortArray | 
| class  | Sofa | 
| class  | StringArrayJCas class model for StringArray | 
| class  | StringList | 
| class  | TOPThe JCas Class model corresponding to the Cas TOP type. | 
| Modifier and Type | Method and Description | 
|---|---|
| <E extends FeatureStructure> | FSArrayList. copyFromArray(E[] src,
             int srcPos,
             int destPos,
             int length)Copy from array. | 
| <U extends FeatureStructure> | FSArray. copyFromArray(U[] src,
             int srcPos,
             int destPos,
             int length) | 
| <E extends FeatureStructure> | FSArrayList. copyToArray(int srcPos,
           E[] dest,
           int destPos,
           int length)Copy to array. | 
| <U extends FeatureStructure> | FSArray. copyToArray(int srcPos,
           U[] dest,
           int destPos,
           int length) | 
| static <U extends TOP,E extends FeatureStructure> | FSList. create(JCas jcas,
      E[] a)Create an FSList from an existing array of Feature Structures | 
| static <E extends TOP,F extends FeatureStructure> | FSArrayList. create(JCas jcas,
      F[] a)Convenience - create a FSArrayList from an existing Array. | 
| static <U extends FeatureStructure> | FSArray. create(JCas jcas,
      FeatureStructure[] a)Convenience - create a FSArray from an existing FeatureStructure[] | 
| <U extends FeatureStructure> | FSArray. get(int i)return the indexed value from the corresponding Cas FSArray as a Java Model object. | 
| Modifier and Type | Method and Description | 
|---|---|
| FeatureStructure[] | FSArray. _toArrayForSelect() | 
| FeatureStructure[] | SelectViaCopyToArray. _toArrayForSelect() | 
| FeatureStructure[] | FSArrayList. _toArrayForSelect() | 
| FeatureStructure | Sofa. getLocalFSData() | 
| FeatureStructure[] | FSArray. toArray() | 
| Modifier and Type | Method and Description | 
|---|---|
| <E extends FeatureStructure> | FSArrayList. copyFromArray(E[] src,
             int srcPos,
             int destPos,
             int length)Copy from array. | 
| <U extends FeatureStructure> | FSArray. copyFromArray(U[] src,
             int srcPos,
             int destPos,
             int length) | 
| <E extends FeatureStructure> | FSArrayList. copyToArray(int srcPos,
           E[] dest,
           int destPos,
           int length)Copy to array. | 
| <U extends FeatureStructure> | FSArray. copyToArray(int srcPos,
           U[] dest,
           int destPos,
           int length) | 
| static <U extends TOP,E extends FeatureStructure> | FSList. create(JCas jcas,
      E[] a)Create an FSList from an existing array of Feature Structures | 
| static <E extends TOP,F extends FeatureStructure> | FSArrayList. create(JCas jcas,
      F[] a)Convenience - create a FSArrayList from an existing Array. | 
| static <U extends FeatureStructure> | FSArray. create(JCas jcas,
      FeatureStructure[] a)Convenience - create a FSArray from an existing FeatureStructure[] | 
| void | AnnotationBase. setFeatureValue(Feature feat,
               FeatureStructure v) | 
| void | Sofa. setFeatureValue(Feature feat,
               FeatureStructure fs) | 
| void | Sofa. setLocalSofaData(FeatureStructure aFS) | 
| void | Sofa. setLocalSofaData(FeatureStructure aFS,
                String mimeType) | 
| Modifier and Type | Method and Description | 
|---|---|
| <T extends FeatureStructure> | JCasImpl. createFilteredIterator(FSIterator<T> it,
                      FSMatchConstraint constraint) | 
| <T extends FeatureStructure> | JCasImpl. fs2listIterator(FSIterator<T> it) | 
| Modifier and Type | Method and Description | 
|---|---|
| FeatureStructure | JCasImpl. getSofaDataArray() | 
| Modifier and Type | Method and Description | 
|---|---|
| void | JCasImpl. addFsToIndexes(FeatureStructure instance) | 
| void | JCasImpl. removeFsFromIndexes(FeatureStructure instance) | 
| void | JCasImpl. setSofaDataArray(FeatureStructure array,
                String mime) | 
| Modifier and Type | Method and Description | 
|---|---|
| Type | JCasImpl. getCasType(Class<? extends FeatureStructure> clazz)Return the UIMA Type object corresponding to this JCas's JCas cover class (Note: different
 JCas's, with different type systems, may share the same cover class impl) | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | Annotationthe JCas class model for the CAS type uima.cas.Annotation. | 
| class  | DocumentAnnotationThe JCas class definition for the CAS  DocumentAnnotationtype. | 
| Modifier and Type | Method and Description | 
|---|---|
| <T extends FeatureStructure> | CasCopier. copyFs(T aFS)Copy 1 feature structure from the originalSrcCas to a new Cas. | 
| Modifier and Type | Method and Description | 
|---|---|
| static FeatureStructure | ConsumerCasUtils. getTcasFS(CAS aCasView,
         String aTypeS) | 
| Modifier and Type | Method and Description | 
|---|---|
| boolean | CasCopier. alreadyCopied(FeatureStructure aFS)Note: if lenient is in effect, this method will return false for FSs which are not copied
 because the target doesn't have that type. | 
Copyright © 2006–2022 The Apache Software Foundation. All rights reserved.