Java FSIterator.moveToLast方法代码示例

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
/**
 * Return previous element if exists.
 *
 * @param iter   iterator
 * @param anchor an anchor
 * @return previous element if exists or null otherwise
 */
private static Token getPrevious(FSIterator<Token> iter, TokenBase anchor) {
    iter.moveTo(anchor);
    // now the current fs either greater (for tokens seq it means 'after') or equal to the anchor
    if (iter.isValid()) {
        // in any case we should move backward (true for disjoint token segmentation)
        iter.moveToPrevious();
        if (iter.isValid()) {
            return iter.get();
        } else {
            return null;
        }
    } else {
        // check for a case when anchor is after the last visible token
        iter.moveToLast();
        if (iter.isValid()) {
            return iter.get();
        } else {
            return null;
        }
    }
}
 

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
@Override
public void process(JCas jCas) throws AnalysisEngineProcessException {
    Sentence sent = AnnotationFactory.createAnnotation(jCas, 0, jCas.getDocumentText().length(), Sentence.class);
    FSIterator<Token> tokenIter = jCas.getAnnotationIndex(Token.class).iterator();
    Token firstToken = null;
    Token lastToken = null;
    tokenIter.moveToFirst();
    if (tokenIter.isValid()) {
        firstToken = tokenIter.get();
        tokenIter.moveToLast();
        lastToken = tokenIter.get();
    }
    sent.setFirstToken(firstToken);
    sent.setLastToken(lastToken);
}
 

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
/**
 * REM: modified from CasUtils..
 * 
 * Get a list of annotations of the given annotation type constraint by a
 * start and end. It's good to provide an annotation that is close to the
 * region, to quickly move the iterator
 * 
 * @param cas
 *            a CAS.
 * @param type
 *            a UIMA type.
 * @param annotationCloseToTheRegion
 *            the covering annotation.
 * @return a return value.
 * @see Subiterator
 */
private static List<Annotation> selectMatching(CAS cas, final int begin,
        final int end, AnnotationFS annotationCloseToTheRegion) {

    final List<Annotation> list = new ArrayList<Annotation>();
    final FSIterator<AnnotationFS> it = cas.getAnnotationIndex().iterator();

    // Try to seek the insertion point.
    it.moveTo(annotationCloseToTheRegion);

    // If the insertion point is beyond the index, move back to the last.
    if (!it.isValid()) {
        it.moveToLast();
        if (!it.isValid()) {
            return list;
        }
    }

    // Ignore type priorities by seeking to the first that has the same
    // begin
    boolean moved = false;
    while (it.isValid() && (it.get()).getBegin() >= begin) {
        it.moveToPrevious();
        moved = true;
    }

    // If we moved, then we are now on one starting before the requested
    // begin, so we have to
    // move one ahead.
    if (moved) {
        it.moveToNext();
    }

    // If we managed to move outside the index, start at first.
    if (!it.isValid()) {
        it.moveToFirst();
    }

    // Skip annotations whose start is before the start parameter.
    while (it.isValid() && (it.get()).getBegin() < begin) {
        it.moveToNext();
    }

    while (it.isValid()) {
        AnnotationFS a = it.get();
        if (!(a instanceof Annotation))
            continue;

        // If the start of the current annotation is past the end parameter,
        // we're done.
        if (a.getBegin() > end) {
            break;
        }
        it.moveToNext();

        if (a.getBegin() == begin && a.getEnd() == end) {
            list.add((Annotation) a);
        }
    }
    return unmodifiableList(list);
}
 

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
/**
 * Finds the covering annotation of the specified coverFSType for the given annotation.
 * 
 * @param aCAS
 *          a CAS to search in
 * @param annot
 *          current annotation
 * @param coverFsType
 *          covering annotation type to search for
 * 
 * @return returns the covering annotation FS or null if the covering annotation was not found.
 * 
 */
private AnnotationFS findCoverFS(CAS aCAS, AnnotationFS annot, Type coverFsType) {

  // covering annotation
  AnnotationFS coverFs = null;

  // create a searchFS of the coverFsType with the annot boundaries to
  // search for it.
  FeatureStructure searchFs = aCAS.createAnnotation(coverFsType, annot.getBegin(), aCAS
      .getDocumentText().length());

  // get the coverFSType iterator from the CAS and move it "near" to the
  // position of the created searchFS.
  FSIterator<?> iterator = aCAS.getAnnotationIndex(coverFsType).iterator();
  iterator.moveTo(searchFs);

  // now the iterator can either point directly to the FS we are searching
  // or it points to the next higher FS in the list. So we either have
  // already found the correct one, of we maybe have to move the iterator to
  // the previous position.

  // check if the iterator at the current position is valid
  if (iterator.isValid()) {
    // iterator is valid, so we either have the correct annotation of we
    // have to move to the
    // previous one, lets check the current FS from the iterator
    // get current FS
    coverFs = (AnnotationFS) iterator.get();
    // check if the coverFS covers the current match type annotation
    if ((coverFs.getBegin() <= annot.getBegin()) && (coverFs.getEnd() >= annot.getEnd())) {
      // we found the covering annotation
      return coverFs;
    }
    // current coverFs does not cover the current match type annotation
    // lets try to move iterator to the previous annotation and check
    // again
    iterator.moveToPrevious();
    // check if the iterator is still valid after me move it to the
    // previous FS
    if (iterator.isValid()) {
      // get FS
      coverFs = (AnnotationFS) iterator.get();
      // check the found coverFS covers the current match type
      // annotation
      if ((coverFs.getBegin() <= annot.getBegin()) && (coverFs.getEnd() >= annot.getEnd())) {
        // we found the covering annotation
        return coverFs;
      }
    }
  }
  // iterator is invalid lets try to move the iterator to the last FS and
  // check the FS
  iterator.moveToLast();
  // check if the iterator is valid after we move it
  if (iterator.isValid()) {
    // get FS
    coverFs = (AnnotationFS) iterator.get();
    // check the found coverFS covers the current match type annotation
    if ((coverFs.getBegin() <= annot.getBegin()) && (coverFs.getEnd() >= annot.getEnd())) {
      // we found the covering annotation
      return coverFs;
    }
  }
  // no covering annotation found
  return null;
}