Examples of org.apache.uima.analysis_engine.ResultSpecification

org.apache.uima.analysis_engine.ResultSpecification
A ResultSpecification is a set of desired outputs from a Analysis Engine or Annotator. Each output is a reference to either a {@link org.apache.uima.cas.Type} or a{@link org.apache.uima.cas.Feature}.
Annotator implementations may, but are not required to, check the ResultSpecification passed as a parameter to their {@link AnalysisComponent#setResultSpecification(ResultSpecification)}}, and produce only those Types and Features that are part of the ResultSpecification. Annotators can call the {@link #containsType(String)} and{@link #containsFeature(String)} to determine which types and features belong to thisResultSpecification and should be produced.
The containsType(...) method also returns true for subtypes of types specified in the result specification. The containsFeature(...) method also returns true for all features of a type if the type's allAnnotatorFeatures flag is set. As a corner case, the containsFeature may return true in this case even if the feature is not actually part of the type system.
ResultSpecifications are language enabled to allow different values to be set and returned, based on a ISO language identifier. There are two styles of the get and add methods that add these specifications to an instance of a ResultSpecification: one takes an additional parameter specifying the language(s), the other doesn't have this parameter. Using the one without the language parameter is equivalent to using the "x-unspecified" language. The functions that add ResultSpecifications can do this for multiple languages at once because the language parameter is an array of strings. The functions to retrieve a ResultSpecification specify one particular language.
Result Specifications for particular types or features have an associated set of languages which they are set for. That associated set of languages can include the "x-unspecified" language; if it does, then a query for that feature for any language will match.
If a type or feature's set of languages does not include "x-unspecified", then a query using "x-unspecified" (either as the language passed, or by default, if no language is passed) returns false.
A result specification entry having a language set may contain languages with country codes, such as zh-cn for example. A query for zh-cn would match, but a query for zh would not match, if this entry only had the zh-cn language specified.
But, a result specification entry having a language set containing just zh will match queries that specify zh-cn as the language, because a result-specification of zh is implied to mean the language zh regardless of the country.
Sometimes the methods to change the result specification replace the language(s), other times, the language(s) are merged with any existing specification already present in the result specification for the particular type or feature.
- Methods to "set" result types and/or features (or both) replace the current settings, for all languages.
- Methods to "add" 1 type or feature, with no language(s) specified replace the current language setting for that type or feature with x-unspecified, except for the following 2 methods
- Methods addResultType and addFeatureType, with languages specified, augment any existing languages that might already be specified for that type or feature.
Prior to any querying using the containsType or containsFeature methods, the type system in use for this result specification may be specified by calling setTypeSystem(typeSystem). If it is available, the results of the containsType and containsFeature methods will be true for subtypes of the original types. The language specification in the ResultSpecification for a derived sub type is computed as the union of all of the langauges specified for its supertypes. Likewise, the The allAnnotatorFeatures flag of a subtype is the logical union of this property for all of its supertypes.
The computation to enable this behavior for subtypes is called "compiling" the result specification, and is done automatically, but only when needed, and when there is an available type system specified for this result specification object, using the setTypeSystem or compile methods. The result of this computation is "cached". If the result specification is subsequently updated in such a way as to make this computation invalid, the cache is invalidated, and another compile operation will be transparently done, when and if needed.


    // do proper typecasts and call process method
    try {
      if (mAnnotator instanceof TextAnnotator) {
        CAS cas = (CAS) aCAS;
        ResultSpecification rs = getResultSpecForLanguage(cas.getDocumentLanguage());
        rs.setTypeSystem(cas.getTypeSystem());
        ((TextAnnotator) mAnnotator).process(cas, rs);
      } else if (mAnnotator instanceof JTextAnnotator) {
        JCas jcas = (JCas) aCAS;
        ResultSpecification rs = getResultSpecForLanguage(jcas.getDocumentLanguage());
        rs.setTypeSystem(jcas.getTypeSystem());
        ((JTextAnnotator) mAnnotator).process(jcas, rs);
      } else if (mAnnotator instanceof GenericAnnotator) {
        mDefaultResultSpecification.setTypeSystem(((CAS) aCAS).getTypeSystem());
        ((GenericAnnotator) mAnnotator).process((CAS) aCAS, mDefaultResultSpecification);
      }

View Full Code Here

   * @param language
   * @return
   */
  private ResultSpecification getResultSpecForLanguage(String language) {
    // we cache this since it is called for each document
    ResultSpecification rs = (ResultSpecification) mLanguageToResultSpecMap.get(language);
    if (rs == null) {
      TypeOrFeature[] tofs = mDefaultResultSpecification.getResultTypesAndFeatures(language);
      if (tofs.length > 0) {
        rs = UIMAFramework.getResourceSpecifierFactory().createResultSpecification();
        rs.setResultTypesAndFeatures(tofs);
      } else {
        // special case: if annotator lists no outputs for this language, all it
        // with all possible outputs. This is mainly for backwards compatibility,
        // but here's a rationalization: the FlowController wants us to invoke the
        // annotator, so calling it with no outputs doesn't really make sense.

View Full Code Here

    // does nothing by default (for service adapters)
    // overridden in both primitive and aggregate AE implementations
  }


  public void resetResultSpecificationToDefault() {
    ResultSpecification resultSpec = new ResultSpecification_impl();
    resultSpec.addCapabilities(this.getAnalysisEngineMetaData().getCapabilities());
    setResultSpecification(resultSpec);
  }

View Full Code Here

      casImpl.reinit(serializer);


      // 2. create result spec
      if (ae != null) {


        ResultSpecification rs = ae.createResultSpecification(casImpl.getTypeSystem());
        for (int i = 0; i < resultSpecTypes.length; ++i) {
          // allAnnotatorFeatures is not considere here! (TODO)
          rs
                  .addResultType(casImpl.getTypeSystemImpl().ll_getTypeForCode(resultSpecTypes[i]).getName(),
                          false);
        }
        for (int i = 0; i < resultSpecFeatures.length; ++i) {
          rs.addResultFeature(casImpl.getTypeSystemImpl().ll_getFeatureForCode(resultSpecFeatures[i])
                  .getName());
        }
        // 3. call process with cas
        ae.process(casImpl, rs);

View Full Code Here

    ae.process(tcas);
    assertEquals("new test", TestAnnotator.lastDocument);
    tcas.reset();


    // process(CAS,ResultSpecification)
    ResultSpecification resultSpec = new ResultSpecification_impl(tcas.getTypeSystem());
    resultSpec.addResultType("NamedEntity", true);


    tcas.setDocumentText("testing...");
    ae.process(tcas, resultSpec);
    assertEquals("testing...", TestAnnotator.lastDocument);
    assertEquals(resultSpec, TestAnnotator.lastResultSpec);

View Full Code Here

              .parseAnalysisEngineDescription(
                      new XMLInputSource(JUnitExtension.getFile("SequencerTest/Annotator1.xml")));
      PrimitiveAnalysisEngine_impl ae = (PrimitiveAnalysisEngine_impl) UIMAFramework
              .produceAnalysisEngine(aeDesc);
      CAS cas = ae.newCAS();
      ResultSpecification resultSpec = new ResultSpecification_impl();
      resultSpec.addResultType("uima.tt.TokenLikeAnnotation", true);
      resultSpec.setTypeSystem(cas.getTypeSystem());
      ResultSpecification acResultSpec = ae.computeAnalysisComponentResultSpec(resultSpec, ae
              .getAnalysisEngineMetaData().getCapabilities());
      assertTrue(acResultSpec.containsType("uima.tt.TokenAnnotation"));
      assertFalse(acResultSpec.containsType("uima.tt.SentenceAnnotation"));
      assertFalse(acResultSpec.containsType("uima.tt.Lemma"));
    } catch (Exception e) {
      JUnitExtension.handleException(e);
    }
  }

View Full Code Here

      String rsXml = writer.getBuffer().toString();
      // System.out.println(rsXml);


      // parse object back from XML
      InputStream is = new ByteArrayInputStream(rsXml.getBytes());
      ResultSpecification newRS = UIMAFramework.getXMLParser().parseResultSpecification(
              new XMLInputSource(is, null));
      TypeOrFeature[] tofs = newRS.getResultTypesAndFeatures();
      Arrays.sort(tofs);
      newRS.setResultTypesAndFeatures(tofs);
      Assert.assertEquals(rs, newRS);
    } catch (Exception e) {
      JUnitExtension.handleException(e);
    }
  }

View Full Code Here

      
      //Check TestAnnotator fields only at the very end of processing,
      //we can't test from the threads themsleves since the state of
      //these fields is nondeterministic during the multithreaded processing.
      assertEquals("testing...", TestAnnotator.getLastDocument());
      ResultSpecification lastResultSpec = TestAnnotator.getLastResultSpec();
      ResultSpecification resultSpec = new ResultSpecification_impl(lastResultSpec.getTypeSystem());
      resultSpec.addResultType("NamedEntity", true);
      assertEquals(resultSpec, lastResultSpec);


    } catch (Exception e) {
      JUnitExtension.handleException(e);
    }

