Java TypeSystem.subsumes方法代码示例

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
/**
 * {@code FeatureCopier} used for features which are references to {@code FeatureStructure}s.
 *
 * @param fromFeature the {@link Feature}
 * @param fromFs the {@link FeatureStructure} to copy from
 * @param toFs the {@link FeatureStructure} to copy to
 */
private void defaultFeatureMapper(Feature fromFeature, FeatureStructure fromFs,
    FeatureStructure toFs) {
  TypeSystem typeSystem = fromFs.getCAS().getTypeSystem();
  if (typeSystem.subsumes(typeSystem.getType(CAS.TYPE_NAME_STRING), fromFeature.getRange())) {
    STRING_COPIER.copy(fromFeature, fromFs, toFs);
  } else {
    FeatureStructure fromFeatureValue = fromFs.getFeatureValue(fromFeature);
    if (fromFeatureValue != null) {
      FeatureStructure toFeatureValue = fsEncounteredCallback.apply(fromFeatureValue);
      Feature toFeature = toFs.getType().getFeatureByBaseName(fromFeature.getShortName());
      toFs.setFeatureValue(toFeature, toFeatureValue);
    }
  }
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
private static boolean isSlotFeature(TypeSystem aTypeSystem, Feature feat)
{
    // This could be written more efficiently using a single conjunction. The reason this
    // has not been done is to facilitate debugging.
    
    boolean multiValued = feat.getRange().isArray() || aTypeSystem
            .subsumes(aTypeSystem.getType(CAS.TYPE_NAME_LIST_BASE), feat.getRange());
    
    if (!multiValued) {
        return false;
    }
    
    boolean linkInheritsFromTop = CAS.TYPE_NAME_TOP
            .equals(aTypeSystem.getParent(feat.getRange().getComponentType()).getName());
    boolean hasTargetFeature = feat.getRange().getComponentType()
            .getFeatureByBaseName(FEAT_SLOT_TARGET) != null;
    boolean hasRoleFeature = feat.getRange().getComponentType()
            .getFeatureByBaseName(FEAT_SLOT_ROLE) != null;
    
    return linkInheritsFromTop && hasTargetFeature && hasRoleFeature;
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
public static List<Annotation> toList(JCas jCas, Collection<Type> iteratedTypes) {
	List<Annotation> annotations = new ArrayList<>();

	FSIterator<Annotation> it = jCas.getAnnotationIndex().iterator();
	while(it.hasNext()) {
		Annotation a = it.next();
		if(iteratedTypes.isEmpty())
			annotations.add(a);
		else {
			for(Type type:iteratedTypes) {
				TypeSystem typeSystem = jCas.getTypeSystem();
				if(typeSystem.subsumes(type, a.getType())) {
					annotations.add(a);
					break;
				}
			}
		}
	}
	return annotations;
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
@Override
public void typeSystemInit(TypeSystem ts) {
    resultAnnotationType = FSTypeUtils.getType(ts, resultAnnotationClass.getName(), true);
    tagFeature = FSTypeUtils.getFeature(resultAnnotationType, tagFeatureName, true);
    if (!ts.subsumes(ts.getType(CAS.TYPE_NAME_STRING), tagFeature.getRange())) {
        throw new IllegalStateException(String.format(
                "Feature %s can not hold dictionary tags as its range is %s",
                tagFeature, tagFeature.getRange()));
    }
    // TODO describe this in the class javadoc
    firstTokenFeature = FSTypeUtils.getFeature(resultAnnotationType, "firstToken", false);
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
@Override
public boolean match(FeatureStructure ref, FeatureStructure cand) {
    if (!subtypeMatch) {
        return ref.getType().equals(cand.getType());
    } else {
        TypeSystem ts = ref.getCAS().getTypeSystem();
        return ts.subsumes(ref.getType(), cand.getType());
    }
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
public static boolean isValidType(Type type, TypeSystem typeSystem) {
  String typeName = type.getName();
  for (String handledType : HANDLED_TYPES) {
    if (typeName.equals(handledType))
      return true;
  }

  // see section 2.3.4 of UIMA References
  if (typeSystem.subsumes(typeSystem.getType("uima.cas.String"), type))
    return true;
  if (typeSystem.subsumes(typeSystem.getType("uima.tcas.Annotation"), type))
    return true;

  return false;
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
private boolean isAnnotationType(Type t, TypeSystem ts) {
    return ts.subsumes(annotationType, t);
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
/**
 * Configure this ObjectBuilder by extracting the GATE and UIMA types and the
 * feature definitions from the XML element.
 */
public void configure(Element elt, TypeSystem typeSystem)
      throws MappingException {
  annotationType = elt.getAttributeValue("type");
  if(annotationType == null) {
    throw new MappingException("No \"type\" attribute specified for "
        + "gateAnnotation");
  }

  String uimaTypeString = elt.getAttributeValue("uimaType");
  if(uimaTypeString == null) {
    throw new MappingException("No \"uimaType\" attribute specified for "
        + "gateAnnotation");
  }

  uimaType = typeSystem.getType(uimaTypeString);
  if(uimaType == null) {
    throw new MappingException("Type " + uimaTypeString
        + " not found in UIMA type system");
  }

  if(!typeSystem.subsumes(typeSystem.getType(CAS.TYPE_NAME_ANNOTATION),
                          uimaType)) {
    throw new MappingException("Type " + uimaTypeString
        + " is not an annotation type");
  }

  uimaAnnotationBeginFeature = typeSystem.getFeatureByFullName(
       CAS.FEATURE_FULL_NAME_BEGIN);
  if(uimaAnnotationBeginFeature == null) {
    throw new MappingException(CAS.FEATURE_FULL_NAME_BEGIN + " feature not "
        + "found in type system - are you sure CAS is a CAS?");
  }

  uimaAnnotationEndFeature = typeSystem.getFeatureByFullName(
       CAS.FEATURE_FULL_NAME_END);
  if(uimaAnnotationEndFeature == null) {
    throw new MappingException(CAS.FEATURE_FULL_NAME_END + " feature not "
        + "found in type system - are you sure CAS is a CAS?");
  }

  String indexedString = elt.getAttributeValue("indexed");
  indexed = Boolean.valueOf(indexedString).booleanValue();

  // build the list of feature definitions
  List featureElements = elt.getChildren("feature");
  featureDefs = new ArrayList(featureElements.size());

  Iterator featureElementsIt = featureElements.iterator();
  while(featureElementsIt.hasNext()) {
    Element featureElt = (Element)featureElementsIt.next();
    String featureName = featureElt.getAttributeValue("name");
    if(featureName == null) {
      throw new MappingException("feature element must have \"name\" "
          + "attribute specified");
    }

    List children = featureElt.getChildren();
    if(children.isEmpty()) {
      throw new MappingException("feature element must have a child element "
          + "specifying its value");
    }
    Element valueElement = (Element)children.get(0);

    // create the object builder that gives this feature's value
    ObjectBuilder valueBuilder = ObjectManager.createBuilder(valueElement,
                                                             typeSystem);

    featureDefs.add(new FeatureDefinition(featureName, valueBuilder));
  }
}