com.intellij.openapi.vfs.pointers.VirtualFilePointerManager Java Examples

@Nonnull
public static HistoryEntry createHeavy(@Nonnull Project project,
                                       @Nonnull VirtualFile file,
                                       @Nonnull FileEditorProvider[] providers,
                                       @Nonnull FileEditorState[] states,
                                       @Nonnull FileEditorProvider selectedProvider) {
  if (project.isDisposed()) return createLight(file, providers, states, selectedProvider);

  Disposable disposable = Disposable.newDisposable();
  VirtualFilePointer pointer = VirtualFilePointerManager.getInstance().create(file, disposable, null);

  HistoryEntry entry = new HistoryEntry(pointer, selectedProvider, disposable);
  for (int i = 0; i < providers.length; i++) {
    FileEditorProvider provider = providers[i];
    FileEditorState state = states[i];
    if (provider != null && state != null) {
      entry.putState(provider, state);
    }
  }
  return entry;
}
 

@Override
public void setCompilerOutputUrl(@Nullable String compilerOutputUrl) {
  myOutputDirPointer = compilerOutputUrl == null ? null : VirtualFilePointerManager.getInstance().create(compilerOutputUrl, myProject, null);

  myCompilerOutputWatchRequest =
          compilerOutputUrl == null ? null : LocalFileSystem.getInstance().replaceWatchedRoot(myCompilerOutputWatchRequest, ProjectRootManagerImpl.extractLocalPath(compilerOutputUrl), true);
}
 

@Override
public void loadState(Element state) {
  for (Element element : state.getChildren("task")) {
    String url = element.getAttributeValue("url");
    String name = element.getAttributeValue("name");
    String providerName = element.getAttributeValue("provider-name");
    boolean enabled = Boolean.valueOf(element.getAttributeValue("enabled"));

    VirtualFilePointer virtualFilePointer = VirtualFilePointerManager.getInstance().create(url, this, null);

    BackgroundTaskByVfsParametersImpl parameters = new BackgroundTaskByVfsParametersImpl(myProject);

    BackgroundTaskByVfsChangeTaskImpl task = new BackgroundTaskByVfsChangeTaskImpl(myProject, virtualFilePointer, providerName, name, parameters, this);
    task.setEnabled(enabled);

    Element parametersElement = element.getChild("parameters");
    if (parametersElement != null) {
      ReplacePathToMacroMap replaceMacroToPathMap = task.createReplaceMacroToPathMap();

      replaceMacroToPathMap.substitute(parametersElement, false, true);

      XmlSerializer.deserializeInto(parameters, parametersElement);
    }

    registerTask(task);
  }
}
 

public BackgroundTaskByVfsChangeTaskImpl(@Nonnull Project project,
                                         @Nonnull VirtualFile virtualFile,
                                         @Nonnull BackgroundTaskByVfsChangeManagerImpl manager,
                                         @Nonnull BackgroundTaskByVfsChangeProvider provider,
                                         @Nonnull String name,
                                         @Nonnull BackgroundTaskByVfsParameters parameters) {
  this(project, VirtualFilePointerManager.getInstance().create(virtualFile, manager, null), parameters, provider.getTemplateName(), name, provider, manager);

}
 

protected FileOrDirectoryTreeNode(@Nonnull String path,
                                  @Nonnull SimpleTextAttributes invalidAttributes,
                                  @Nonnull Project project,
                                  @javax.annotation.Nullable String parentPath) {
  String preparedPath = path.replace(File.separatorChar, '/');
  String url = VirtualFileManager.constructUrl(LocalFileSystem.getInstance().getProtocol(), preparedPath);
  setUserObject(VirtualFilePointerManager.getInstance().create(url, this, this));
  myFile = new File(getFilePath());
  myInvalidAttributes = invalidAttributes;
  myProject = project;
  myName = parentPath == null ? myFile.getAbsolutePath() : myFile.getName();
}
 