View Full Code Here

    tae.process(tcas);
    assertEquals("new test", TestAnnotator.lastDocument);
    tcas.reset();


    // process(CAS,ResultSpecification)
    ResultSpecification resultSpec = new ResultSpecification_impl(tcas.getTypeSystem());
    resultSpec.addResultType("NamedEntity", true);


    tcas.setDocumentText("testing...");
    tae.process(tcas, resultSpec);
    assertEquals("testing...", TestAnnotator.lastDocument);
    assertEquals(resultSpec, TestAnnotator.lastResultSpec);

View Full Code Here

   */
  protected List<AnalysisSequenceCapabilityNode> computeSequence(String language, Capability[] aCapabilities) {
    language = Language.normalize(language);  // lower-cases, replaces _ with -, changes null to x-unspecified


    // create resultSpec from the current aggregate capabilities
    ResultSpecification aggrResultsToProduce = UIMAFramework.getResourceSpecifierFactory()
            .createResultSpecification();


    if (aCapabilities != null) {
      aggrResultsToProduce.addCapabilities(aCapabilities);
    } else {
      return null;
    }


    // create array list for the current sequence
    List<AnalysisSequenceCapabilityNode> newSequence = new ArrayList<AnalysisSequenceCapabilityNode>();


    // loop over all annotators that should be called
    // In this loop we will gradually reduce the set of output capabilities 
    for (int sequenceIndex = 0; sequenceIndex < mStaticSequence.size(); sequenceIndex++) {
      // get array of output capabilities for the current language from the current result spec
      TypeOrFeature[] tofsNeeded = aggrResultsToProduce.getResultTypesAndFeatures(language);


      // Augment these outputCapabilities if the language-spec is for a country, to 
      // include the outputCapabilities for the language without the country-spec.
      
      // strip language extension if available
      int index = language.indexOf(LANGUAGE_SEPARATOR);


      // if country extension is available
      if (index >= 0) {
        // create Set for outputSpecs, so we can eliminate duplicates
        Set<TypeOrFeature> outputSpec = new HashSet<TypeOrFeature>();


        // add language with country extension removed, 
        // to the existing output capabilities (or if non exist, just use
        // the capabilities for the language without the country extension)
        if (tofsNeeded.length > 0) {
          // copy all existing capabilities to the Set
          for (TypeOrFeature outputCapability : tofsNeeded) {
            outputSpec.add(outputCapability);
          }


          // get array of output capabilities only for the language without country extension
          tofsNeeded = aggrResultsToProduce.getResultTypesAndFeatures(language.substring(0, index));


          // add language output capabilities to the Set
          for (TypeOrFeature outputCapability : tofsNeeded) {
            outputSpec.add(outputCapability);
          }


          // convert all output capabilities to a outputCapabilities array
          tofsNeeded = new TypeOrFeature[outputSpec.size()];
          outputSpec.toArray(tofsNeeded);
        } else { // for language with country extension was noting found        
          // get array of output capabilities with the new main language without country extension
          tofsNeeded = aggrResultsToProduce.getResultTypesAndFeatures(language.substring(0, index));
        }
      }


      // current analysis node which contains the current analysis engine
      AnalysisSequenceCapabilityNode node;


      // result spec for the current analysis engine
      ResultSpecification currentAnalysisResultSpec = null;


      // flag if current analysis engine should be called or not
      boolean shouldEngineBeCalled = false;


      // check output capabilites from the current result spec


      // get next analysis engine from the sequence node
      node = mStaticSequence.get(sequenceIndex);


      // get capability container from the current analysis engine
      ResultSpecification delegateProduces = node.getCapabilityContainer();


      // create current analysis result spec without any language information
      currentAnalysisResultSpec = UIMAFramework.getResourceSpecifierFactory()
              .createResultSpecification();


      // check if engine should be called - 
      //   loop over all remaining ouput capabilities of the aggregate's result spec
      //     to see if this component of the aggregate produces that type or feature,
      //     for this language
      for (TypeOrFeature tof : tofsNeeded) {
        if ((tof.isType() && delegateProduces.containsType(tof.getName(), language)) ||
            (!tof.isType() && delegateProduces.containsFeature(tof.getName(), language))) {
//        if (capabilityContainer.hasOutputTypeOrFeature(tof, language, true)) {
          currentAnalysisResultSpec.addResultTypeOrFeature(tof);
          shouldEngineBeCalled = true;
          // remove current ToF from the result spec
          aggrResultsToProduce.removeTypeOrFeature(tof);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.uima.analysis_engine.ResultSpecification

org.apache.uima.analysis_engine.asb.impl.ASB_impl$AggregateCasIterator

org.apache.uima.analysis_engine.impl.AggregateAnalysisEngine_impl

org.apache.uima.analysis_engine.impl.AnalysisEngine_implTest

org.apache.uima.analysis_engine.impl.AnalysisEngineImplBase

org.apache.uima.analysis_engine.impl.compatibility.AnnotatorAdapter

org.apache.uima.analysis_engine.impl.MultiprocessingAnalysisEngine_implTest

org.apache.uima.analysis_engine.impl.MultiprocessingAnalysisEngine_implTest$ProcessThread

org.apache.uima.analysis_engine.impl.MultiprocessingAnalysisEngine_implTest$ProcessThreadMany

org.apache.uima.analysis_engine.impl.PrimitiveAnalysisEngine_impl

org.apache.uima.analysis_engine.impl.ResultSpecification_implTest

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.