Package 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
  Description
  `protected final CASImpl`
  `casImpl`
  `protected final FSIndexComparatorImpl`
  `comparatorForIndexSpecs`
  comparator for an index, passed in as an argument to the constructor
  `protected final Comparator<TOP>`
  `comparatorNoTypeWithID`
  comparator (with id) (ignoring typeorder) - used within one type
  `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
  `protected final Comparator<TOP>`
  `comparatorWithID`
  `protected final Comparator<TOP>`
  `comparatorWithoutID`
  `final boolean`
  `isAnnotIdx`
  `protected final 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.FSIndex

  `BAG_INDEX, DEFAULT_BAG_INDEX, SET_INDEX, SORTED_INDEX`

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

  `FS_ID_COMPARATOR, IS_ORDERED, IS_TYPE_ORDER`

- ## Constructor Summary

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

- ## Method Summary

  Modifier and Type
  Method
  Description
  `protected final 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>
  `int`
  `compare(int fs1, int fs2)`
  `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
  `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.Collection

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

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

  `reversed, thenComparing, thenComparing, thenComparing, thenComparingDouble, thenComparingInt, thenComparingLong`

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

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

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

  `forEach`

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

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

- ## Field Details

  - ### 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 Details

  - ### FsIndex_singletype

    protected FsIndex_singletype(CASImpl cas, Type type, int indexType, FSIndexComparator comparatorForIndexSpecs)
    Constructor for FsIndex_singletype.
    Parameters:
      `cas` - -
      `type` - -
      `indexType` - -
      `comparatorForIndexSpecs` - -

- ## Method Details

  - ### 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<T extends 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<T extends 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)