Java CachedValuesManager.getManager方法代码示例

import com.intellij.psi.util.CachedValuesManager; //导入方法依赖的package包/类
@Override
public Object invoke(final DomInvocationHandler<?, ?> handler, final Object[] args) throws Throwable {
  if (myConverter == Converter.EMPTY_CONVERTER) {
    return getValueInner(handler, myConverter);
  }

  CachedValue<List<Pair<Converter,Object>>> value = handler.getUserData(DOM_VALUE_KEY);
  if (value == null) {
    final DomManagerImpl domManager = handler.getManager();
    final Project project = domManager.getProject();
    final CachedValuesManager cachedValuesManager = CachedValuesManager.getManager(project);
    handler.putUserData(DOM_VALUE_KEY, value = cachedValuesManager.createCachedValue(new CachedValueProvider<List<Pair<Converter,Object>>>() {
      @Override
      public Result<List<Pair<Converter,Object>>> compute() {
        List<Pair<Converter, Object>> list = ContainerUtil.createLockFreeCopyOnWriteList();
        return Result
          .create(list, PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, domManager, ProjectRootManager.getInstance(project));
      }
    }, false));
  }

  return getOrCalcValue(handler, value.getValue());
}
 

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 PropertiesFile getPropertiesFile(final PsiFile file) {
  CachedValuesManager manager = CachedValuesManager.getManager(file.getProject());
  if (file instanceof XmlFile) {
    return manager.getCachedValue(file, KEY,
                                  new CachedValueProvider<PropertiesFile>() {
                                    @Override
                                    public Result<PropertiesFile> compute() {
                                      PropertiesFile value =
                                        XmlPropertiesIndex.isPropertiesFile((XmlFile)file)
                                        ? new XmlPropertiesFileImpl((XmlFile)file)
                                        : null;
                                      return Result.create(value, file);
                                    }
                                  }, false
    );
  }
  return null;
}
 

import com.intellij.psi.util.CachedValuesManager; //导入方法依赖的package包/类
protected void runPreview(boolean forceRefresh) {
    if (!isAutoSync() && !forceRefresh)
        return;

    final Map<String, Object> payload = new HashMap<String, Object>();
    Map<String, Map<String, Object>> flowVars = new HashMap<String, Map<String, Object>>();
    /*
    1. Get input from tabs - if payload exists, use payload, otherwise put in the Map
    2. Get text from DW
    3. Run preview, put the output to the output tab
     */

    int count = inputTabs.getTabCount();
    for (int index = 0; index < count; index++) {
        String title = inputTabs.getTitleAt(index);
        Editor editor = editors.get(title);
        Document document = editor.getDocument();
        String text = document.getText();
        String contentType = contentTypes.get(title);
        Map<String, Object> content = WeavePreview.createContent(contentType, text);
        if ("payload".equalsIgnoreCase(title)) {
            payload.clear();
            payload.putAll(content);
        } else {
            flowVars.put(title, content);
        }
    }

    final CachedValuesManager manager = CachedValuesManager.getManager(project);
    List<String> melFunctions = manager.getCachedValue(psiFile, MEL_STRINGS_KEY, new MelStringsCachedProvider());

    String dwScript = this.textEditor.getEditor().getDocument().getText();

    String output = WeavePreview.runPreview(module, dwScript, payload, flowVars, flowVars, flowVars, flowVars, flowVars, melFunctions);
    if (output != null)
        editors.get("output").getDocument().setText(output);
}
 

import com.intellij.psi.util.CachedValuesManager; //导入方法依赖的package包/类
private static boolean hasErrors(@NotNull final PsiFile psiFile) {
  CachedValuesManager cachedValuesManager = CachedValuesManager.getManager(psiFile.getProject());
  return cachedValuesManager.getCachedValue(
    psiFile,
    CONTAINS_ERROR_ELEMENT,
    new CachedValueProvider<Boolean>() {
      @Override
      public Result<Boolean> compute() {
        boolean error = hasErrorElements(psiFile);
        return Result.create(error, psiFile);
      }
    },
    false
  );
}
 

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();
}
 

import com.intellij.psi.util.CachedValuesManager; //导入方法依赖的package包/类
@Override
public <T> T getCachedValue(@NotNull GroovyPsiElement element, @NotNull final Computable<T> computable) {
  CachedValuesManager manager = CachedValuesManager.getManager(element.getProject());
  Key<CachedValue<T>> key = manager.getKeyForClass(computable.getClass());
  return manager.getCachedValue(element, key, new CachedValueProvider<T>() {
    @Nullable
    @Override
    public Result<T> compute() {
      return Result.create(computable.compute(), PsiModificationTracker.MODIFICATION_COUNT);
    }
  }, false);
}
 

import com.intellij.psi.util.CachedValuesManager; //导入方法依赖的package包/类
public FacetFinderImpl(Project project) {
  myProject = project;
  myCachedValuesManager = CachedValuesManager.getManager(project);
  myModuleManager = ModuleManager.getInstance(myProject);
}
 

import com.intellij.psi.util.CachedValuesManager; //导入方法依赖的package包/类
private static List<URL> getURLsForModule(Module module) throws Exception {

        final CachedValuesManager manager = CachedValuesManager.getManager(module.getProject());
        List<URL> loaderUrls = manager.getParameterizedCachedValue(module, URLS_KEY, new ClasspathUtils.UrlsCachedProvider(), false, module);

        return loaderUrls;
    }