Java FSIterator.moveToNext方法代码示例

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
public static void checkForTheSameBoundaries(CAS cas, Class<? extends AnnotationFS> typeClass) {
    Type type = CasUtil.getType(cas, typeClass);
    FSIterator<AnnotationFS> iter = cas.getAnnotationIndex(type).iterator();
    iter.moveToFirst();
    if (!iter.isValid()) {
        return;
    }
    AnnotationOffsetComparator<AnnotationFS> cmp =
            AnnotationOffsetComparator.instance(AnnotationFS.class);
    AnnotationFS lastAnno = iter.get();
    iter.moveToNext();
    while (iter.isValid()) {
        AnnotationFS anno = iter.get();
        if (cmp.compare(anno, lastAnno) == 0) {
            throw new IllegalStateException(String.format(
                    "Annotations %s and %s have the same boundaries",
                    lastAnno, anno));
        }
        iter.moveToNext();
    }
}
 

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
/**
 * Return next element if exists.
 *
 * @param iter   iterator
 * @param anchor an anchor
 * @return next element if exists or null otherwise
 */
private static Token getNext(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()) {
        Token result = iter.get();
        if (result.equals(anchor)) {
            iter.moveToNext();
            if (iter.isValid()) {
                return iter.get();
            } else {
                return null;
            }
        } else {
            return result;
        }
    } else {
        return null;
    }
}
 

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
private String normalizeSpaceBetween(FSIterator<TokenBase> tbIter, final Token x, final Token y) {
    // X must be before Y
    Preconditions.checkArgument(x == null || y == null || x.getCAS().getAnnotationIndex().compare(x, y) < 0);
    if (x == null) {
        tbIter.moveToFirst();
    } else {
        tbIter.moveTo(x);
    }
    while (// if Y is null then iterate till the end
            (y == null && tbIter.isValid())
                    // else - iterate till the Y
                    || (y != null && !tbIter.get().equals(y))) {
        if (tbIter.get() instanceof BREAK) {
            return "\n";
        }
        tbIter.moveToNext();
    }
    return " ";
}
 

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
/**
 * Get the last sentence CAS address in the current display window
 *
 * @param aJcas
 *            the JCas.
 * @param aFirstSentenceAddress
 *            the CAS address of the first sentence in the display window
 * @param aWindowSize
 *            the window size
 * @return The address of the last sentence address in the current display window.
 */
public static Sentence getLastSentenceInDisplayWindow(JCas aJcas, int aFirstSentenceAddress,
        int aWindowSize)
{
    int count = 0;
    FSIterator<Sentence> si = seekByAddress(aJcas, Sentence.class, aFirstSentenceAddress);
    Sentence s = si.get();
    while (count < aWindowSize - 1) {
        si.moveToNext();
        if (si.isValid()) {
            s = si.get();
        }
        else {
            break;
        }
        count++;
    }

    return s;
}
 

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
private void testChunkUnambiguousStrictSubiterator(JCas testJcas,
		AnnotationIndex<Annotation> annotationIndex) {
	System.out.println("Debug: ---------------------------------------------------------------");

	System.out.println("Debug: unambiguous and strict subiterating all the chunk annotations");
	AnnotationIndex<Annotation> chunkAnnotationIndex = (AnnotationIndex<Annotation>) testJcas.getAnnotationIndex(Chunk.type);
	for (Annotation aChunk : chunkAnnotationIndex) {
		FSIterator<Annotation> chunkSubIterator = annotationIndex.subiterator(aChunk,false,true);
		System.out.println("annotation to subiterate type>"+aChunk.getClass().getName()+"< coveredText>"+aChunk.getCoveredText()+"<");

		while(chunkSubIterator.isValid()) {
			Annotation subAnnotation = chunkSubIterator.get();

			System.out.println("moveToNext subAnnotation type>"+subAnnotation.getClass().getName()+"< coveredText>"+subAnnotation.getCoveredText()+"<");
			chunkSubIterator.moveToNext();
		}
	}
}
 

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
/**
 * @param annotationIndex
 */
