Java TypeSystem.getType方法代码示例

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
CASDocument(@Nullable LabelAdapters labelAdapters, CAS cas) {
  this.labelAdapters = labelAdapters;
  this.cas = cas;

  TypeSystem typeSystem = cas.getTypeSystem();
  metadataType = typeSystem
      .getType("edu.umn.biomedicus.uima.type1_5.DocumentMetadata");
  keyFeature = metadataType.getFeatureByBaseName("key");
  valueFeature = metadataType.getFeatureByBaseName("value");

  metadata = cas.getView("metadata");
  Type idType = typeSystem
      .getType("edu.umn.biomedicus.uima.type1_5.DocumentId");
  Feature idFeat = idType.getFeatureByBaseName("documentId");
  documentId = metadata.getIndexRepository()
      .getAllIndexedFS(idType)
      .get()
      .getStringValue(idFeat);
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
@Nullable
AnnotationFS getAnnotation(CAS cas, int begin, int end, int value) {
  if (begin < 0) {
    throw new IllegalArgumentException("Begin: " + begin + "before 0.");
  }

  if (end < begin) {
    throw new IllegalArgumentException(
        annotationClassName + " - illegal annotation span at begin: " + begin
            + " end: " + end);
  }

  if (!zeroLengthEmitted && end == begin) {
    return null;
  }

  TypeSystem typeSystem = cas.getTypeSystem();
  Type type = typeSystem.getType(annotationClassName);
  AnnotationFS annotation = cas.createAnnotation(type, begin, end);
  if (valueIncluded) {
    Feature valueFeature = type.getFeatureByBaseName("value");
    annotation.setIntValue(valueFeature, value);
  }
  return annotation;
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
/**
 * Default constructor, initializes all fields.
 *
 * @param destinationView The view to write to.
 * @param casMappings The property cas mappings
 * @param annotationTypeForControlWord The annotation type to create for control words.
 */
CasOutputDestination(CAS destinationView,
    List<PropertyCasMapping> casMappings,
    Map<String, Type> annotationTypeForControlWord,
    String name) {
  this.destinationView = destinationView;
  this.sofaBuilder = new StringBuilder();
  this.completedAnnotations = new ArrayList<>();
  this.annotationPropertyWatchers = casMappings.stream()
      .map(AnnotationPropertyWatcher::new)
      .collect(Collectors.toList());
  this.annotationTypeForControlWord = annotationTypeForControlWord;
  this.name = name;
  TypeSystem typeSystem = destinationView.getTypeSystem();
  illegalCharType = typeSystem
      .getType("edu.umn.biomedicus.type.IllegalXmlCharacter");
  valueFeat = illegalCharType.getFeatureByBaseName("value");
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
public static Type getType(TypeSystem ts, Object value) {
	if (value instanceof String)
		return ts.getType(CAS.TYPE_NAME_STRING);
	if (value instanceof Integer)
		return ts.getType(CAS.TYPE_NAME_INTEGER);
	if (value instanceof Float)
		return ts.getType(CAS.TYPE_NAME_FLOAT);
	if (value instanceof Byte)
		return ts.getType(CAS.TYPE_NAME_BYTE);
	if (value instanceof Short)
		return ts.getType(CAS.TYPE_NAME_SHORT);
	if (value instanceof Long)
		return ts.getType(CAS.TYPE_NAME_LONG);
	if (value instanceof Double)
		return ts.getType(CAS.TYPE_NAME_DOUBLE);
	if (value instanceof Boolean)
		return ts.getType(CAS.TYPE_NAME_BOOLEAN);
	if (value instanceof FeatureStructure)
		return ((FeatureStructure)value).getType();
	return null;

}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
@Override
public void typeSystemInit(TypeSystem ts) throws AnalysisEngineProcessException {
    super.typeSystemInit(ts);
    //
    tokenType = ts.getType(tokenTypeName);
    annotationTypeExist(tokenTypeName, tokenType);
    //
    encodeTypesMap = Maps.newHashMap();
    for (int i = 0; i < encodeTypeNames.size(); i++) {
        String etn = encodeTypeNames.get(i);
        Type et = ts.getType(etn);
        annotationTypeExist(etn, et);
        //
        String etLabel = encodeTypeLabels != null ? encodeTypeLabels.get(i) : getTypeLabel(et);
        encodeTypesMap.put(et, etLabel);
    }
    encodeTypesMap = ImmutableMap.copyOf(encodeTypesMap);
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
@Override
public void typeSystemInit(TypeSystem ts) {
    tag2TypeMap = Maps.newHashMap();
    for (int i = 0; i < pTags.length; i++) {
        String tag = pTags[i];
        String relTypeName = pTypes[i];
        String typeName;
        if (baseNamespace != null) {
            typeName = baseNamespace + "." + relTypeName;
        } else {
            typeName = relTypeName;
        }
        Type type = ts.getType(typeName);
        try {
            AnnotatorUtils.annotationTypeExist(typeName, type);
        } catch (AnalysisEngineProcessException e) {
            throw new IllegalStateException(e);
        }
        tag2TypeMap.put(tag, type);
    }
    tag2TypeMap = ImmutableMap.copyOf(tag2TypeMap);
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
@Override
public void typeSystemInit(TypeSystem aTypeSystem)
        throws AnalysisEngineProcessException
{
    super.typeSystemInit(aTypeSystem);

    tokenType = aTypeSystem.getType(Token.class.getName());
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
public static Type getAnnotationType(TypeSystem ts) {
    Type result = ts.getType(ANNOTATION_TYPE_NAME);
    if (result == null) {
        throw new IllegalStateException();
    }
    return result;
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
public static Type getType(TypeSystem ts, String typeName, boolean mustExist) {
    Type result = ts.getType(typeName);
    if (result == null && mustExist) {
        throw new IllegalArgumentException(String.format(
                "Type %s does not exist", typeName));
    }
    return result;
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
@Override
public void typeSystemInit(TypeSystem ts) throws AnalysisEngineProcessException {
    super.typeSystemInit(ts);
    //
    targetType = ts.getType(targetTypeName);
    AnnotatorUtils.annotationTypeExist(targetTypeName, targetType);
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
@Override
public void typeSystemInit(TypeSystem ts) throws AnalysisEngineProcessException {
    super.typeSystemInit(ts);
    //
    coveringAnnoType = ts.getType(coveringAnnoTypeName);
    AnnotatorUtils.annotationTypeExist(coveringAnnoTypeName, coveringAnnoType);
    //
    annoToDeleteType = ts.getType(annoToDeleteTypeName);
    AnnotatorUtils.annotationTypeExist(annoToDeleteTypeName, annoToDeleteType);
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
@Override
public void typeSystemInit(TypeSystem aTypeSystem)
        throws AnalysisEngineProcessException {
    unitType = aTypeSystem.getType(UnitAnnotator.UNIT_TYPE_NAME);
    classFeature = unitType.getFeatureByBaseName(CLASS_FEAT_NAME);
    for (String classTypeName : classTypeNames) {
        classTypes.add(aTypeSystem.getType(classTypeName));
    }
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
@Override
public void typeSystemInit(TypeSystem aTypeSystem)
        throws AnalysisEngineProcessException {
    unitType = aTypeSystem.getType(UNIT_TYPE_NAME);
    for (String unitTypeName : unitTypeNames) {
        unitTypes.add(aTypeSystem.getType(unitTypeName));
    }
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public UimaBratMappingInitializer(TypeSystem ts,
                                  List<EntityDefinitionValue> entityDefinitions,
                                  List<StructureDefinitionValue> relationDefinitions,
                                  List<StructureDefinitionValue> eventDefinitions,
                                  List<NoteMapperDefinitionValue> noteMapperDefinitions)
        throws AnalysisEngineProcessException {
    this.ts = ts;
    this.entityDefinitions = entityDefinitions;
    this.relationDefinitions = relationDefinitions;
    this.eventDefinitions = eventDefinitions;
    //
    type2NoteMapper = Maps.newHashMap();
    for (NoteMapperDefinitionValue ndv : noteMapperDefinitions) {
        Type type = ts.getType(ndv.uimaType);
        annotationTypeExist(ndv.uimaType, type);
        if (type2NoteMapper.containsKey(type)) {
            throw new IllegalStateException(String.format(
                    "Duplicate note mapper declaration for %s", type));
        }
        Class<? extends BratNoteMapper> noteMapperClass;
        try {
            noteMapperClass = (Class<? extends BratNoteMapper>) Class
                    .forName(ndv.mapperClassName);
            // create instance
            BratNoteMapper mapperInstance = noteMapperClass.newInstance();
            // initialize via interface method
            mapperInstance.typeSystemInit(ts);
            // memorize
            type2NoteMapper.put(type, mapperInstance);
        } catch (Exception e) {
            throw new IllegalStateException(String.format(
                    "Can't initialize note mapper for %s", type), e);
        }
    }
}
 

import org.apache.uima.cas.TypeSystem; //导入方法依赖的package包/类
@Override
public void typeSystemInit(TypeSystem ts) throws AnalysisEngineProcessException {
    Type cityType = ts.getType(CITY_TYPE_NAME);
    annotationTypeExist(CITY_TYPE_NAME, cityType);
    longFeat = featureExist(cityType, "longitude");
    latFeat = featureExist(cityType, "latitude");
}