Java CASImpl类代码示例

import org.apache.uima.cas.impl.CASImpl; //导入依赖的package包/类
private static void forceSetFeatureValue(FeatureStructure aFS, String aFeatureName,
        String aValue)
{
    CASImpl casImpl = (CASImpl) aFS.getCAS().getLowLevelCAS();
    TypeSystemImpl ts = (TypeSystemImpl) aFS.getCAS().getTypeSystem();
    Feature feat = aFS.getType().getFeatureByBaseName(aFeatureName);
    int featCode = ((FeatureImpl) feat).getCode();
    int thisType = ((TypeImpl) aFS.getType()).getCode();
    if (!ts.isApprop(thisType, featCode)) {
        throw new IllegalArgumentException("Feature structure does not have that feature");
    }
    if (!ts.subsumes(ts.getType(CAS.TYPE_NAME_STRING), feat.getRange())) {
        throw new IllegalArgumentException("Not a string feature!");
    }
    casImpl.ll_setStringValue(casImpl.ll_getFSRef(aFS), featCode, aValue);
}
 

import org.apache.uima.cas.impl.CASImpl; //导入依赖的package包/类
public FeatureStructure createFS(int addr, CASImpl cas) {
 if (GoldAspectTarget_Type.this.useExistingInstance) {
   // Return eq fs instance if already created
    FeatureStructure fs = GoldAspectTarget_Type.this.jcas.getJfsFromCaddr(addr);
    if (null == fs) {
      fs = new GoldAspectTarget(addr, GoldAspectTarget_Type.this);
   GoldAspectTarget_Type.this.jcas.putJfsFromCaddr(addr, fs);
   return fs;
    }
    return fs;
   } else return new GoldAspectTarget(addr, GoldAspectTarget_Type.this);
}
 

import org.apache.uima.cas.impl.CASImpl; //导入依赖的package包/类
public FeatureStructure createFS(int addr, CASImpl cas) {
 if (AspectTarget_Type.this.useExistingInstance) {
   // Return eq fs instance if already created
    FeatureStructure fs = AspectTarget_Type.this.jcas.getJfsFromCaddr(addr);
    if (null == fs) {
      fs = new AspectTarget(addr, AspectTarget_Type.this);
   AspectTarget_Type.this.jcas.putJfsFromCaddr(addr, fs);
   return fs;
    }
    return fs;
   } else return new AspectTarget(addr, AspectTarget_Type.this);
}
 

import org.apache.uima.cas.impl.CASImpl; //导入依赖的package包/类
public FeatureStructure createFS(int addr, CASImpl cas) {
 if (CC_Type.this.useExistingInstance) {
   // Return eq fs instance if already created
    FeatureStructure fs = CC_Type.this.jcas.getJfsFromCaddr(addr);
    if (null == fs) {
      fs = new CC(addr, CC_Type.this);
   CC_Type.this.jcas.putJfsFromCaddr(addr, fs);
   return fs;
    }
    return fs;
   } else return new CC(addr, CC_Type.this);
}
 

import org.apache.uima.cas.impl.CASImpl; //导入依赖的package包/类
public FeatureStructure createFS(int addr, CASImpl cas) {
 if (QuestionCategoryAnnotation_Type.this.useExistingInstance) {
   // Return eq fs instance if already created
    FeatureStructure fs = QuestionCategoryAnnotation_Type.this.jcas.getJfsFromCaddr(addr);
    if (null == fs) {
      fs = new QuestionCategoryAnnotation(addr, QuestionCategoryAnnotation_Type.this);
   QuestionCategoryAnnotation_Type.this.jcas.putJfsFromCaddr(addr, fs);
   return fs;
    }
    return fs;
   } else return new QuestionCategoryAnnotation(addr, QuestionCategoryAnnotation_Type.this);
}
 