private void testNonAmbiguousIterator(
		AnnotationIndex<Annotation> annotationIndex) {
	FSIterator<Annotation> annotationIndexIterator;
	Annotation annotation;
	System.out.println("Debug: ---------------------------------------------------------------");
	System.out.println("Debug: non-ambiguous iteration over an annotation index");
	annotationIndexIterator = annotationIndex.iterator(false);
	annotationIndexIterator.moveToFirst();
	annotation = annotationIndexIterator.get();
	System.out.println("first annotation coveredText>"+annotation.getCoveredText()+"< type>"+annotation.getClass().getName()+"< ");
	annotationIndexIterator.moveToNext();
	while(annotationIndexIterator.isValid()) {
		annotation = annotationIndexIterator.get();
		System.out.println("moveToNext annotation coveredText>"+annotation.getCoveredText()+"< type>"+annotation.getClass().getName()+"<");
		annotationIndexIterator.moveToNext();
	}
}
 

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
/**
 * @param inputViewJCas
 * @param firstChunk
 */
private void testNonAmbiguousIteratorOverAnIndexOfAGivenType(JCas inputViewJCas,
		Annotation firstChunk) {
	AnnotationIndex<Annotation> annotationIndex;
	FSIterator<Annotation> annotationIndexIterator;
	Annotation annotation;
	System.out.println("Debug: ---------------------------------------------------------------");
	System.out.println("Debug: moveTo+ non-ambiguous iteration over an annotation index (of Chunk.type)");
	annotationIndex = (AnnotationIndex<Annotation>) inputViewJCas.getAnnotationIndex(Chunk.type);

	annotationIndexIterator = annotationIndex.iterator(false);
	annotationIndexIterator.moveTo(firstChunk);
	annotation = annotationIndexIterator.get();
	System.out.println("moveTo annotation (first chunk firstly met) coveredText>"+annotation.getCoveredText()+"< type>"+annotation.getClass().getName()+"< ");
	annotationIndexIterator.moveToNext();
	while(annotationIndexIterator.isValid()) {
		annotation = annotationIndexIterator.get();
		System.out.println("moveToNext annotation coveredText>"+annotation.getCoveredText()+"< type>"+annotation.getClass().getName()+"<");
		annotationIndexIterator.moveToNext();
	}
}
 

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
@Override
public void process(JCas jCas) throws AnalysisEngineProcessException {
    String txt = jCas.getDocumentText();
    if (txt == null || txt.isEmpty()) {
        return;
    }
    int txtLength = txt.length();
    AnnotationIndex<Annotation> tokenIndex = jCas
            .getAnnotationIndex(TokenBase.typeIndexID);
    FSIterator<Annotation> tokenIter = tokenIndex.iterator();
    if (!tokenIter.isValid()) {
        makeNTSpan(jCas, 0, txtLength);
    } else {
        int lastTokenEnd = 0;
        while (tokenIter.isValid()) {
            Annotation token = tokenIter.get();
            if (token.getBegin() > lastTokenEnd) {
                makeNTSpan(jCas, lastTokenEnd, token.getBegin());
            }
            lastTokenEnd = token.getEnd();
            //
            tokenIter.moveToNext();
        }
        // check the span after the last token
        if (txtLength > lastTokenEnd) {
            makeNTSpan(jCas, lastTokenEnd, txtLength);
        }
    }
}
 

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
public static boolean areAdjoining(Token t1, Token t2) {
    JCas jCas = getJCas(t1);
    FSIterator<Annotation> tokenIter = jCas.getAnnotationIndex(Token.typeIndexID).iterator();
    tokenIter.moveTo(t1);
    assert (t1.equals(tokenIter.get()));
    tokenIter.moveToNext();
    return tokenIter.isValid() && tokenIter.get().equals(t2);
}
 

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
/**
  * (A code that is borrowed from UIMA-library example)
  * Prints all Annotations to a PrintStream.
  * 
  * @param aCAS
  *          the CAS containing the FeatureStructures to print
  * @param aOut
  *          the PrintStream to which output will be written
  */

