private synchronized void save() { myDir.mkdirs(); Properties props = new Properties(); props.setProperty(KIND_KEY, myKind.toString()); props.setProperty(ID_KEY, myId.getValue()); props.setProperty(PATH_OR_URL_KEY, myRepositoryPathOrUrl); props.setProperty(INDEX_VERSION_KEY, CURRENT_VERSION); if (myUpdateTimestamp != null) props.setProperty(TIMESTAMP_KEY, String.valueOf(myUpdateTimestamp)); if (myDataDirName != null) props.setProperty(DATA_DIR_NAME_KEY, myDataDirName); if (myFailureMessage != null) props.setProperty(FAILURE_MESSAGE_KEY, myFailureMessage); try { FileOutputStream s = new FileOutputStream(new File(myDir, INDEX_INFO_FILE)); try { props.store(s, null); } finally { s.close(); } } catch (IOException e) { MavenLog.LOG.warn(e); } }
public Instruction[] getControlFlow() { assert isValid(); CachedValue<Instruction[]> controlFlow = getUserData(CONTROL_FLOW); if (controlFlow == null) { controlFlow = CachedValuesManager.getManager(getProject()) .createCachedValue( new CachedValueProvider<Instruction[]>() { @Override public Result<Instruction[]> compute() { try { ResolveProfiler.start(); final Instruction[] flow = new ControlFlowBuilder(getProject()).buildControlFlow(GrBlockImpl.this); return Result.create( flow, getContainingFile(), PsiModificationTracker.JAVA_STRUCTURE_MODIFICATION_COUNT); } finally { final long time = ResolveProfiler.finish(); ResolveProfiler.write("flow " + GrBlockImpl.this.toString() + " : " + time); } } }, false); controlFlow = putUserDataIfAbsent(CONTROL_FLOW, controlFlow); } return ControlFlowBuilder.assertValidPsi(controlFlow.getValue()); }
@Nullable public BundleManifest getManifest(@NotNull final VirtualFile libRoot) { CachedValue<BundleManifest> value = myCache.get(libRoot); if (value == null) { value = myManager.createCachedValue( new CachedValueProvider<BundleManifest>() { @Nullable @Override public Result<BundleManifest> compute() { VirtualFile manifestFile = libRoot.findFileByRelativePath(JarFile.MANIFEST_NAME); PsiFile psiFile = manifestFile != null ? PsiManager.getInstance(myProject).findFile(manifestFile) : null; BundleManifest manifest = manifestFile != null ? readManifest(psiFile) : null; return Result.createSingleDependency(manifest, libRoot); } }, false); myCache.put(libRoot, value); } return value.getValue(); }
public XmlNSDescriptor getNSDescriptor(final String namespace, boolean strict) { final XmlTag parentTag = getParentTag(); if (parentTag == null && namespace.equals(XmlUtil.XHTML_URI)) { final XmlNSDescriptor descriptor = getDtdDescriptor(XmlUtil.getContainingFile(this)); if (descriptor != null) { return descriptor; } } Map<String, CachedValue<XmlNSDescriptor>> map = initNSDescriptorsMap(); final CachedValue<XmlNSDescriptor> descriptor = map.get(namespace); if (descriptor != null) { final XmlNSDescriptor value = descriptor.getValue(); if (value != null) { return value; } } if (parentTag == null) { final XmlDocument parentOfType = PsiTreeUtil.getParentOfType(this, XmlDocument.class); if (parentOfType == null) { return null; } return parentOfType.getDefaultNSDescriptor(namespace, strict); } return parentTag.getNSDescriptor(namespace, strict); }
@Override @Nullable public PsiModifierList getAnnotationList() { if (myAnnotationList == null) { myAnnotationList = CachedValuesManager.getManager(myManager.getProject()) .createCachedValue(new PackageAnnotationValueProvider()); } return myAnnotationList.getValue(); }
@Override public XmlNSDescriptor getDefaultNSDescriptor(final String namespace, final boolean strict) { long curExtResourcesModCount = ExternalResourceManagerEx.getInstanceEx().getModificationCount(getProject()); if (myExtResourcesModCount != curExtResourcesModCount) { myDefaultDescriptorsCacheNotStrict.clear(); myDefaultDescriptorsCacheStrict.clear(); myExtResourcesModCount = curExtResourcesModCount; } final ConcurrentMap<String, CachedValue<XmlNSDescriptor>> defaultDescriptorsCache; if (strict) { defaultDescriptorsCache = myDefaultDescriptorsCacheStrict; } else { defaultDescriptorsCache = myDefaultDescriptorsCacheNotStrict; } CachedValue<XmlNSDescriptor> cachedValue = defaultDescriptorsCache.get(namespace); if (cachedValue == null) { defaultDescriptorsCache.put( namespace, cachedValue = new PsiCachedValueImpl<XmlNSDescriptor>( getManager(), new CachedValueProvider<XmlNSDescriptor>() { @Override public Result<XmlNSDescriptor> compute() { final XmlNSDescriptor defaultNSDescriptorInner = getDefaultNSDescriptorInner(namespace, strict); if (isGeneratedFromDtd(defaultNSDescriptorInner)) { return new Result<XmlNSDescriptor>( defaultNSDescriptorInner, XmlDocumentImpl.this, ExternalResourceManager.getInstance()); } return new Result<XmlNSDescriptor>( defaultNSDescriptorInner, defaultNSDescriptorInner != null ? defaultNSDescriptorInner.getDependences() : ExternalResourceManager.getInstance()); } })); } return cachedValue.getValue(); }
/** * Analyze project with string cache for given file. Given file will be fully analyzed. * * @param file * @param declarationProvider * @return */ public static AnalyzeExhaust analyzeFileWithCache( @NotNull final JetFile file, @NotNull final Function<JetFile, Collection<JetFile>> declarationProvider) { // Need lock for getValue(), because parallel threads can start evaluation of compute() // simultaneously synchronized (lock) { CachedValue<AnalyzeExhaust> bindingContextCachedValue = file.getUserData(BINDING_CONTEXT); if (bindingContextCachedValue == null) { bindingContextCachedValue = CachedValuesManager.getManager(file.getProject()) .createCachedValue( new CachedValueProvider<AnalyzeExhaust>() { @Override public Result<AnalyzeExhaust> compute() { try { AnalyzeExhaust bindingContext = analyzeFilesWithJavaIntegration( file.getProject(), declarationProvider.fun(file), Predicates.<PsiFile>equalTo(file), JetControlFlowDataTraceFactory.EMPTY); return new Result<AnalyzeExhaust>( bindingContext, PsiModificationTracker.MODIFICATION_COUNT); } catch (ProcessCanceledException e) { throw e; } catch (Throwable e) { DiagnosticUtils.throwIfRunningOnServer(e); LOG.error(e); BindingTraceContext bindingTraceContext = new BindingTraceContext(); bindingTraceContext.report(Errors.EXCEPTION_WHILE_ANALYZING.on(file, e)); AnalyzeExhaust analyzeExhaust = new AnalyzeExhaust(bindingTraceContext.getBindingContext(), null); return new Result<AnalyzeExhaust>( analyzeExhaust, PsiModificationTracker.MODIFICATION_COUNT); } } }, false); file.putUserData(BINDING_CONTEXT, bindingContextCachedValue); } return bindingContextCachedValue.getValue(); } }
private PsiJavaFileStub getStub() { CachedValue<PsiJavaFileStub> answer = file.getUserData(JAVA_API_STUB); if (answer == null) { answer = CachedValuesManager.getManager(getProject()) .createCachedValue( new CachedValueProvider<PsiJavaFileStub>() { @Override public Result<PsiJavaFileStub> compute() { return Result.create( calcStub(), PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT); } }, false); file.putUserData(JAVA_API_STUB, answer); } return answer.getValue(); }
@Nullable protected TypeDescriptor findTypeDescriptorImpl( XmlTag rootTag, final String name, String namespace, Set<XmlTag> visited) { XmlNSDescriptorImpl responsibleDescriptor = this; if (namespace != null && namespace.length() != 0 && !namespace.equals(getDefaultNamespace())) { final XmlNSDescriptor nsDescriptor = rootTag.getNSDescriptor(namespace, true); if (nsDescriptor instanceof XmlNSDescriptorImpl) { responsibleDescriptor = (XmlNSDescriptorImpl) nsDescriptor; } } if (responsibleDescriptor != this) { return responsibleDescriptor.findTypeDescriptor(XmlUtil.findLocalNameByQualifiedName(name)); } if (rootTag == null) return null; if (visited != null) { if (visited.contains(rootTag)) return null; visited.add(rootTag); } final Pair<QNameKey, XmlTag> pair = new Pair<QNameKey, XmlTag>(new QNameKey(name, namespace), rootTag); final CachedValue<TypeDescriptor> descriptor = myTypesMap.get(pair); if (descriptor != null) { TypeDescriptor value = descriptor.getValue(); if (value == null || (value instanceof ComplexTypeDescriptor && ((ComplexTypeDescriptor) value).getDeclaration().isValid())) return value; } XmlTag[] tags = rootTag.getSubTags(); if (visited == null) { visited = new HashSet<XmlTag>(1); visited.add(rootTag); } return doFindIn(tags, name, namespace, pair, rootTag, visited); }
@Nullable private static PsiType getLeastUpperBoundByVar(final GrVariable resolved) { CachedValue<PsiType> data = resolved.getUserData(LEAST_UPPER_BOUND_TYPE); if (data == null) { data = CachedValuesManager.getManager(resolved.getProject()) .createCachedValue( new CachedValueProvider<PsiType>() { @Override public Result<PsiType> compute() { return Result.create( getLeastUpperBoundByVarImpl(resolved), PsiModificationTracker.MODIFICATION_COUNT, ProjectRootManager.getInstance(resolved.getProject())); } }, false); } return data.getValue(); }
/** * Analyze project with string cache for the whole project. All given files will be analyzed only * for descriptors. */ public static AnalyzeExhaust analyzeProjectWithCache( @NotNull final Project project, @NotNull final Collection<JetFile> files) { // Need lock for getValue(), because parallel threads can start evaluation of compute() // simultaneously synchronized (lock) { CachedValue<AnalyzeExhaust> bindingContextCachedValue = project.getUserData(BINDING_CONTEXT); if (bindingContextCachedValue == null) { bindingContextCachedValue = CachedValuesManager.getManager(project) .createCachedValue( new CachedValueProvider<AnalyzeExhaust>() { @Override public Result<AnalyzeExhaust> compute() { try { AnalyzeExhaust analyzeExhaust = analyzeFilesWithJavaIntegration( project, files, Predicates.<PsiFile>alwaysFalse(), JetControlFlowDataTraceFactory.EMPTY); return new Result<AnalyzeExhaust>( analyzeExhaust, PsiModificationTracker.MODIFICATION_COUNT); } catch (ProcessCanceledException e) { throw e; } catch (Throwable e) { DiagnosticUtils.throwIfRunningOnServer(e); LOG.error(e); BindingTraceContext bindingTraceContext = new BindingTraceContext(); AnalyzeExhaust analyzeExhaust = new AnalyzeExhaust(bindingTraceContext.getBindingContext(), null); return new Result<AnalyzeExhaust>( analyzeExhaust, PsiModificationTracker.MODIFICATION_COUNT); } } }, false); project.putUserData(BINDING_CONTEXT, bindingContextCachedValue); } return bindingContextCachedValue.getValue(); } }
/** Returns the same as {@link #getGlobalDartSdk()} but much faster */ @Nullable public static DartSdk getDartSdk(@NotNull final Project project) { CachedValue<DartSdk> cachedValue = project.getUserData(CACHED_DART_SDK_KEY); if (cachedValue == null) { cachedValue = CachedValuesManager.getManager(project) .createCachedValue( () -> { final DartSdk sdk = getGlobalDartSdk(); if (sdk == null) { return new CachedValueProvider.Result<DartSdk>( null, DartProjectComponent.getProjectRootsModificationTracker(project)); } List<Object> dependencies = new ArrayList<Object>(3); dependencies.add( DartProjectComponent.getProjectRootsModificationTracker(project)); ContainerUtil.addIfNotNull( dependencies, LocalFileSystem.getInstance() .findFileByPath(sdk.getHomePath() + "/version")); ContainerUtil.addIfNotNull( dependencies, LocalFileSystem.getInstance() .findFileByPath(sdk.getHomePath() + "/lib/core/core.dart")); return new CachedValueProvider.Result<DartSdk>( sdk, ArrayUtil.toObjectArray(dependencies)); }, false); project.putUserData(CACHED_DART_SDK_KEY, cachedValue); } return cachedValue.getValue(); }
@Nullable public XmlElementDescriptor getElementDescriptor( String localName, String namespace, Set<XmlNSDescriptorImpl> visited, boolean reference) { if (visited.contains(this)) return null; final QNameKey pair = new QNameKey(namespace, localName); final CachedValue<XmlElementDescriptor> descriptor = myDescriptorsMap.get(pair); if (descriptor != null) { final XmlElementDescriptor value = descriptor.getValue(); if (value == null || value.getDeclaration().isValid()) return value; } final XmlTag rootTag = myTag; if (rootTag == null) return null; XmlTag[] tags = rootTag.getSubTags(); visited.add(this); for (final XmlTag tag : tags) { if (equalsToSchemaName(tag, ELEMENT_TAG_NAME)) { String name = tag.getAttributeValue("name"); if (name != null) { if (checkElementNameEquivalence(localName, namespace, name, tag)) { final CachedValue<XmlElementDescriptor> cachedValue = CachedValuesManager.getManager(tag.getProject()) .createCachedValue( new CachedValueProvider<XmlElementDescriptor>() { public Result<XmlElementDescriptor> compute() { final String name = tag.getAttributeValue("name"); if (name != null && !name.equals(pair.second)) { myDescriptorsMap.remove(pair); return new Result<XmlElementDescriptor>(null); } final XmlElementDescriptor xmlElementDescriptor = createElementDescriptor(tag); return new Result<XmlElementDescriptor>( xmlElementDescriptor, xmlElementDescriptor.getDependences()); } }, false); myDescriptorsMap.put(pair, cachedValue); return cachedValue.getValue(); } } } else if (equalsToSchemaName(tag, INCLUDE_TAG_NAME) || (reference && equalsToSchemaName(tag, IMPORT_TAG_NAME) && (namespace.equals(tag.getAttributeValue("namespace")) || namespace.length() == 0 && tag.getAttributeValue("namespace") == null))) { final XmlAttribute schemaLocation = tag.getAttribute("schemaLocation", null); if (schemaLocation != null) { final XmlFile xmlFile = XmlUtil.findNamespaceByLocation( rootTag.getContainingFile(), schemaLocation.getValue()); if (xmlFile != null) { final XmlDocument includedDocument = xmlFile.getDocument(); if (includedDocument != null) { final PsiMetaData data = includedDocument.getMetaData(); if (data instanceof XmlNSDescriptorImpl) { final XmlElementDescriptor elementDescriptor = ((XmlNSDescriptorImpl) data) .getElementDescriptor(localName, namespace, visited, reference); if (elementDescriptor != null) { // final CachedValue<XmlElementDescriptor> value = // includedDocument.getManager().getCachedValuesManager() // .createCachedValue(new CachedValueProvider<XmlElementDescriptor>() { // public Result<XmlElementDescriptor> compute() { // return new Result<XmlElementDescriptor>(elementDescriptor, // elementDescriptor.getDependences()); // } // }, false); // return value.getValue(); return elementDescriptor; } } } } } } else if (equalsToSchemaName(tag, REDEFINE_TAG_NAME)) { final XmlNSDescriptorImpl nsDescriptor = getRedefinedElementDescriptor(tag); if (nsDescriptor != null) { final XmlElementDescriptor xmlElementDescriptor = nsDescriptor.getElementDescriptor(localName, namespace, visited, reference); if (xmlElementDescriptor != null) return xmlElementDescriptor; } } } return null; }
@Nullable public BundleManifest getManifest(@NotNull final Module module) { final OsmorcFacet facet = OsmorcFacet.getInstance(module); if (facet == null) return null; CachedValue<BundleManifest> value = myCache.get(facet); if (value == null) { value = myManager.createCachedValue( new CachedValueProvider<BundleManifest>() { @Nullable @Override public Result<BundleManifest> compute() { OsmorcFacetConfiguration configuration = facet.getConfiguration(); BundleManifest manifest = null; List<Object> dependencies = ContainerUtil.<Object>newSmartList(configuration); switch (configuration.getManifestGenerationMode()) { case Manually: { PsiFile manifestFile = findInModuleRoots( facet.getModule(), configuration.getManifestLocation()); if (manifestFile != null) { manifest = readManifest(manifestFile); dependencies.add(manifestFile); } else { dependencies.add(PsiModificationTracker.MODIFICATION_COUNT); } break; } case OsmorcControlled: { Map<String, String> map = ContainerUtil.newHashMap(configuration.getAdditionalPropertiesAsMap()); map.put( Constants.BUNDLE_SYMBOLICNAME, configuration.getBundleSymbolicName()); map.put(Constants.BUNDLE_VERSION, configuration.getBundleVersion()); map.put(Constants.BUNDLE_ACTIVATOR, configuration.getBundleActivator()); manifest = new BundleManifest(map); break; } case Bnd: { PsiFile bndFile = findInModuleRoots( facet.getModule(), configuration.getBndFileLocation()); if (bndFile != null) { manifest = readProperties(bndFile); dependencies.add(bndFile); } else { dependencies.add(PsiModificationTracker.MODIFICATION_COUNT); } break; } case Bundlor: break; // not supported } return Result.create(manifest, dependencies); } }, false); myCache.put(facet, value); } return value.getValue(); }
private TypeDescriptor doFindIn( final XmlTag[] tags, final String name, final String namespace, final Pair<QNameKey, XmlTag> pair, final XmlTag rootTag, final Set<XmlTag> visited) { for (final XmlTag tag : tags) { if (equalsToSchemaName(tag, "complexType")) { if (name == null) { CachedValue<TypeDescriptor> value = createAndPutTypesCachedValue(tag, pair); return value.getValue(); } String nameAttribute = tag.getAttributeValue("name"); if (isSameName(name, namespace, nameAttribute)) { CachedValue<TypeDescriptor> cachedValue = createAndPutTypesCachedValue(tag, pair); return cachedValue.getValue(); } } else if (equalsToSchemaName(tag, "simpleType")) { if (name == null) { CachedValue<TypeDescriptor> value = createAndPutTypesCachedValueSimpleType(tag, pair); return value.getValue(); } String nameAttribute = tag.getAttributeValue("name"); if (isSameName(name, namespace, nameAttribute)) { CachedValue<TypeDescriptor> cachedValue = createAndPutTypesCachedValue(tag, pair); return cachedValue.getValue(); } } else if (equalsToSchemaName(tag, INCLUDE_TAG_NAME) || (equalsToSchemaName(tag, IMPORT_TAG_NAME) && (namespace == null || !namespace.equals(getDefaultNamespace())))) { final String schemaLocation = tag.getAttributeValue("schemaLocation"); if (schemaLocation != null) { final XmlFile xmlFile = XmlUtil.findNamespaceByLocation(rootTag.getContainingFile(), schemaLocation); if (xmlFile != null) { final XmlDocument document = xmlFile.getDocument(); if (document != null) { final CachedValue<TypeDescriptor> value = CachedValuesManager.getManager(tag.getProject()) .createCachedValue( new CachedValueProvider<TypeDescriptor>() { public Result<TypeDescriptor> compute() { final String currentName = tag.getAttributeValue("name"); if ((currentName != null && !currentName.equals( XmlUtil.findLocalNameByQualifiedName(name))) || !xmlFile.isValid() || xmlFile.getDocument() == null) { myTypesMap.remove(pair); return new Result<TypeDescriptor>(null); } final XmlDocument document = xmlFile.getDocument(); final XmlNSDescriptorImpl nsDescriptor = findNSDescriptor(tag, document); if (nsDescriptor == null) { myTypesMap.remove(pair); return new Result<TypeDescriptor>(null); } final XmlTag rTag = document.getRootTag(); final TypeDescriptor complexTypeDescriptor = nsDescriptor.findTypeDescriptorImpl( rTag, name, namespace, visited); return new Result<TypeDescriptor>(complexTypeDescriptor, rTag); } }, false); if (value.getValue() != null) { myTypesMap.put(pair, value); return value.getValue(); } } } } } else if (equalsToSchemaName(tag, REDEFINE_TAG_NAME)) { final XmlTag[] subTags = tag.getSubTags(); TypeDescriptor descriptor = doFindIn(subTags, name, namespace, pair, rootTag, visited); if (descriptor != null) return descriptor; final XmlNSDescriptorImpl nsDescriptor = getRedefinedElementDescriptor(tag); if (nsDescriptor != null) { final XmlTag redefinedRootTag = ((XmlDocument) nsDescriptor.getDeclaration()).getRootTag(); descriptor = doFindIn( redefinedRootTag.getSubTags(), name, namespace, pair, redefinedRootTag, visited); if (descriptor != null) return descriptor; } } } return null; }
@Nullable private XmlAttributeDescriptor getAttributeImpl( String localName, String namespace, Set<XmlTag> visited) { if (myTag == null) return null; XmlNSDescriptorImpl nsDescriptor = (XmlNSDescriptorImpl) myTag.getNSDescriptor(namespace, true); if (nsDescriptor != this && nsDescriptor != null) { return nsDescriptor.getAttributeImpl(localName, namespace, visited); } if (visited == null) visited = new HashSet<XmlTag>(1); else if (visited.contains(myTag)) return null; visited.add(myTag); XmlTag[] tags = myTag.getSubTags(); for (XmlTag tag : tags) { if (equalsToSchemaName(tag, ATTRIBUTE_TAG_NAME)) { String name = tag.getAttributeValue("name"); if (name != null) { if (checkElementNameEquivalence(localName, namespace, name, tag)) { return createAttributeDescriptor(tag); } } } else if (equalsToSchemaName(tag, INCLUDE_TAG_NAME) || (equalsToSchemaName(tag, IMPORT_TAG_NAME) && namespace.equals(tag.getAttributeValue("namespace")))) { final XmlAttribute schemaLocation = tag.getAttribute("schemaLocation", null); if (schemaLocation != null) { final XmlFile xmlFile = XmlUtil.findNamespaceByLocation(myTag.getContainingFile(), schemaLocation.getValue()); if (xmlFile != null) { final XmlDocument includedDocument = xmlFile.getDocument(); if (includedDocument != null) { final PsiMetaData data = includedDocument.getMetaData(); if (data instanceof XmlNSDescriptorImpl) { final XmlAttributeDescriptor attributeDescriptor = ((XmlNSDescriptorImpl) data).getAttributeImpl(localName, namespace, visited); if (attributeDescriptor != null) { final CachedValue<XmlAttributeDescriptor> value = CachedValuesManager.getManager(includedDocument.getProject()) .createCachedValue( new CachedValueProvider<XmlAttributeDescriptor>() { public Result<XmlAttributeDescriptor> compute() { return new Result<XmlAttributeDescriptor>( attributeDescriptor, attributeDescriptor.getDependences()); } }, false); return value.getValue(); } } } } } } } return null; }
private int createContext(File contextDir, String suffix) throws MavenServerIndexerException { String indexId = myDir.getName() + "-" + suffix; return myIndexer.createIndex( indexId, myId.getValue(), getRepositoryFile(), getRepositoryUrl(), contextDir); }
public String getRepositoryId() { return myId.getValue(); }