import org.apache.uima.cas.impl.CASImpl; //导入依赖的package包/类
@Inject
SystemIndexing(CasProcessorFactory casProcessorFactory,
               SystemIndexCasProcessingDelegate.Factory casViewProcessorDelegateFactory,
               Provider<SystemIndexFSProcessorDelegate> systemIndexFSProcessorDelegateProvider,
               @Assisted SystemIndexingSettings systemIndexingSettings,
               @Assisted TypeSystemDescription typeSystemDescription) throws NlpTabException {
    this.casProcessorFactory = casProcessorFactory;
    this.systemIndexFSProcessorDelegateProvider = systemIndexFSProcessorDelegateProvider;

    this.systemIndexingSettings = systemIndexingSettings;

    tuningProperties = new Properties();
    tuningProperties.setProperty(UIMAFramework.JCAS_CACHE_ENABLED, "false");

    resourceManager = UIMAFramework.newDefaultResourceManager();

    CASMgr casMgr = CASFactory.createCAS(CASImpl.DEFAULT_INITIAL_HEAP_SIZE, false);
    try {
        CasCreationUtils.setupTypeSystem(casMgr, typeSystemDescription);
    } catch (ResourceInitializationException e) {
        throw new NlpTabException(e);
    }
    ((CASImpl) casMgr).commitTypeSystem();

    typeSystem = ((CASImpl) casMgr).getTypeSystem();

    TypeFilterLists typeFilterLists = TypeFilterLists.create(TYPE_WHITELIST, new String[]{});
    ImmutableSet<String> typeFilter = TypeFilterBuilder.newBuilder()
            .withTypeSystem(typeSystem)
            .withTypeFilterLists(typeFilterLists)
            .createTypeFilter();
    typeSystemInfo = new TypeSystemInfo(typeSystem, typeFilter);

    InstanceIndexes instanceIndexes = systemIndexingSettings.getInstanceIndexes();
    String systemIndex = systemIndexingSettings.getIndex();
    systemIndexCasViewProcessorDelegate = casViewProcessorDelegateFactory.create(instanceIndexes, systemIndex);
}
 

import org.apache.uima.cas.impl.CASImpl; //导入依赖的package包/类
public FeatureStructure createFS(int addr, CASImpl cas) {
 if (SwanLink_Type.this.useExistingInstance) {
   // Return eq fs instance if already created
    FeatureStructure fs = SwanLink_Type.this.jcas.getJfsFromCaddr(addr);
    if (null == fs) {
      fs = new SwanLink(addr, SwanLink_Type.this);
   SwanLink_Type.this.jcas.putJfsFromCaddr(addr, fs);
   return fs;
    }
    return fs;
   } else return new SwanLink(addr, SwanLink_Type.this);
}
 

import org.apache.uima.cas.impl.CASImpl; //导入依赖的package包/类
public FeatureStructure createFS(int addr, CASImpl cas) {
 if (SwanLabel_Type.this.useExistingInstance) {
   // Return eq fs instance if already created
    FeatureStructure fs = SwanLabel_Type.this.jcas.getJfsFromCaddr(addr);
    if (null == fs) {
      fs = new SwanLabel(addr, SwanLabel_Type.this);
   SwanLabel_Type.this.jcas.putJfsFromCaddr(addr, fs);
   return fs;
    }
    return fs;
   } else return new SwanLabel(addr, SwanLabel_Type.this);
}
 

import org.apache.uima.cas.impl.CASImpl; //导入依赖的package包/类
public FeatureStructure createFS(int addr, CASImpl cas) {
 if (SwanAnnotation_Type.this.useExistingInstance) {
   // Return eq fs instance if already created
    FeatureStructure fs = SwanAnnotation_Type.this.jcas.getJfsFromCaddr(addr);
    if (null == fs) {
      fs = new SwanAnnotation(addr, SwanAnnotation_Type.this);
   SwanAnnotation_Type.this.jcas.putJfsFromCaddr(addr, fs);
   return fs;
    }
    return fs;
   } else return new SwanAnnotation(addr, SwanAnnotation_Type.this);
}
 

