Package org.apache.uima.cas.impl
Class FsIndex_iicp<T extends FeatureStructure>
java.lang.Object
java.util.AbstractCollection<T>
org.apache.uima.cas.impl.FsIndex_iicp<T>
- All Implemented Interfaces:
Comparable<FsIndex_iicp<? extends FeatureStructure>>
,Iterable<T>
,Collection<T>
,Comparator<FeatureStructure>
,FSIndex<T>
,LowLevelIndex<T>
- Direct Known Subclasses:
FsIndex_annotation
class FsIndex_iicp<T extends FeatureStructure>
extends AbstractCollection<T>
implements Comparable<FsIndex_iicp<? extends FeatureStructure>>, Comparator<FeatureStructure>, LowLevelIndex<T>
FsIndex_iicp (iicp)
A pair of an leaf index and an iterator cache. An iterator cache is the set of all leaf-indexes
necessary to create an iterator for the type of the index.
The cache includes the index for the type of this index, as well as all subtypes.
compareTo() is based on types and the comparator of the index.
T is the Java cover class of the top type (root) in the index set
Also includes a lazily initialized reference to a corresponding FSIndexFlat instance.
This class is package private to share with FSIndexFlat For Internal Use
-
Field Summary
FieldsModifier and TypeFieldDescription(package private) FsIndex_singletype<TOP>[]
A list of indexes (the sub-indexes that we need for an iterator).(package private) final FsIndex_singletype
<T> The "root" index, i.e., index of the type of the iterator.(package private) final FSIndexRepositoryImpl
private boolean
(package private) int[]
The type codes corresponding to the cachedSubFsLeafIndexes, set up lazilyFields 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 -
Method Summary
Modifier and TypeMethodDescription(package private) void
collectCowIndexParts
(ArrayList<CopyOnWriteIndexPart<T>> indexes) int
compare
(FeatureStructure fs1, FeatureStructure fs2) Compare two feature structures according to the ordering relation of the index.int
compareTo
(FsIndex_iicp<? extends FeatureStructure> cp) Maybe not used 3/2015 Compares two instances of FsIndex_iicp, for ordering.boolean
Check if the index contains an element equal to the given feature structure according to the comparators defined for this index.(package private) void
boolean
Two iicps are equal if and only if: - the types they index are the same, and - the comparators are equal, and - the indexing stragtegy (bag/set/sorted) are the same Used when creating the index iterator cache to select from the set of all instances of these the one that goes with the same index definition Used by CasComplete serialization to merge multiple index names referring to the same indexfind
(FeatureStructure fs) Find an entry in the index "equal to" the given feature structure according to the comparators specified for this index.This is **NOT** a comparator for Feature Structures, but rather something that compares two comparator specifications(package private) FsIndex_singletype
<T> int
Return the indexing strategy.(package private) LowLevelIterator<T>[]
getType()
Return the type of feature structures this index contains.(package private) int
(package private) int
A faster version of size() when there are lots of subtypes The cache must be already set up Guess by adding the sizes of up to the first 3 type/subtypes, then add 1 more for each subtype in addition.int
hashCode()
private void
initOneTypeThenAllSubtypes
(TypeImpl ti, ArrayList<FsIndex_singletype<FeatureStructure>> cache, int indexKind) This method inits one type then calls itself for all direct subtypes(package private) boolean
boolean
isEmpty()
(package private) boolean
boolean
isSorted()
iterator()
Iterator varieties All iterators are over a Type + subtypes (because that's the purpose of this class) - ambiguous / unambiguous (for AnnotationIndex) - not strict / strict (for AnnotationIndex) - ignoring type priorities or not (for any index) - "unordered" - no need to preserve order These may be combined.iterator
(boolean orderNotNeeded, boolean ignoreType) Internal use, used by select framework.int
ll_compare
(int ref1, int ref2) Compare two Feature structures, referred to by IDsll_iterator
(boolean ambiguous) Iterator over arbitrary Feature Structures, but also filters out non-AnnotationFS FeatureStructuresint
int
size()
Return the number of feature structures in this index.toString()
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, remove, removeAll, retainAll, 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, parallelStream, remove, removeAll, removeIf, retainAll, spliterator, toArray, toArray
Methods inherited from interface java.util.Comparator
reversed, thenComparing, thenComparing, thenComparing, thenComparingDouble, thenComparingInt, thenComparingLong
Methods inherited from interface org.apache.uima.cas.impl.LowLevelIndex
flush, getIntIterator, getSubIndex, getSubIndex, ll_iterator, select, select, select, select, select
-
Field Details
-
fsIndexRepositoryImpl
-
fsIndex_singletype
The "root" index, i.e., index of the type of the iterator. default visibility to make it accessible by FSIndexFlat -
cachedSubFsLeafIndexes
FsIndex_singletype<TOP>[] cachedSubFsLeafIndexesA list of indexes (the sub-indexes that we need for an iterator). I.e., one index for each type that's subsumed by the iterator's type; includes the iterator's type leaf index too. This is set up lazily on first need, to avoid extra work when won't be accessed -
isIteratorCacheSetup
private volatile boolean isIteratorCacheSetup -
sortedTypeCodes
int[] sortedTypeCodesThe type codes corresponding to the cachedSubFsLeafIndexes, set up lazily
-
-
Constructor Details
-
FsIndex_iicp
FsIndex_iicp(FsIndex_singletype<T> fsIndex_singletype)
-
-
Method Details
-
toString
- Overrides:
toString
in classAbstractCollection<T extends FeatureStructure>
-
equals
Two iicps are equal if and only if: - the types they index are the same, and - the comparators are equal, and - the indexing stragtegy (bag/set/sorted) are the same Used when creating the index iterator cache to select from the set of all instances of these the one that goes with the same index definition Used by CasComplete serialization to merge multiple index names referring to the same index- Specified by:
equals
in interfaceCollection<T extends FeatureStructure>
- Specified by:
equals
in interfaceComparator<T extends FeatureStructure>
- Overrides:
equals
in classObject
-
hashCode
public int hashCode()- Specified by:
hashCode
in interfaceCollection<T extends FeatureStructure>
- Overrides:
hashCode
in classObject
-
createIndexIteratorCache
void createIndexIteratorCache() -
initOneTypeThenAllSubtypes
private void initOneTypeThenAllSubtypes(TypeImpl ti, ArrayList<FsIndex_singletype<FeatureStructure>> cache, int indexKind) This method inits one type then calls itself for all direct subtypes- Parameters:
ti
-cache
-indexKind
-
-
compareTo
Maybe not used 3/2015 Compares two instances of FsIndex_iicp, for ordering. Compares first using the type code of the main types If those are equal, Compares using the comparatorForIndexSpecs objects- Specified by:
compareTo
in interfaceComparable<T extends FeatureStructure>
- See Also:
-
size
public int size()Description copied from interface:FSIndex
Return the number of feature structures in this index.- Specified by:
size
in interfaceCollection<T extends FeatureStructure>
- Specified by:
size
in interfaceFSIndex<T extends FeatureStructure>
- Specified by:
size
in classAbstractCollection<T extends FeatureStructure>
- Returns:
- the sum of the sizes of the indexes of the type + all subtypes
-
ll_maxAnnotSpan
public int ll_maxAnnotSpan()- Specified by:
ll_maxAnnotSpan
in interfaceLowLevelIndex<T extends FeatureStructure>
- Returns:
- for annotation indexes, an conservative estimate the maximum span between begin and end The value may be larger than actual.
-
isEmpty
public boolean isEmpty()- Specified by:
isEmpty
in interfaceCollection<T extends FeatureStructure>
- Overrides:
isEmpty
in classAbstractCollection<T extends FeatureStructure>
-
guessedSize
int guessedSize()A faster version of size() when there are lots of subtypes The cache must be already set up Guess by adding the sizes of up to the first 3 type/subtypes, then add 1 more for each subtype in addition.- Returns:
- a guess at the size, done quickly
-
getFsIndex_singleType
FsIndex_singletype<T> getFsIndex_singleType() -
isDefaultBagIndex
boolean isDefaultBagIndex() -
isSetIndex
boolean isSetIndex() -
ll_compare
public int ll_compare(int ref1, int ref2) Description copied from interface:LowLevelIndex
Compare two Feature structures, referred to by IDs- Specified by:
ll_compare
in interfaceLowLevelIndex<T extends FeatureStructure>
- Parameters:
ref1
- -ref2
- -- Returns:
- -
-
getIndexingStrategy
public int getIndexingStrategy()Description copied from interface:FSIndex
Return the indexing strategy.- Specified by:
getIndexingStrategy
in interfaceFSIndex<T extends FeatureStructure>
- Returns:
- One of
SORTED_INDEX
,BAG_INDEX
orSET_INDEX
.
-
getComparator
- Specified by:
getComparator
in interfaceLowLevelIndex<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
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 interfaceLowLevelIndex<T extends FeatureStructure>
- Returns:
- -
-
getComparatorImplForIndexSpecs
-
compare
Description copied from interface:FSIndex
Compare two feature structures according to the ordering relation of the index. If the input feature structures are not of the type of the index or a supertype, the result is undefined. Because the indexes compare might use only features defined in supertypes, the arguments being compared could be supertypes of the indexed type.- Specified by:
compare
in interfaceComparator<T extends FeatureStructure>
- Specified by:
compare
in interfaceFSIndex<T extends FeatureStructure>
- Parameters:
fs1
- the first Feature Structure to comparefs2
- the second Feature Structure to compare- Returns:
-1
iffs1 < fs2
;0
iffs1 = fs2
;1
else.
-
contains
Description copied from interface:FSIndex
Check if the index contains an element equal to the given feature structure according to the comparators defined for this index. For bag indexes (which have no comparators), the equality test means the identical feature structure. Note that this is in general not the same as feature structure identity.
The element is used as a template, and may be a supertype of the type of the index, as long as the keys specified for this index can be accessed.
- Specified by:
contains
in interfaceFSIndex<T extends FeatureStructure>
- Parameters:
fs
- A Feature Structure used a template to match for equality with the FSs in the index.- Returns:
true
if the index contains such an element.
-
find
Description copied from interface:FSIndex
Find an entry in the index "equal to" the given feature structure according to the comparators specified for this index. Note that this is in general not the same as feature structure identity. For BAG indexes, it is identity, for others it means the found feature structure compares equal with the parameter in terms of the defined comparators for the index. If there are multiple different FSs in the index which compare equal with the given feature structure, an arbitrary one is returned. This differs from the moveTo(fs) operation which guarantees to move to the first feature structure occurring in the index in this case.- Specified by:
find
in interfaceFSIndex<T extends FeatureStructure>
- Parameters:
fs
- A Feature Structure used a template to match with the Feature Structures in the index. It must have the keys needed to do the compare as specified for the index that it's in.- Returns:
- A FS equal to the template argument, or
null
if no such FS exists. - See Also:
-
getType
Description copied from interface:FSIndex
Return the type of feature structures this index contains.- Specified by:
getType
in interfaceFSIndex<T extends FeatureStructure>
- Returns:
- The type of feature structures in this index.
-
getTypeCode
int getTypeCode() -
getCasImpl
- Specified by:
getCasImpl
in interfaceLowLevelIndex<T extends FeatureStructure>
- Returns:
- a CAS View associated with this iterator
-
isSorted
public boolean isSorted()- Specified by:
isSorted
in interfaceLowLevelIndex<T extends FeatureStructure>
- Returns:
- true if the index is sorted
-
iterator
Iterator varieties All iterators are over a Type + subtypes (because that's the purpose of this class) - ambiguous / unambiguous (for AnnotationIndex) - not strict / strict (for AnnotationIndex) - ignoring type priorities or not (for any index) - "unordered" - no need to preserve order These may be combined.- Specified by:
iterator
in interfaceCollection<T extends FeatureStructure>
- Specified by:
iterator
in interfaceFSIndex<T extends FeatureStructure>
- Specified by:
iterator
in interfaceIterable<T extends FeatureStructure>
- Specified by:
iterator
in interfaceLowLevelIndex<T extends FeatureStructure>
- Specified by:
iterator
in classAbstractCollection<T extends FeatureStructure>
- Returns:
- An FSIterator positioned at the beginning, or an invalid iterator.
-
iterator
Description copied from interface:LowLevelIndex
Internal use, used by select framework. Return an iterator over the index. The position of the iterator will be set to return the first item in the index. If the index is empty, the iterator position will be marked as invalid.- Specified by:
iterator
in interfaceLowLevelIndex<T extends FeatureStructure>
- Parameters:
orderNotNeeded
- if true, skips work while iterating to keep iterators over multiple types in sync.ignoreType
- if true, the comparator used for moveTo leftmost operations will ignore typeOrder keys, if the index happens to define these- Returns:
- An FSIterator positioned at the beginning, or an invalid iterator.
-
ll_iterator
Iterator over arbitrary Feature Structures, but also filters out non-AnnotationFS FeatureStructures- Specified by:
ll_iterator
in interfaceLowLevelIndex<T extends FeatureStructure>
- Parameters:
ambiguous
- true for normal iteration, false to do unambiguous iteration- Returns:
- the iterator
-
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 interfaceFSIndex<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.
-
getFsRepositoryImpl
-
streamNonEmptyIndexes
- Returns:
- a stream of FSIndex_singletype, for all non-empty indexes
-
collectCowIndexParts
-
getIterators
LowLevelIterator<T>[] getIterators()
-