public static void printAnnotations(CAS aCAS, PrintStream aOut) {
    // get iterator over annotations
    FSIterator<AnnotationFS> iter = aCAS.getAnnotationIndex().iterator();

    // iterate
    while (iter.isValid()) {
      FeatureStructure fs = iter.get();
      printFS(fs, aCAS, 0, aOut);
      iter.moveToNext();
    }
  }
 

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包/类
public void testGatePOSTagger() throws Exception {
  // load the TAE containing UIMA tokeniser and GATE POS tagger
  File tokAndPOSTaggerDescriptorFile =
    new File(testConfDir, "TokenizerAndPOSTagger.xml");

  XMLInputSource inputSource =
    new XMLInputSource(tokAndPOSTaggerDescriptorFile);

  ResourceSpecifier tokAndPOSTaggerDescriptor =
    uimaXMLParser.parseResourceSpecifier(inputSource);

  AnalysisEngine tokAndPOSTagger =
    UIMAFramework.produceAnalysisEngine(tokAndPOSTaggerDescriptor);

  // create CAS and populate it with initial text.
  CAS cas = tokAndPOSTagger.newCAS();

  cas.setDocumentText(
      "This is a test document. This is the second sentence.");
  // what POS tags do we expect to get back?
  String[] expectedPOSTags = new String[] {
    "DT",    // This
    "VBZ",   // is
    "DT",    // a
    "NN",    // test
    "NN",    // document
    ".",     // .
    "DT",    // This
    "VBZ",   // is
    "DT",    // the
    "JJ",    // second
    "NN",    // sentence
    "."      // .
  };

  // run the beast
  tokAndPOSTagger.process(cas);

  // check the results have the right POS tags
  Type tokenType = cas.getTypeSystem().getType(
      "org.apache.uima.examples.tokenizer.Token");
  assertNotNull("Token type not found in type system", tokenType);

  Feature posFeature = tokenType.getFeatureByBaseName("POS");
  assertNotNull("Token POS feature not found", posFeature);
  
  FSIndex tokensIndex = cas.getAnnotationIndex(tokenType);
  FSIterator tokensIt = tokensIndex.iterator();
  int tokenNo = 0;
  while(tokensIt.isValid()) {
    // make sure we don't have too many tokens
    assertTrue("Found more tokens than expected",
               tokenNo < expectedPOSTags.length);
    FeatureStructure token = tokensIt.get();
    String actualPOS = token.getStringValue(posFeature);
    assertEquals("Token has wrong part of speech",
                 expectedPOSTags[tokenNo], actualPOS);
    tokensIt.moveToNext();
    tokenNo++;
  }

  assertEquals("Found fewer tokens than expected",
               tokenNo, expectedPOSTags.length);
}
 

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
/**
	 * @param testJcas
	 * @param annotationIndex
	 * 
	 * Debug: ---------------------------------------------------------------
Debug: subiterating all the chunk annotations
annotation to subiterate type>common.types.text.Chunk< coveredText>Verne<
moveToNext subAnnotation type>org.apache.uima.examples.SourceDocumentInformation< coveredText><
annotation to subiterate type>common.types.text.Chunk< coveredText>visited<
annotation to subiterate type>common.types.text.Chunk< coveredText>the seaport of Nantes<
moveToNext subAnnotation type>common.types.text.Chunk< coveredText>the seaport<
moveToNext subAnnotation type>common.types.text.Token< coveredText>the<
moveToNext subAnnotation type>common.types.coref.Coreference< coveredText>the<
moveToNext subAnnotation type>common.types.text.Token< coveredText>seaport<
moveToNext subAnnotation type>common.types.coref.Coreference< coveredText>seaport<
moveToNext subAnnotation type>common.types.text.Chunk< coveredText>of Nantes<
moveToNext subAnnotation type>common.types.text.Token< coveredText>of<
moveToNext subAnnotation type>common.types.coref.Coreference< coveredText>of<
moveToNext subAnnotation type>common.types.text.Token< coveredText>Nantes<
moveToNext subAnnotation type>common.types.ne.NamedEntity< coveredText>Nantes<
moveToNext subAnnotation type>common.types.coref.Coreference< coveredText>Nantes<
annotation to subiterate type>common.types.text.Chunk< coveredText>the seaport<
moveToNext subAnnotation type>common.types.text.Token< coveredText>the<
moveToNext subAnnotation type>common.types.coref.Coreference< coveredText>the<
moveToNext subAnnotation type>common.types.text.Token< coveredText>seaport<
moveToNext subAnnotation type>common.types.coref.Coreference< coveredText>seaport<
annotation to subiterate type>common.types.text.Chunk< coveredText>of Nantes<
moveToNext subAnnotation type>common.types.text.Token< coveredText>of<
moveToNext subAnnotation type>common.types.coref.Coreference< coveredText>of<
moveToNext subAnnotation type>common.types.text.Token< coveredText>Nantes<
moveToNext subAnnotation type>common.types.ne.NamedEntity< coveredText>Nantes<
moveToNext subAnnotation type>common.types.coref.Coreference< coveredText>Nantes<
	 */
	private void testChunkSubiterator(JCas testJcas,
			AnnotationIndex<Annotation> annotationIndex) {
		System.out.println("Debug: ---------------------------------------------------------------");

		System.out.println("Debug: ambiguous subiterating all the chunk annotations");
		AnnotationIndex<Annotation> chunkAnnotationIndex = (AnnotationIndex<Annotation>) testJcas.getAnnotationIndex(Chunk.type);
		for (Annotation aChunk : chunkAnnotationIndex) {
			FSIterator<Annotation> chunkSubIterator = annotationIndex.subiterator(aChunk);
			System.out.println("annotation to subiterate type>"+aChunk.getClass().getName()+"< coveredText>"+aChunk.getCoveredText()+"<");

			while(chunkSubIterator.isValid()) {
				Annotation subAnnotation = chunkSubIterator.get();

				System.out.println("moveToNext subAnnotation type>"+subAnnotation.getClass().getName()+"< coveredText>"+subAnnotation.getCoveredText()+"<");
				chunkSubIterator.moveToNext();
			}
		}
	}
 

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
/**
 * @param inputViewJCas
 * @param annotationIndexIterator
 */