import org.apache.uima.cas.impl.CASImpl; //导入依赖的package包/类
public FeatureStructure createFS(int addr, CASImpl cas) {
 if (VerbFeatures_Type.this.useExistingInstance) {
   // Return eq fs instance if already created
    FeatureStructure fs = VerbFeatures_Type.this.jcas.getJfsFromCaddr(addr);
    if (null == fs) {
      fs = new VerbFeatures(addr, VerbFeatures_Type.this);
   VerbFeatures_Type.this.jcas.putJfsFromCaddr(addr, fs);
   return fs;
    }
    return fs;
   } else return new VerbFeatures(addr, VerbFeatures_Type.this);
}
 

import org.apache.uima.cas.impl.CASImpl; //导入依赖的package包/类
public FeatureStructure createFS(int addr, CASImpl cas) {
 if (SEFeature_Type.this.useExistingInstance) {
   // Return eq fs instance if already created
    FeatureStructure fs = SEFeature_Type.this.jcas.getJfsFromCaddr(addr);
    if (null == fs) {
      fs = new SEFeature(addr, SEFeature_Type.this);
   SEFeature_Type.this.jcas.putJfsFromCaddr(addr, fs);
   return fs;
    }
    return fs;
   } else return new SEFeature(addr, SEFeature_Type.this);
}
 

import org.apache.uima.cas.impl.CASImpl; //导入依赖的package包/类
public FeatureStructure createFS(int addr, CASImpl cas) {
 if (Passage_Type.this.useExistingInstance) {
   // Return eq fs instance if already created
    FeatureStructure fs = Passage_Type.this.jcas.getJfsFromCaddr(addr);
    if (null == fs) {
      fs = new Passage(addr, Passage_Type.this);
   Passage_Type.this.jcas.putJfsFromCaddr(addr, fs);
   return fs;
    }
    return fs;
   } else return new Passage(addr, Passage_Type.this);
}
 

import org.apache.uima.cas.impl.CASImpl; //导入依赖的package包/类
public FeatureStructure createFS(int addr, CASImpl cas) {
 if (Segment_Type.this.useExistingInstance) {
   // Return eq fs instance if already created
    FeatureStructure fs = Segment_Type.this.jcas.getJfsFromCaddr(addr);
    if (null == fs) {
      fs = new Segment(addr, Segment_Type.this);
   Segment_Type.this.jcas.putJfsFromCaddr(addr, fs);
   return fs;
    }
    return fs;
   } else return new Segment(addr, Segment_Type.this);
}
 

import org.apache.uima.cas.impl.CASImpl; //导入依赖的package包/类
public FeatureStructure createFS(int addr, CASImpl cas) {
 if (ClassificationAnnotation_Type.this.useExistingInstance) {
   // Return eq fs instance if already created
    FeatureStructure fs = ClassificationAnnotation_Type.this.jcas.getJfsFromCaddr(addr);
    if (null == fs) {
      fs = new ClassificationAnnotation(addr, ClassificationAnnotation_Type.this);
   ClassificationAnnotation_Type.this.jcas.putJfsFromCaddr(addr, fs);
   return fs;
    }
    return fs;
   } else return new ClassificationAnnotation(addr, ClassificationAnnotation_Type.this);
}
 

import org.apache.uima.cas.impl.CASImpl; //导入依赖的package包/类
public FeatureStructure createFS(int addr, CASImpl cas) {
 if (Situation_Type.this.useExistingInstance) {
   // Return eq fs instance if already created
    FeatureStructure fs = Situation_Type.this.jcas.getJfsFromCaddr(addr);
    if (null == fs) {
      fs = new Situation(addr, Situation_Type.this);
   Situation_Type.this.jcas.putJfsFromCaddr(addr, fs);
   return fs;
    }
    return fs;
   } else return new Situation(addr, Situation_Type.this);
}