Java CachedValuesManager.createCachedValue方法代码示例

import com.intellij.psi.util.CachedValuesManager; //导入方法依赖的package包/类
@Nullable
public T getCachedValue(final @NotNull H dataHolder) {
  CachedValue<T> cachedValue = dataHolder.getUserData(myKey);
  if (cachedValue == null) {
    final CachedValueProvider<T> myProvider = new CachedValueProvider<T>() {
      @Override
      @Nullable
      public Result<T> compute() {
        return computeValue(dataHolder);
      }
    };
    final CachedValuesManager manager = CachedValuesManager.getManager(myProject);
    cachedValue = manager.createCachedValue(myProvider, false);
    dataHolder.putUserData(myKey, cachedValue);
  }
  return cachedValue.getValue();
}
 

import com.intellij.psi.util.CachedValuesManager; //导入方法依赖的package包/类
public static Schema getCachedSchema(final XmlFile descriptorFile) {
  CachedValue<Schema> value = descriptorFile.getUserData(SCHEMA_KEY);
  if (value == null) {
    final CachedValueProvider<Schema> provider = new CachedValueProvider<Schema>() {
      @Override
      public Result<Schema> compute() {
        final InputSource inputSource = makeInputSource(descriptorFile);

        try {
          final Schema schema = new MySchemaReader(descriptorFile).createSchema(inputSource, EMPTY_PROPS);
          final PsiElementProcessor.CollectElements<XmlFile> processor = new PsiElementProcessor.CollectElements<XmlFile>();
          RelaxIncludeIndex.processForwardDependencies(descriptorFile, processor);
          if (processor.getCollection().size() > 0) {
            return Result.create(schema, processor.toArray(), descriptorFile);
          } else {
            return Result.createSingleDependency(schema, descriptorFile);
          }
        } catch (Exception e) {
          LOG.info(e);
          return Result.createSingleDependency(null, descriptorFile);
        }
      }
    };

    final CachedValuesManager mgr = CachedValuesManager.getManager(descriptorFile.getProject());
    value = mgr.createCachedValue(provider,  false);
    descriptorFile.putUserData(SCHEMA_KEY, value);
  }
  return value.getValue();
}
 

import com.intellij.psi.util.CachedValuesManager; //导入方法依赖的package包/类
@Nullable
public static Map<String, Set<Define>> getAllVariants(Grammar scope) {
  final PsiElement psiElement = scope.getPsiElement();
  if (psiElement == null || !psiElement.isValid()) return null;

  final CachedValuesManager manager = CachedValuesManager.getManager(psiElement.getProject());
  CachedValue<Map<String, Set<Define>>> data = psiElement.getUserData(KEY);
  if (data == null || !((DefinitionResolver)data.getValueProvider()).isValid()) {
    final DefinitionResolver resolver = new DefinitionResolver(scope);
    data = manager.createCachedValue(resolver, false);
    psiElement.putUserData(KEY, data);
  }
  return data.getValue();
}
 

import com.intellij.psi.util.CachedValuesManager; //导入方法依赖的package包/类
@Override
public XmlFile getSchema(@NotNull @NonNls String url, @Nullable final Module module, @NotNull PsiFile baseFile) {
  if (module == null || AndroidFacet.getInstance(module) == null) return null;

  Map<String, CachedValue<XmlFile>> descriptors = module.getUserData(DESCRIPTORS_MAP_IN_MODULE);
  if (descriptors == null) {
    descriptors = new THashMap<String, CachedValue<XmlFile>>();
    module.putUserData(DESCRIPTORS_MAP_IN_MODULE, descriptors);
  }
  CachedValue<XmlFile> reference = descriptors.get(url);
  if (reference != null) {
    return reference.getValue();
  }
  CachedValuesManager manager = CachedValuesManager.getManager(module.getProject());
  reference = manager.createCachedValue(new CachedValueProvider<XmlFile>() {
    @Override
    public Result<XmlFile> compute() {
      final URL resource = AndroidXmlSchemaProvider.class.getResource("android.xsd");
      final VirtualFile fileByURL = VfsUtil.findFileByURL(resource);
      XmlFile result = (XmlFile)PsiManager.getInstance(module.getProject()).findFile(fileByURL).copy();
      return new Result<XmlFile>(result, PsiModificationTracker.MODIFICATION_COUNT);
    }
  }, false);

  descriptors.put(url, reference);
  return reference.getValue();
}