private void testTypeSubsumptionConstrainedIterator(JCas inputViewJCas,
		FSIterator<Annotation> annotationIndexIterator) {
	Annotation annotation;
	// -- constrained iterator chunk which words occurs at the same offsets 
	System.out.println("Debug: ---------------------------------------------------------------");
	System.out.println("Debug: constrained iterator chunk which words occurs at the same offsets (do not work since none is the surtype of the other) ; works with tcas.annotation");
	// 
	// Start by getting the constraint factory from the CAS.
	ConstraintFactory cf = inputViewJCas.getConstraintFactory();

	// To specify a path to an item to test, you start by
	// creating an empty path.
	//FeaturePath path = cas.createFeaturePath();

	// Add POS feature to path, creating one-element path.
	//path.addFeature(posFeat);

	// You can extend the chain arbitrarily by adding additional
	// features.

	// Create a new type constraint.  

	// Type constraints will check that structures
	// they match against have a type at least as specific
	// as the type specified in the constraint.
	FSTypeConstraint chunkConstraint = cf.createTypeConstraint();

	// Set the type (by default it is TOP).
	// This succeeds if the type being tested by this constraint
	// is nounType or a subtype of nounType.
	chunkConstraint.add(inputViewJCas.getTypeSystem().getType("common.types.text.Chunk"));


	// Embed the noun constraint under the pos path.
	// This means, associate the test with the path, so it tests the
	// proper value.

	// The result is a test which will
	// match a feature structure that has a posFeat defined
	// which has a value which is an instance of a nounType or
	// one of its subtypes.
	//FSMatchConstraint embeddedNoun = cf.embedConstraint(path, chunkConstraint);

	// Create a type constraint for token (or a subtype of it)
	FSTypeConstraint uimaTCasAnnotationConstraint = cf.createTypeConstraint();

	// Set the type.
	uimaTCasAnnotationConstraint.add(inputViewJCas.getTypeSystem().getType("uima.tcas.Annotation"));

	// Create the final constraint by conjoining the two constraints.
	FSMatchConstraint chunkAndLexicalUnitCons = cf.and(chunkConstraint, uimaTCasAnnotationConstraint);

	// Create a filtered iterator from some annotation iterator.
	FSIterator uimaTCasAnnotationUnitIterator = inputViewJCas.createFilteredIterator(annotationIndexIterator, chunkAndLexicalUnitCons);

	uimaTCasAnnotationUnitIterator.moveToFirst();

	annotation = (Annotation) uimaTCasAnnotationUnitIterator.get();
	System.out.println("first chunkAndLexicalUnitIterator annotation type>"+annotation.getClass().getName()+"< coveredText>"+annotation.getCoveredText()+"<");
	uimaTCasAnnotationUnitIterator.moveToNext();

	while(uimaTCasAnnotationUnitIterator.isValid()) {
		annotation =  (Annotation) uimaTCasAnnotationUnitIterator.get();

		System.out.println("moveToNext chunkAndLexicalUnitIterator annotation type>"+annotation.getClass().getName()+"< coveredText>"+annotation.getCoveredText()+"<");
		uimaTCasAnnotationUnitIterator.moveToNext();
	}
}
 