public CoreApplicationEnvironment(@Nonnull Disposable parentDisposable) {
  myParentDisposable = parentDisposable;

  myFileTypeRegistry = new CoreFileTypeRegistry();

  myApplication = createApplication(myParentDisposable);
  ApplicationManager.setApplication(myApplication, myParentDisposable);
  myLocalFileSystem = createLocalFileSystem();
  myJarFileSystem = createJarFileSystem();

  final InjectingContainer appContainer = myApplication.getInjectingContainer();
  registerComponentInstance(appContainer, FileDocumentManager.class, new MockFileDocumentManagerImpl(DocumentImpl::new, null));

  VirtualFileSystem[] fs = {myLocalFileSystem, myJarFileSystem};
  VirtualFileManagerImpl virtualFileManager = new VirtualFileManagerImpl(myApplication, fs);
  registerComponentInstance(appContainer, VirtualFileManager.class, virtualFileManager);

  registerApplicationExtensionPoint(ASTLazyFactory.EP.getExtensionPointName(), ASTLazyFactory.class);
  registerApplicationExtensionPoint(ASTLeafFactory.EP.getExtensionPointName(), ASTLeafFactory.class);
  registerApplicationExtensionPoint(ASTCompositeFactory.EP.getExtensionPointName(), ASTCompositeFactory.class);

  addExtension(ASTLazyFactory.EP.getExtensionPointName(), new DefaultASTLazyFactory());
  addExtension(ASTLeafFactory.EP.getExtensionPointName(), new DefaultASTLeafFactory());
  addExtension(ASTCompositeFactory.EP.getExtensionPointName(), new DefaultASTCompositeFactory());

  registerApplicationService(EncodingManager.class, new CoreEncodingRegistry());
  registerApplicationService(VirtualFilePointerManager.class, createVirtualFilePointerManager());
  registerApplicationService(PsiBuilderFactory.class, new PsiBuilderFactoryImpl());
  registerApplicationService(ReferenceProvidersRegistry.class, new MockReferenceProvidersRegistry());
  registerApplicationService(StubTreeLoader.class, new CoreStubTreeLoader());
  registerApplicationService(PsiReferenceService.class, new PsiReferenceServiceImpl());
  registerApplicationService(MetaDataRegistrar.class, new MetaRegistry());

  registerApplicationService(ProgressManager.class, createProgressIndicatorProvider());

  registerApplicationService(JobLauncher.class, createJobLauncher());
  registerApplicationService(CodeFoldingSettings.class, new CodeFoldingSettings());
  registerApplicationService(CommandProcessor.class, new CoreCommandProcessor());
}
 

public void dispose() {
  FilePointerPartNode node = checkDisposed(myNode);
  if (node.incrementUsageCount(-1) == 0) {
    myTraceableDisposable.kill("URL when die: " + this);
    VirtualFilePointerManager pointerManager = VirtualFilePointerManager.getInstance();
    if (pointerManager instanceof VirtualFilePointerManagerImpl) {
      ((VirtualFilePointerManagerImpl)pointerManager).removeNodeFrom(this);
    }
  }
}
 

@Nonnull
public static HistoryEntry createHeavy(@Nonnull Project project, @Nonnull Element e) throws InvalidDataException {
  if (project.isDisposed()) return createLight(project, e);

  EntryData entryData = parseEntry(project, e);

  Disposable disposable = Disposable.newDisposable();
  VirtualFilePointer pointer = VirtualFilePointerManager.getInstance().create(entryData.url, disposable, null);

  HistoryEntry entry = new HistoryEntry(pointer, entryData.selectedProvider, disposable);
  for (Pair<FileEditorProvider, FileEditorState> state : entryData.providerStates) {
    entry.putState(state.first, state.second);
  }
  return entry;
}
 

@Override
public void loadState(Element element) {
  myInheritOutput = false;
  myExcludeOutput = Boolean.valueOf(element.getAttributeValue(EXCLUDE, "true"));
  for (Element child2 : element.getChildren()) {
    final String moduleUrl = child2.getAttributeValue(URL);
    final String type = child2.getAttributeValue(TYPE);

    myVirtualFilePointers.put(type, VirtualFilePointerManager.getInstance().create(moduleUrl, this, null));
  }
}
 

@Override
public void setCompilerOutputUrl(@Nonnull ContentFolderTypeProvider contentFolderType, @Nullable String compilerOutputUrl) {
  if (myInheritOutput) {
    throw new IllegalArgumentException();
  }
  if (compilerOutputUrl == null) {
    return;
  }

  myVirtualFilePointers.put(contentFolderType.getId(), VirtualFilePointerManager.getInstance().create(compilerOutputUrl, this, null));
}
 

@Override
protected void setUp() throws Exception {
  super.setUp();
  myVirtualFilePointerManager = (VirtualFilePointerManagerImpl)VirtualFilePointerManager.getInstance();
  numberOfPointersBefore = myVirtualFilePointerManager.numberOfPointers();
  numberOfListenersBefore = myVirtualFilePointerManager.numberOfListeners();
}
 

public VirtualFilePointerContainer setCachedRoots(OrderRootType rootType, int flags, Collection<String> urls) {
  final VirtualFilePointerContainer container = VirtualFilePointerManager.getInstance().createContainer(myParentDisposable);
  for (String url : urls) {
    container.add(url);
  }
  myRoots.put(new CacheKey(rootType, flags), container);
  return container;
}
 

@Nonnull
private VirtualFilePointerContainer getOrCreateExcludedRoots() {
  VirtualFilePointerContainer excludedRoots = myExcludedRoots;
  if (excludedRoots == null) {
    myExcludedRoots = excludedRoots = VirtualFilePointerManager.getInstance().createContainer(myPointersDisposable);
  }
  return excludedRoots;
}
 

