Examples of org.apache.uima.cas.ConstraintFactory

org.apache.uima.cas.ConstraintFactory
Methods to create {@link org.apache.uima.cas.FSMatchConstraint}s for filtered iterators or other use. A constraint is an object which represents a test or a series of tests joined with "and" or "or". Each test consists of a test predicate plus an optional "path" which specifies how to walk through a chain of references, starting from a feature structure being tested, to reach the value to be tested.
Tests include
- type subsumption --(satisfied if the CAS feature structure being tested is of a specified type (or is a subtype of that type).
- value equality
- for numeric values - range testing
Constraints can be used by calling their "match" method, passing as an argument the value to test. If the constraint includes the "path", the argument is a feature structure; the path specifies how to reach the value to test, starting with the feature structure. Otherwise, the value to test depends on the constraint; for an {@link org.apache.uima.cas.FSIntConstraint}, for instance, the value would be an integer.

  /**
   * Retrieves the annotations in the given span.
   */
  @Override
  public Collection<AnnotationFS> getAnnotation(Type type, Span span) {
    ConstraintFactory cf = getCAS().getConstraintFactory();


    Type annotationType = getCAS().getAnnotationType();


    FeaturePath beginPath = getCAS().createFeaturePath();
    beginPath.addFeature(annotationType.getFeatureByBaseName("begin"));
    FSIntConstraint beginConstraint = cf.createIntConstraint();
    beginConstraint.geq(span.getStart());


    FSMatchConstraint embeddedBegin = cf.embedConstraint(beginPath, beginConstraint);


    FeaturePath endPath = getCAS().createFeaturePath();
    endPath.addFeature(annotationType.getFeatureByBaseName("end"));
    FSIntConstraint endConstraint = cf.createIntConstraint();
    endConstraint.leq(span.getEnd());


    FSMatchConstraint embeddedEnd = cf.embedConstraint(endPath, endConstraint);


    FSMatchConstraint strictType = new StrictTypeConstraint(type);


    FSMatchConstraint annotatioInSpanConstraint = cf.and(embeddedBegin, embeddedEnd);


    FSMatchConstraint annotationInSpanAndStrictTypeConstraint =
            cf.and(annotatioInSpanConstraint, strictType);


    FSIndex<AnnotationFS> allAnnotations = getCAS().getAnnotationIndex(type);


    FSIterator<AnnotationFS> annotationInsideSpanIndex =
            getCAS().createFilteredIterator(allAnnotations.iterator(),

View Full Code Here

      token.setFeatureValue(tokenTypeFeat, eosFS);
      cas.getIndexRepository().addFS(token);


      FSIterator it = cas.getAnnotationIndex(tokenType).iterator();


      ConstraintFactory cf = this.cas.getConstraintFactory();
      FSTypeConstraint tc = cf.createTypeConstraint();
      tc.add(sepType);
      tc.add(eosType.getName());
      ArrayList path = new ArrayList();
      path.add(tokenTypeFeat.getShortName());
      FSMatchConstraint cons = cf.embedConstraint(path, tc);
      it = this.cas.createFilteredIterator(it, cons);
      int count = 0;
      for (it.moveToFirst(); it.isValid(); it.moveToNext()) {
        ++count;
      }

View Full Code Here

   * @return
   */
  public FSIterator<Annotation> createFilteredIterator(
      int problemBegin, int problemEnd, Type sentenceType)
  {
    ConstraintFactory cf = jcas.getConstraintFactory();
    TypeSystem ts = jcas.getTypeSystem();
    Iterator<Type> it = ts.getTypeIterator();
    //Type annotationType = ts.getType(Annotation.class.getName()); // this returns "org.apache.uima.tcas.Annotation" which isn't in type system
    Type annotationType = ts.getType("uima.tcas.Annotation"); // should be safe to hard code this
    //System.err.println("annotation type: " + annotationType);
    Feature sentenceBeginFeature = annotationType.getFeatureByBaseName("begin");
    FeaturePath sentenceBeginFeaturePath = jcas.createFeaturePath();
    sentenceBeginFeaturePath.addFeature(sentenceBeginFeature);
    
    Feature sentenceEndFeature = annotationType.getFeatureByBaseName("end");
    FeaturePath sentenceEndFeaturePath = jcas.createFeaturePath();
    sentenceEndFeaturePath.addFeature(sentenceEndFeature);
    
    FSMatchConstraint beginAndEnd = constructConstraintByBeginEnd(
        problemBegin, problemEnd, cf, sentenceBeginFeaturePath,
        sentenceEndFeaturePath);
    
    
    FSTypeConstraint sentenceTypeConstraint = cf.createTypeConstraint();
    sentenceTypeConstraint.add(sentenceType);
    
    FSMatchConstraint beginAndEndAndType = cf.and(beginAndEnd, sentenceTypeConstraint);
    
    FSIterator<Annotation> filteredIterator =
        jcas.createFilteredIterator(jcas.getAnnotationIndex().iterator(),  beginAndEndAndType);
    return filteredIterator;
  }

View Full Code Here

0 1 2

TOP

Related Classes of org.apache.uima.cas.ConstraintFactory

org.apache.ctakes.assertion.medfacts.i2b2.api.ConstraintConstructor

org.apache.ctakes.core.util.FSUtil

org.apache.uima.cas.impl.ConstraintFactoryImpl

org.apache.uima.cas.test.FilteredIteratorTest

org.apache.uima.caseditor.core.uima.DocumentUimaImpl

org.apache.uima.caseditor.editor.AnnotationEditor

org.apache.uima.caseditor.editor.DocumentUimaImpl

org.apache.uima.ruta.rule.RutaTypeMatcher

org.apache.uima.ruta.rule.WildCardRuleElement

org.apache.uima.ruta.RutaStream

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.