import org.apache.uima.cas.FSIterator; //导入方法依赖的package包/类
/**
 * @param inputViewJCas
 * @param annotationIndexIterator
 */
private void testSelectSpecificTypesConstrainedIterator(JCas inputViewJCas,
		FSIterator<Annotation> annotationIndexIterator) {
	Annotation annotation;
	// -- constrained iterator chunk which words occurs at the same offsets 
	System.out.println("Debug: ---------------------------------------------------------------");
	System.out.println("Debug: constrained iterator over two types (noun and verb) without inheritance relations");

	// Start by getting the constraint factory from the CAS.
	ConstraintFactory cf = inputViewJCas.getConstraintFactory();

	// Create a new type constraint.  

	// Type constraints will check that structures
	// they match against have a type at least as specific
	// as the type specified in the constraint.
	FSTypeConstraint nounConstraint = cf.createTypeConstraint();

	// Set the type (by default it is TOP).
	// This succeeds if the type being tested by this constraint
	// is nounType or a subtype of nounType.
	nounConstraint.add(inputViewJCas.getTypeSystem().getType("common.types.text.Noun"));


	FSTypeConstraint verbConstraint = cf.createTypeConstraint();

	// Set the type (by default it is TOP).
	// This succeeds if the type being tested by this constraint
	// is nounType or a subtype of nounType.
	verbConstraint.add(inputViewJCas.getTypeSystem().getType("common.types.text.Verb"));



	// Create the final constraint by conjoining the two constraints.
	FSMatchConstraint nounOrVerbConstraint = cf.or(verbConstraint, nounConstraint);

	// Create a filtered iterator from some annotation iterator.
	FSIterator uimaTCasAnnotationUnitIterator = inputViewJCas.createFilteredIterator(annotationIndexIterator, nounOrVerbConstraint);

	uimaTCasAnnotationUnitIterator.moveToFirst();

	annotation = (Annotation) uimaTCasAnnotationUnitIterator.get();
	System.out.println("first nounOrVerbConstraint annotation type>"+annotation.getClass().getName()+"< coveredText>"+annotation.getCoveredText()+"<");
	uimaTCasAnnotationUnitIterator.moveToNext();

	while(uimaTCasAnnotationUnitIterator.isValid()) {
		annotation =  (Annotation) uimaTCasAnnotationUnitIterator.get();

		System.out.println("moveToNext nounOrVerbConstraint annotation type>"+annotation.getClass().getName()+"< coveredText>"+annotation.getCoveredText()+"<");
		uimaTCasAnnotationUnitIterator.moveToNext();
	}
}