public class AnnotationIndexImpl<T extends AnnotationFS> extends Object implements AnnotationIndex<T>
BAG_INDEX, DEFAULT_BAG_INDEX, SET_INDEX, SORTED_INDEX| Constructor and Description |
|---|
AnnotationIndexImpl(FSIndex<T> index) |
| Modifier and Type | Method and Description |
|---|---|
int |
compare(FeatureStructure fs1,
FeatureStructure fs2)
Compare two feature structures according to the ordering relation of the index.
|
boolean |
contains(FeatureStructure fs)
Check if the index contains an element equal to the given feature structure
according to the comparators defined for this index.
|
FeatureStructure |
find(FeatureStructure fs)
Find an entry in the index "equal to" the given feature structure according to the comparators specified
for this index.
|
int |
getIndexingStrategy()
Return the indexing strategy.
|
Type |
getType()
Return the type of feature structures this index contains.
|
FSIterator<T> |
iterator()
Return an iterator over the index.
|
FSIterator<T> |
iterator(boolean ambiguous)
Return an iterator over annotations that can be constrained to be unambiguous.
|
FSIterator<T> |
iterator(FeatureStructure fs)
Return an iterator over the index.
|
int |
size()
Return the number of feature structures in this index.
|
FSIterator<T> |
subiterator(AnnotationFS annot)
Return a subiterator whose bounds are defined by the input annotation.
|
FSIterator<T> |
subiterator(AnnotationFS annot,
boolean ambiguous,
boolean strict)
Return a subiterator whose bounds are defined by the input annotation.
|
AnnotationTree<T> |
tree(T annot)
Create an annotation tree with
annot as root node. |
FSIndex<T> |
withSnapshotIterators()
Creates a shared copy of this FSIndex configured to produce snapshot iterators
that don't throw ConcurrentModificationExceptions.
|
public int size()
FSIndexsize in interface FSIndex<T extends AnnotationFS>public Type getType()
FSIndexgetType in interface FSIndex<T extends AnnotationFS>public boolean contains(FeatureStructure fs)
FSIndexcontains in interface FSIndex<T extends AnnotationFS>fs - A Feature Structure used a template to match for equality with the
FSs in the index.true if the index contains such an element.public FeatureStructure find(FeatureStructure fs)
FSIndexfind in interface FSIndex<T extends AnnotationFS>fs - A Feature Structure used a template to match with the Feature Structures in the index.null if no such FS exists.FSIterator.moveTo(FeatureStructure)public int compare(FeatureStructure fs1, FeatureStructure fs2)
FSIndexcompare in interface FSIndex<T extends AnnotationFS>fs1 - the first Feature Structure to comparefs2 - the second Feature Structure to compare-1 if fs1 < fs2; 0 if
fs1 = fs2; 1 else.public FSIterator<T> iterator()
FSIndexiterator in interface Iterable<T extends AnnotationFS>iterator in interface FSIndex<T extends AnnotationFS>public FSIterator<T> iterator(FeatureStructure fs)
FSIndexget() 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.iterator in interface FSIndex<T extends AnnotationFS>fs - The feature structure at which the iterator should be positioned.fs, if it exists. An invalid iterator, else.public int getIndexingStrategy()
FSIndexgetIndexingStrategy in interface FSIndex<T extends AnnotationFS>SORTED_INDEX, BAG_INDEX or SET_INDEX.public FSIterator<T> iterator(boolean ambiguous)
AnnotationIndex
A disambiguated iterator is defined as follows. The first annotation returned is the same as
would be returned by the corresponding ambiguous iterator. If the unambiguous iterator has
returned a previously, it will next return the smallest b s.t. a < b and a.getEnd() <=
b.getBegin(). In other words, the b annotation's start will be large enough to not
overlap the span of a.
An unambiguous iterator makes a snapshot copy of the index containing just the disambiguated items, and iterates over that. It doesn't check for concurrent index modifications (the ambiguous iterator does check for this).
iterator in interface AnnotationIndex<T extends AnnotationFS>ambiguous - If set to false, iterator will be unambiguous.public FSIterator<T> subiterator(AnnotationFS annot)
AnnotationIndex
The subiterator will return annotations b s.t. annot < b,
annot.getBegin() <= b.getBegin() and
annot.getEnd() >= b.getEnd(). For annotations x, y, x < y
here is to be interpreted as "x comes before y in the index", according to the rules defined in
the description of this class.
This definition implies that annotations b that have the same span as
annot may or may not be returned by the subiterator. This is determined by the
type priorities; the subiterator will only return such an annotation b if the
type of annot precedes the type of b in the type priorities
definition. If you have not specified the priority, or if annot and
b are of the same type, then the behavior is undefined.
For example, if you an annotation s of type Sentence and an
annotation p of type Paragraph that have the same span, and you
have defined Paragraph before Sentence in your type priorities,
then subiterator(p) will give you an iterator that will return s,
but subiterator(s) will give you an iterator that will NOT return p.
The intuition is that a Paragraph is conceptually larger than a Sentence, as defined by the
type priorities.
Calling subiterator(a) is equivalent to calling
subiterator(a, true, true).. See
subiterator(AnnotationFS, boolean, boolean).
subiterator in interface AnnotationIndex<T extends AnnotationFS>annot - Defines the boundaries of the subiterator.public FSIterator<T> subiterator(AnnotationFS annot, boolean ambiguous, boolean strict)
AnnotationIndex
A strict subiterator is defined as follows: it will return annotations
b s.t. annot < b,
annot.getBegin() <= b.getBegin() and
annot.getEnd() >= b.getEnd(). For annotations x,y, x < y
here is to be interpreted as "x comes before y in the index", according to the rules defined in
the description of this class.
If strict is set to false, the boundary conditions are relaxed
as follows: return annotations b s.t. annot < b and
annot.getBegin() <= b.getBegin() <= annot.getEnd(). The resulting
iterator may also be disambiguated.
These definitions imply that annotations b that have the same span as
annot may or may not be returned by the subiterator. This is determined by the
type priorities; the subiterator will only return such an annotation b if the
type of annot precedes the type of b in the type priorities
definition. If you have not specified the priority, or if annot and
b are of the same type, then the behavior is undefined.
For example, if you an annotation s of type Sentence and an
annotation p of type Paragraph that have the same span, and you
have defined Paragraph before Sentence in your type priorities,
then subiterator(p) will give you an iterator that will return s,
but subiterator(s) will give you an iterator that will NOT return p.
The intuition is that a Paragraph is conceptually larger than a Sentence, as defined by the
type priorities.
subiterator in interface AnnotationIndex<T extends AnnotationFS>annot - Annotation setting boundary conditions for subiterator.ambiguous - If set to false, resulting iterator will be unambiguous.strict - Controls if annotations that overlap to the right are considered in or out.public AnnotationTree<T> tree(T annot)
AnnotationIndexannot as root node. The tree is defined as
follows: for each node in the tree, the children are the sequence of annotations that would be
obtained from a strict, unambiguous subiterator of the node's annotation.tree in interface AnnotationIndex<T extends AnnotationFS>annot - The annotation at the root of the tree. This must be of type T or a subtypeannot.public FSIndex<T> withSnapshotIterators()
FSIndexwithSnapshotIterators in interface FSIndex<T extends AnnotationFS>Copyright © 2015. All rights reserved.