Interface AnnotationIndex<T extends AnnotationFS>
- Type Parameters:
T
- The top most Java cover class (usually a JCas Class) specified for the underlying index.
- All Known Implementing Classes:
AnnotationIndexImpl
uima.tcas.Annotation
(or its subtypes). You can obtain an AnnotationIndex by calling:
AnnotationIndex idx = cas.getAnnotationIndex();
or
AnnotationIndex<SomeJCasType> idx = jcas.getAnnotationIndex(SomeJCasType.class);
Note that the AnnotationIndex defines the following sort order between two annotations:
- Annotations are sorted in increasing order of their start offset. That is, for any
annotations a and b, if
a.start < b.start
thena < b
. - Annotations whose start offsets are equal are next sorted by decreasing order of
their end offsets. That is, if
a.start = b.start
anda.end > b.end
, thena < b
. This causes annotations with larger spans to be sorted before annotations with smaller spans, which produces an iteration order similar to a preorder tree traversal. - Annotations whose start offsets are equal and whose end offsets are equal are sorted based
on
TypePriorities
(which is an element of the component descriptor). That is, ifa.start = b.start
,a.end = b.end
, and the type ofa
is defined before the type ofb
in the type priorities, thena < b
. - If none of the above rules apply, then the ordering is arbitrary. This will occur if you have two annotations of the exact same type that also have the same span. It will also occur if you have not defined any type priority between two annotations that have the same span.
In the method descriptions below, the notation a < b
, where a
and b
are annotations, should be taken to mean a
comes before
b
in the index, according to the above rules.
-
Field Summary
Fields inherited from interface org.apache.uima.cas.FSIndex
BAG_INDEX, DEFAULT_BAG_INDEX, SET_INDEX, SORTED_INDEX
-
Method Summary
Modifier and TypeMethodDescriptioniterator
(boolean ambiguous) Return an iterator over annotations that can be constrained to be unambiguous.subiterator
(AnnotationFS annot) Return a subiterator whose bounds are defined by the input annotation.subiterator
(AnnotationFS annot, boolean ambiguous, boolean strict) Return a subiterator whose bounds are defined by the input annotation.Create an annotation tree withannot
as root node.Methods inherited from interface org.apache.uima.cas.FSIndex
compare, contains, find, getIndexingStrategy, getType, iterator, iterator, size, withSnapshotIterators
Methods inherited from interface java.lang.Iterable
forEach, spliterator
-
Method Details
-
iterator
Return an iterator over annotations that can be constrained to be unambiguous.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 smallestb
s.t. a < b and a.getEnd() <= b.getBegin(). In other words, theb
annotation's start will be large enough to not overlap the span ofa
.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).
- Parameters:
ambiguous
- If set to false, iterator will be unambiguous.- Returns:
- A annotation iterator.
-
subiterator
Return a subiterator whose bounds are defined by the input annotation.The subiterator will return annotations
b
s.t.annot < b
,annot.getBegin() <= b.getBegin()
andannot.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 ofthis class
.This definition implies that annotations
b
that have the same span asannot
may or may not be returned by the subiterator. This is determined by the type priorities; the subiterator will only return such an annotationb
if the type ofannot
precedes the type ofb
in the type priorities definition. If you have not specified the priority, or ifannot
andb
are of the same type, then the behavior is undefined.For example, if you an annotation
s
of typeSentence
and an annotationp
of typeParagraph
that have the same span, and you have definedParagraph
beforeSentence
in your type priorities, thensubiterator(p)
will give you an iterator that will returns
, butsubiterator(s)
will give you an iterator that will NOT returnp
. The intuition is that a Paragraph is conceptually larger than a Sentence, as defined by the type priorities.Calling
subiterator(a)
is equivalent to callingsubiterator(a, true, true).
. Seesubiterator(AnnotationFS, boolean, boolean)
.- Parameters:
annot
- Defines the boundaries of the subiterator.- Returns:
- A subiterator.
-
subiterator
Return a subiterator whose bounds are defined by the input annotation.A
strict
subiterator is defined as follows: it will return annotationsb
s.t.annot < b
,annot.getBegin() <= b.getBegin()
andannot.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 ofthis class
.If
strict
is set tofalse
, the boundary conditions are relaxed as follows: return annotationsb
s.t.annot < b
andannot.getBegin() <= b.getBegin() <= annot.getEnd()
. The resulting iterator may also be disambiguated.These definitions imply that annotations
b
that have the same span asannot
may or may not be returned by the subiterator. This is determined by the type priorities; the subiterator will only return such an annotationb
if the type ofannot
precedes the type ofb
in the type priorities definition. If you have not specified the priority, or ifannot
andb
are of the same type, then the behavior is undefined.For example, if you an annotation
s
of typeSentence
and an annotationp
of typeParagraph
that have the same span, and you have definedParagraph
beforeSentence
in your type priorities, thensubiterator(p)
will give you an iterator that will returns
, butsubiterator(s)
will give you an iterator that will NOT returnp
. The intuition is that a Paragraph is conceptually larger than a Sentence, as defined by the type priorities.- Parameters:
annot
- Annotation setting boundary conditions for subiterator.ambiguous
- If set tofalse
, resulting iterator will be unambiguous.strict
- Controls if annotations that overlap to the right are considered in or out.- Returns:
- A subiterator.
-
tree
Create an annotation tree withannot
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.- Parameters:
annot
- The annotation at the root of the tree. This must be of type T or a subtype- Returns:
- The annotation tree rooted at
annot
.
-