@Nonnull
private VirtualFilePointerContainer getOrCreateContainer(@Nonnull OrderRootType rootType) {
  VirtualFilePointerContainer roots = myRoots.get(rootType);
  if (roots == null) {
    roots = VirtualFilePointerManager.getInstance().createContainer(myPointersDisposable, getListener());
    myRoots.put(rootType, roots);
  }
  return roots;
}
 

protected ContentFolderImpl(@Nonnull VirtualFilePointer filePointer,
                            @Nullable Map<String, Object> properties,
                            @Nonnull ContentFolderTypeProvider contentFolderType,
                            @Nonnull ContentEntryImpl contentEntry) {
  super(contentEntry.getModuleRootLayer());
  myContentEntry = contentEntry;
  myContentFolderType = contentFolderType;
  myProperties = properties;
  myFilePointer = VirtualFilePointerManager.getInstance().duplicate(filePointer, this, null);
}
 

ContentFolderImpl(@Nonnull String url,
                  @Nonnull ContentFolderTypeProvider contentFolderType,
                  @Nullable Map<String, Object> map,
                  @Nonnull ContentEntryImpl contentEntry) {
  super(contentEntry.getModuleRootLayer());
  myContentEntry = contentEntry;
  myContentFolderType = contentFolderType;
  myProperties = map == null ? null : new HashMap<String, Object>(map);
  myFilePointer = VirtualFilePointerManager.getInstance().create(url, this, null);
}
 

ContentFolderImpl(@Nonnull VirtualFile file,
                  @Nonnull ContentFolderTypeProvider contentFolderType,
                  @Nonnull ContentEntryImpl contentEntry) {
  super(contentEntry.getModuleRootLayer());
  myContentEntry = contentEntry;
  myContentFolderType = contentFolderType;
  myFilePointer = VirtualFilePointerManager.getInstance().create(file, this, null);
}
 

@Nonnull
private VirtualFilePointerContainer getOrCreateContainer(@Nonnull OrderRootType rootType) {
  VirtualFilePointerContainer roots = myRoots.get(rootType);
  if (roots == null) {
    roots = VirtualFilePointerManager.getInstance().createContainer(myParent, myListener);
    myRoots.put(rootType, roots);
  }
  return roots;
}
 

public SdkImpl(SdkTable sdkTable, String name, SdkTypeId sdkType) {
  mySdkTable = sdkTable;
  mySdkType = sdkType;
  myName = name;

  myRoots = new RootsAsVirtualFilePointers(true, tellAllProjectsTheirRootsAreGoingToChange, this);
  // register on VirtualFilePointerManager because we want our virtual pointers to be disposed before VFPM to avoid "pointer leaked" diagnostics fired
  Disposer.register((Disposable)VirtualFilePointerManager.getInstance(), this);
}
 

public void setPresentableUrl(String newUrl) {
  myFilePointer = VirtualFilePointerManager.getInstance().create(VfsUtil.pathToUrl(FileUtil.toSystemIndependentName(newUrl)), myParentDisposable, null);
  final VirtualFile file = getVirtualFile();
  if (file != null) {
    myIsFile = !file.isDirectory();
  }
}
 

public ExcludeEntryDescription(String url, boolean includeSubdirectories, boolean isFile, Disposable parent) {
  myParentDisposable = parent;
  myFilePointer = VirtualFilePointerManager.getInstance().create(url, parent, null);
  myIncludeSubdirectories = includeSubdirectories;
  myIsFile = isFile;
}
 

public ModuleImpl(@Nonnull String name, @Nullable String dirUrl, @Nonnull Project project) {
  super(project, "Module " + name, ExtensionAreaId.MODULE);
  myName = name;
  myProject = project;
  myDirVirtualFilePointer = dirUrl == null ? null : VirtualFilePointerManager.getInstance().create(dirUrl, this, null);
}
 

VirtualFilePointerContainerImpl(@Nonnull VirtualFilePointerManager manager, @Nonnull Disposable parentDisposable, @Nullable VirtualFilePointerListener listener) {
  myTraceableDisposable = TraceableDisposable.newTraceDisposable(TRACE_CREATION && !ApplicationInfoImpl.isInStressTest());
  myVirtualFilePointerManager = manager;
  myParent = parentDisposable;
  myListener = listener;
}
 

public ContentEntryImpl(@Nonnull String url, @Nonnull ModuleRootLayerImpl m) {
  super(m);
  myRoot = VirtualFilePointerManager.getInstance().create(url, this, null);
}
 

@Nonnull
protected VirtualFilePointerManager createVirtualFilePointerManager() {
  return new CoreVirtualFilePointerManager();
}