org.apache.uima.cas.impl

## Class FsIndex_singletype<T extends FeatureStructure>

- java.lang.Object
- - java.util.AbstractCollection<T>
  - - org.apache.uima.cas.impl.FsIndex_singletype<T>

- Type Parameters:
    `T` - the Java cover class type for this index, passed along to (wrapped) iterators producing Java cover classes
  All Implemented Interfaces:
    Iterable<T>, Collection<T>, Comparator<FeatureStructure>, FSIndex<T>, LowLevelIndex<T>
  Direct Known Subclasses:
    FsIndex_bag, FsIndex_flat, FsIndex_set_sorted

      public abstract class FsIndex_singletype<T extends FeatureStructure>
      extends AbstractCollection<T>
      implements Comparator<FeatureStructure>, LowLevelIndex<T>

  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.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected CASImpl` | `casImpl`
    `protected FSIndexComparatorImpl` | `comparatorForIndexSpecs` comparator for an index, passed in as an argument to the constructor
    `protected Comparator<TOP>` | `comparatorNoTypeWithID` comparator (with id) (ignoring typeorder) - used within one type
    `protected Comparator<TOP>` | `comparatorNoTypeWithoutID` comparator (without id) (ignoring typeorder) - used within one type - used for iterator operations where the type is requested to be ignored
    `protected Comparator<TOP>` | `comparatorWithID`
    `protected Comparator<TOP>` | `comparatorWithoutID`
    `boolean` | `isAnnotIdx`
    `protected TypeImpl` | `type`
    `protected WeakReference<CopyOnWriteIndexPart<T>>` | `wr_cow` common copy on write instance or null; starts out as null Iterator creation initializes (if null).

    - ### Fields inherited from interface org.apache.uima.cas.impl.LowLevelIndex

      `FS_ID_COMPARATOR, IS_ORDERED, IS_TYPE_ORDER`

    - ### Fields inherited from interface org.apache.uima.cas.FSIndex

      `BAG_INDEX, DEFAULT_BAG_INDEX, SET_INDEX, SORTED_INDEX`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `FsIndex_singletype(CASImpl cas, Type type, int indexType, FSIndexComparator comparatorForIndexSpecs)` Constructor for FsIndex_singletype.

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `assertFsTypeMatchesIndexType(FeatureStructure fs, String operation)`
    `protected abstract void` | `bulkAddTo(List<T> v)` For serialization: get all the items in this index and bulk add to an List<T>
    `abstract int` | `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` | `compare(int fs1, int fs2)`
    `protected abstract CopyOnWriteIndexPart<T>` | `createCopyOnWriteIndexPart()`
    `boolean` | `equals(Object obj)`
    `void` | `flush()`
    `CASImpl` | `getCasImpl()`
    `Comparator<TOP>` | `getComparator()`
    `FSIndexComparator` | `getComparatorForIndexSpecs()` This is **NOT** a comparator for Feature Structures, but rather something that compares two comparator specifications
    `FSIndexComparatorImpl` | `getComparatorImplForIndexSpecs()`
    `CopyOnWriteIndexPart<T>` | `getCopyOnWriteIndexPart()`
    `int` | `getIndexingStrategy()` Return the indexing strategy.
    `protected CopyOnWriteIndexPart<T>` | `getNonNullCow()`
    `Type` | `getType()` Return the type of feature structures this index contains.
    `TypeImpl` | `getTypeImpl()`
    `int` | `hashCode()`
    `boolean` | `isSorted()`
    `LowLevelIterator<T>` | `iterator(FeatureStructure initialPositionFs)` Return an iterator over the index.
    `int` | `ll_compare(int fs1, int fs2)` Compare two Feature structures, referred to by IDs
    `LowLevelIterator<T>` | `ll_iterator(boolean ambiguous)` Get a low-level, FS reference iterator.
    `protected void` | `maybeCopy()` Called just before modifying an index if wr_cow has a value, tell that value to create a preserving copy of the index part, and set wr_cow to null
    `String` | `toString()`
    `FSIndex<T>` | `withSnapshotIterators()` Creates a shared copy of this FSIndex configured to produce snapshot iterators that don't throw ConcurrentModificationExceptions.

    - ### Methods inherited from class java.util.AbstractCollection

      `add, addAll, clear, contains, containsAll, isEmpty, iterator, remove, removeAll, retainAll, size, toArray, toArray`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface java.util.Comparator

      `comparing, comparing, comparingDouble, comparingInt, comparingLong, naturalOrder, nullsFirst, nullsLast, reversed, reverseOrder, thenComparing, thenComparing, thenComparing, thenComparingDouble, thenComparingInt, thenComparingLong`

    - ### Methods inherited from interface org.apache.uima.cas.impl.LowLevelIndex

      `getIntIterator, getSubIndex, getSubIndex, iterator, iterator, ll_iterator, ll_maxAnnotSpan, select, select, select, select, select`

    - ### Methods inherited from interface org.apache.uima.cas.FSIndex

      `contains, find, size, stream, subType, subType`

    - ### Methods inherited from interface java.util.Collection

      `add, addAll, clear, contains, containsAll, isEmpty, parallelStream, remove, removeAll, removeIf, retainAll, spliterator, toArray, toArray`

    - ### Methods inherited from interface java.lang.Iterable

      `forEach`

- - ### Field Detail

    - #### casImpl

          protected final CASImpl casImpl

    - #### comparatorForIndexSpecs

          protected final FSIndexComparatorImpl comparatorForIndexSpecs

      comparator for an index, passed in as an argument to the constructor

    - #### comparatorWithID

          protected final Comparator<TOP> comparatorWithID

    - #### comparatorWithoutID

          protected final Comparator<TOP> comparatorWithoutID

    - #### comparatorNoTypeWithID

          protected final Comparator<TOP> comparatorNoTypeWithID

      comparator (with id) (ignoring typeorder) - used within one type

    - #### comparatorNoTypeWithoutID

          protected final Comparator<TOP> comparatorNoTypeWithoutID

      comparator (without id) (ignoring typeorder) - used within one type - used for iterator operations where the type is requested to be ignored

    - #### isAnnotIdx

          public final boolean isAnnotIdx

    - #### type

          protected final TypeImpl type

    - #### wr_cow

          protected WeakReference<CopyOnWriteIndexPart<T extends FeatureStructure>> wr_cow

      common copy on write instance or null; starts out as null Iterator creation initializes (if null). A subsequent Modification to index, if this is not null: call cow.makeCopy(); set wr_cow = null do the modification index clear/flush - set to null; Weak ref so that after iterator is GC'd, and no ref's exist, this becomes null, so that future mods no longer need to do extra work.

  - ### Constructor Detail

    - #### FsIndex_singletype

          protected FsIndex_singletype(CASImpl cas,
                                       Type type,
                                       int indexType,
                                       FSIndexComparator comparatorForIndexSpecs)

      Constructor for FsIndex_singletype.
      Parameters:
        `cas` - -
        `type` - -
        `indexType` - -
        `comparatorForIndexSpecs` - -

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `AbstractCollection<T extends FeatureStructure>`

    - #### iterator

          public LowLevelIterator<T> iterator(FeatureStructure initialPositionFs)

      Description copied from interface: `FSIndex`
      Return an iterator over the index. The position of the iterator will be set such that the feature structure returned by a call to the iterator's `get()` method is greater than or equal to `fs`, and any previous FS is less than `FS` (the iterator is positioned at the earliest of equal values). If no such position exists, the iterator will be invalid.
      Specified by:
        `iterator` in interface `FSIndex<T extends FeatureStructure>`
      Parameters:
        `initialPositionFs` - A feature structure template (may be a supertype of T) having keys used in the index compare function, specifying where to initially position the iterator.
      Returns:
        An iterator positioned at `fs`, if it exists; else, an invalid iterator.

    - #### getComparator

          public Comparator<TOP> getComparator()

      Specified by:
        `getComparator` in interface `LowLevelIndex<T extends FeatureStructure>`
      Returns:
        a comparator used by this index to compare Feature Structures For sets, the equal is used to determine set membership For sorted, the comparator is the sort order (this comparator is without the ID)

    - #### getComparatorForIndexSpecs

          public FSIndexComparator getComparatorForIndexSpecs()

      Description copied from interface: `LowLevelIndex`
      This is **NOT** a comparator for Feature Structures, but rather something that compares two comparator specifications
      Specified by:
        `getComparatorForIndexSpecs` in interface `LowLevelIndex<T extends FeatureStructure>`
      Returns:
        -

    - #### getComparatorImplForIndexSpecs

          public FSIndexComparatorImpl getComparatorImplForIndexSpecs()

    - #### getIndexingStrategy

          public int getIndexingStrategy()

      Description copied from interface: `FSIndex`
      Return the indexing strategy.
      Specified by:
        `getIndexingStrategy` in interface `FSIndex<T extends FeatureStructure>`
      Returns:
        One of `SORTED_INDEX`, `BAG_INDEX` or `SET_INDEX`.

    - #### ll_compare

          public int ll_compare(int fs1,
                                int fs2)

      Description copied from interface: `LowLevelIndex`
      Compare two Feature structures, referred to by IDs
      Specified by:
        `ll_compare` in interface `LowLevelIndex<T extends FeatureStructure>`
      Parameters:
        `fs1` - -
        `fs2` - -
      Returns:
        0 if equal, < 0 if fs1 < fs2, > 0 if fs1 > fs2

    - #### compare

          public int compare(int fs1,
                             int fs2)

      Parameters:
        `fs1` - -
        `fs2` - -
      Returns:
        0 if equal, < 0 if fs1 < fs2, > 0 if fs1 > fs2

    - #### hashCode

          public int hashCode()

      Specified by:
        `hashCode` in interface `Collection<T extends FeatureStructure>`
      Overrides:
        `hashCode` in class `Object`

    - #### equals

          public boolean equals(Object obj)

      Specified by:
        `equals` in interface `Collection<T extends FeatureStructure>`
      Specified by:
        `equals` in interface `Comparator<FeatureStructure>`
      Overrides:
        `equals` in class `Object`

    - #### getType

          public Type getType()

      Description copied from interface: `FSIndex`
      Return the type of feature structures this index contains.
      Specified by:
        `getType` in interface `FSIndex<T extends FeatureStructure>`
      Returns:
        The type of feature structures in this index.
      See Also:
        `FSIndex.getType()`

    - #### getTypeImpl

          public TypeImpl getTypeImpl()

    - #### bulkAddTo

          protected abstract void bulkAddTo(List<T> v)

      For serialization: get all the items in this index and bulk add to an List<T>
      Parameters:
        `v` - the set of items to add

    - #### ll_iterator

          public LowLevelIterator<T> ll_iterator(boolean ambiguous)

      Description copied from interface: `LowLevelIndex`
      Get a low-level, FS reference iterator. This iterator can be disambiguated. This means that only non-overlapping annotations will be returned. Non-annotation FSs will be filtered in this mode.
      Specified by:
        `ll_iterator` in interface `LowLevelIndex<T extends FeatureStructure>`
      Parameters:
        `ambiguous` - When set to `false`, iterator will be disambiguated.
      Returns:
        An iterator for this index.

    - #### getCasImpl

          public CASImpl getCasImpl()

      Specified by:
        `getCasImpl` in interface `LowLevelIndex<T extends FeatureStructure>`
      Returns:
        a CAS View associated with this iterator

    - #### withSnapshotIterators

          public FSIndex<T> withSnapshotIterators()

      Description copied from interface: `FSIndex`
      Creates a shared copy of this FSIndex configured to produce snapshot iterators that don't throw ConcurrentModificationExceptions.
      Specified by:
        `withSnapshotIterators` in interface `FSIndex<T extends FeatureStructure>`
      Returns:
        a light-weight copy of this FSIndex, configured such that any iterator created using it will be a snapshot iterator - one where a snapshot is made of the state of the index at the time the iterator is created, and where subsequent modifications to the underlying index are allowed, but don't affect the iterator (which iterates over the read-only snapshot). Iterators produced with this won't throw ConcurrentModificationExceptions.

    - #### isSorted

          public boolean isSorted()

      Specified by:
        `isSorted` in interface `LowLevelIndex<T extends FeatureStructure>`
      Returns:
        true if the index is sorted

    - #### getNonNullCow

          protected CopyOnWriteIndexPart<T> getNonNullCow()

    - #### getCopyOnWriteIndexPart

          public CopyOnWriteIndexPart<T> getCopyOnWriteIndexPart()

      Returns:
        the copy-on-write wrapper for an index part if it exists for this index, or null

    - #### createCopyOnWriteIndexPart

          protected abstract CopyOnWriteIndexPart<T> createCopyOnWriteIndexPart()

    - #### maybeCopy

          protected void maybeCopy()

      Called just before modifying an index if wr_cow has a value, tell that value to create a preserving copy of the index part, and set wr_cow to null

    - #### flush

          public void flush()

      Specified by:
        `flush` in interface `LowLevelIndex<T extends FeatureStructure>`

    - #### compare

          public abstract int 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
      Specified by:
        `compare` in interface `Comparator<FeatureStructure>`
      Specified by:
        `compare` in interface `FSIndex<T extends FeatureStructure>`
      Parameters:
        `o1` - the first Feature Structure to compare
        `o2` - the second Feature Structure to compare
      Returns:
        `-1` if `fs1 < fs2`; `0` if `fs1 = fs2`; `1` else.

    - #### assertFsTypeMatchesIndexType

          protected final void assertFsTypeMatchesIndexType(FeatureStructure fs,
                                                            String operation)

Copyright © 2006–2022 The Apache Software Foundation. All rights reserved.