public class AnnotationIndexImpl<T extends AnnotationFS> extends java.lang.Object implements AnnotationIndex<T>
BAG_INDEX, DEFAULT_BAG_INDEX, SET_INDEX, SORTED_INDEX
Constructor and Description |
---|
AnnotationIndexImpl(FSIndex<AnnotationFS> 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
ordering of the index.
|
FeatureStructure |
find(FeatureStructure fs)
Find an entry in the index equal to the given feature structure according to the ordering of
the 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. |
public AnnotationIndexImpl(FSIndex<AnnotationFS> index)
public int size()
FSIndex
size
in interface FSIndex<T extends AnnotationFS>
public Type getType()
FSIndex
getType
in interface FSIndex<T extends AnnotationFS>
public boolean contains(FeatureStructure fs)
FSIndex
contains
in interface FSIndex<T extends AnnotationFS>
fs
- The FS we're looking for.true
if the index contains such an element.public FeatureStructure find(FeatureStructure fs)
FSIndex
find
in interface FSIndex<T extends AnnotationFS>
fs
- The FS we're looking for.fs
, or null
if no such FS exists.FSIterator.moveTo(FeatureStructure)
public int compare(FeatureStructure fs1, FeatureStructure fs2)
FSIndex
compare
in interface FSIndex<T extends AnnotationFS>
-1
if fs1 < fs2
; 0
if
fs1 = fs2
; 1
else.public FSIterator<T> iterator()
FSIndex
iterator
in interface java.lang.Iterable<T extends AnnotationFS>
iterator
in interface FSIndex<T extends AnnotationFS>
public FSIterator<T> iterator(FeatureStructure fs)
FSIndex
get()
method is
greater than or equal to fs
, and any previous FS is less than FS
.
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()
FSIndex
getIndexingStrategy
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().
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 intutition 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)
AnnotationIndex
annot
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.annot
.Copyright © 2012. All Rights Reserved.