com.intellij.psi.impl.cache.CacheManager#com.intellij.openapi.util.Disposer源码实例Demo

public void init41(@Nullable ProgressIndicator indicator) {
  boolean finished = false;
  try {
    //ProjectManagerImpl.initProject(path, this, true, null, null);
    Method method = ReflectionUtil
      .getDeclaredMethod(ProjectManagerImpl.class, "initProject", Path.class, ProjectImpl.class, boolean.class, Project.class,
                         ProgressIndicator.class);
    assert (method != null);
    try {
      method.invoke(null, path, this, true, null, null);
    }
    catch (IllegalAccessException | InvocationTargetException e) {
      throw new RuntimeException(e);
    }
    finished = true;
  }
  finally {
    if (!finished) {
      TransactionGuard.submitTransaction(this, () -> WriteAction.run(() -> Disposer.dispose(this)));
    }
  }
}
 

private static <T> void registerComponentInstance(
    MutablePicoContainer container, Class<T> key, T implementation, Disposable parentDisposable) {
  Object old;
  try {
    old = container.getComponentInstance(key);
  } catch (UnsatisfiableDependenciesException e) {
    old = null;
  }
  container.unregisterComponent(key.getName());
  container.registerComponentInstance(key.getName(), implementation);
  Object finalOld = old;
  Disposer.register(
      parentDisposable,
      () -> {
        container.unregisterComponent(key.getName());
        if (finalOld != null) {
          container.registerComponentInstance(key.getName(), finalOld);
        }
      });
}
 

public void removeModulePane(Module module) {
    // Find corresponding content by module...
    for (RoutesViewPane pane : myPanes)
        if (pane.getModule() == module) {
            // ... and remove it from panels list.
            myContentManager.removeContent(pane.getContent(), true);
            myPanes.remove(pane);

            // Remove contributor
            ChooseByRouteRegistry.getInstance(myProject)
                    .removeContributor(pane.getRoutesManager());

            Disposer.dispose(pane);
            break;
        }
}
 

@Override
public void dispose() {
    if (!disposed) {
        this.disposed = true;
        Disposer.dispose(this);
        changelistMap = null;
        fileMap = null;
        queryHandler = null;
        pendingHandler = null;
        updateListener = null;

        int postReleaseCount = ACTIVE_COUNT.decrementAndGet();
        if (LOG.isDebugEnabled()) {
            LOG.debug("Disposed " + this + " for " + project + "; " + postReleaseCount
                    + " total still in memory");
        }
    }
}
 

@Test
public void testEditorApplyToAndResetFromMatches() throws ConfigurationException {
  BlazeCommandRunConfigurationSettingsEditor editor =
      new BlazeCommandRunConfigurationSettingsEditor(configuration);
  Label label = Label.create("//package:rule");
  configuration.setTarget(label);

  editor.resetFrom(configuration);
  BlazeCommandRunConfiguration readConfiguration =
      type.getFactory().createTemplateConfiguration(getProject());
  editor.applyEditorTo(readConfiguration);

  assertThat(readConfiguration.getTargets()).containsExactly(label);

  Disposer.dispose(editor);
}
 

@NotNull
static FlutterConsole create(@NotNull Project project, @Nullable Module module) {
  final TextConsoleBuilder builder = TextConsoleBuilderFactory.getInstance().createBuilder(project);
  builder.setViewer(true);
  if (module != null) {
    builder.addFilter(new FlutterConsoleFilter(module));
  }
  final ConsoleView view = builder.getConsole();

  final SimpleToolWindowPanel panel = new SimpleToolWindowPanel(false, true);
  panel.setContent(view.getComponent());

  final String title = module != null ? "[" + module.getName() + "] Flutter" : "Flutter";
  final Content content = ContentFactory.SERVICE.getInstance().createContent(panel.getComponent(), title, true);
  Disposer.register(content, view);

  return new FlutterConsole(view, content, project, module);
}
 

@Override
public void dispose() {
  if (isDisposed) {
    return;
  }

  this.isDisposed = true;

  if (uiAnimationTimer.isRunning()) {
    uiAnimationTimer.stop();
  }
  Disposer.dispose(perfProvider);

  AsyncUtils.invokeLater(() -> {
    clearModels();

    for (EditorPerfModel decorations : editorDecorations.values()) {
      Disposer.dispose(decorations);
    }
    editorDecorations.clear();
    perfListeners.clear();
  });
}
 

public StableWidgetTracker(
  InspectorService.Location initialLocation,
  FlutterDartAnalysisServer flutterAnalysisServer,
  Project project,
  Disposable parentDisposable
) {
  Disposer.register(parentDisposable, this);
  converter = new OutlineOffsetConverter(project, initialLocation.getFile());
  currentOutlines = new EventStream<>(ImmutableList.of());
  this.flutterAnalysisServer = flutterAnalysisServer;
  this.initialLocation = initialLocation;

  final DartAnalysisServerService analysisServerService = DartAnalysisServerService.getInstance(project);
  currentFilePath = FileUtil.toSystemDependentName(initialLocation.getFile().getPath());
  flutterAnalysisServer.addOutlineListener(currentFilePath, outlineListener);
}
 

public static void sendDebugActive(@NotNull Project project,
                                   @NotNull FlutterApp app,
                                   @NotNull VmService vmService) {
  final MessageBus bus = project.getMessageBus();
  final FlutterDebugNotifier publisher = bus.syncPublisher(FLUTTER_DEBUG_TOPIC);

  assert (app.getFlutterDebugProcess() != null);

  final VMServiceManager vmServiceManager = new VMServiceManager(app, vmService);
  Disposer.register(app.getFlutterDebugProcess().getVmServiceWrapper(), vmServiceManager);
  app.setVmServices(vmService, vmServiceManager);
  publisher.debugActive(new FlutterDebugEvent(app, vmService));

  // TODO(pq): consider pushing into perf service.
  app.getFlutterLog().listenToVm(vmService);
}
 

PerfMemoryPanel(@NotNull FlutterApp app, @NotNull Disposable parentDisposable) {
  setLayout(new BorderLayout());
  setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(), MEMORY_TAB_LABEL));
  setMinimumSize(new Dimension(0, PerfMemoryPanel.HEIGHT));
  setPreferredSize(new Dimension(Short.MAX_VALUE, PerfMemoryPanel.HEIGHT));

  final JPanel heapDisplay = HeapDisplay.createJPanelView(parentDisposable, app);
  add(heapDisplay, BorderLayout.CENTER);

  if (app.getVMServiceManager() != null) {
    app.getVMServiceManager().getHeapMonitor().addPollingClient();
  }

  Disposer.register(parentDisposable, () -> {
    if (app.getVMServiceManager() != null) {
      app.getVMServiceManager().getHeapMonitor().removePollingClient();
    }
  });
}
 

synchronized void setup(ToolWindow toolWindow) {
  contentManager = toolWindow.getContentManager();
  Disposer.register(contentManager, this);
  refreshButton = createButton("Update", this::update);
  contentContainer =
      ContentFactory.SERVICE
          .getInstance()
          .createContent(createView(refreshButton, STUB), "", false);
  contentManager.addContent(contentContainer);
  DumbService.getInstance(project).smartInvokeLater(this::update);
}
 

@Nullable
@Override
public ModuleWizardStep getCustomOptionsStep(WizardContext context, Disposable parentDisposable) {
    // Prepare the Sling / AEM Archetypes for IntelliJ
    if(archetypeTemplateList.isEmpty()) {
        archetypeTemplateList = obtainArchetypes();
    }
    List<ArchetypeTemplate> list = context.getProject() == null ? archetypeTemplateList : new ArrayList<ArchetypeTemplate>();
    // Instead of displaying a List of All Maven Archetypes we just show the ones applicable.
    SlingArchetypesStep step = new SlingArchetypesStep(this, list);
    Disposer.register(parentDisposable, step);
    return step;
}
 

@Override
public void fileOpened(@NotNull FileEditorManager source, @NotNull VirtualFile sourceFile) {
    ServiceManager.getService(m_project, InsightManager.class).downloadRincewindIfNeeded(sourceFile);

    FileType fileType = sourceFile.getFileType();
    if (FileHelper.isCompilable(fileType)) {
        FileEditor selectedEditor = source.getSelectedEditor(sourceFile);
        Document document = FileDocumentManager.getInstance().getDocument(sourceFile);
        if (selectedEditor instanceof TextEditor && document != null) {
            InsightUpdateQueue insightUpdateQueue = new InsightUpdateQueue(m_project, sourceFile);
            Disposer.register(selectedEditor, insightUpdateQueue);
            document.addDocumentListener(new ORDocumentEventListener(insightUpdateQueue), selectedEditor);

            ORPropertyChangeListener propertyChangeListener = new ORPropertyChangeListener(sourceFile, document, insightUpdateQueue);
            selectedEditor.addPropertyChangeListener(propertyChangeListener);
            Disposer.register(selectedEditor, () -> {
                selectedEditor.removePropertyChangeListener(propertyChangeListener);
            });

            // Store the queue in the document, for easy access
            document.putUserData(INSIGHT_QUEUE, insightUpdateQueue);

            // Initial query when opening the editor
            insightUpdateQueue.queue(m_project, document);

            m_queues.add(insightUpdateQueue);
        }
    }

    m_openedFiles.add(sourceFile);
}
 

private ContentEntry getContentEntry(VirtualFile root) {
  ContentEntry entry =
      ModuleRootManager.getInstance(testFixture.getModule())
          .getModifiableModel()
          .addContentEntry(root);
  if (entry instanceof Disposable) {
    // need to dispose the content entry and child disposables before the TestFixture is disposed
    Disposer.register(thisClassDisposable, (Disposable) entry);
  }
  return entry;
}
 

/**
 * Sets the platform prefix system property, reverting to the previous value when the supplied
 * parent disposable is disposed.
 */
public static void setPlatformPrefix(Disposable parentDisposable, String platformPrefix) {
  String prevValue = System.getProperty(PlatformUtils.PLATFORM_PREFIX_KEY);
  System.setProperty(PlatformUtils.PLATFORM_PREFIX_KEY, platformPrefix);
  Disposer.register(
      parentDisposable,
      () -> {
        if (prevValue != null) {
          System.setProperty(PlatformUtils.PLATFORM_PREFIX_KEY, prevValue);
        } else {
          System.clearProperty(PlatformUtils.PLATFORM_PREFIX_KEY);
        }
      });
}
 

private ConsoleProvider getStockConsoleProvider() {
  return (parent, handler, executor) -> {
    AndroidTestConsoleProperties properties =
        new AndroidTestConsoleProperties(runConfiguration, executor);
    ConsoleView consoleView =
        SMTestRunnerConnectionUtil.createAndAttachConsole("Android", handler, properties);
    Disposer.register(parent, consoleView);
    return consoleView;
  };
}
 

protected BPMNPaletteToolWindowManager(Project project, FileEditorManager fileEditorManager) {
    super(project);

    myFileEditorManager = fileEditorManager;
    palette = new BPMNPalette(project);
    Disposer.register(myProject, palette);
}
 

@Override
public void dispose() {
    if (myBuilder != null) {
        Disposer.dispose(myBuilder);
        myBuilder = null;
    }
    super.dispose();
}
 

public ImportForm(final boolean vsoSelected) {
    // The following call is required to initialize the controls on the form
    // DO NOT MOVE THIS CALL
    $$$setupUI$$$();
    Disposer.register(this, busySpinner);
    userAccountPanel.setWindowsAccount(!vsoSelected);
}
 

@Override
public void commit() {
  // don't commit module changes,
  // and make sure they're properly disposed when the test is finished
  for (ModifiableRootModel model : modules.values()) {
    Disposer.register(ProjectModuleMocker.this, model.getModule());
    if (model.getModule().getName().equals(BlazeDataStorage.WORKSPACE_MODULE_NAME)) {
      workspaceContentEntries = ImmutableList.copyOf(model.getContentEntries());
    }
  }
  ProjectModuleMocker.this.modules = modules;
}
 

private DeviceService(@NotNull final Project project) {
  this.project = project;

  deviceDaemon.setDisposeParent(project);
  deviceDaemon.subscribe(this::refreshDeviceSelection);
  refreshDeviceDaemon();

  // Watch for Flutter SDK changes.
  final FlutterSdkManager.Listener sdkListener = new FlutterSdkManager.Listener() {
    @Override
    public void flutterSdkAdded() {
      refreshDeviceDaemon();
    }

    @Override
    public void flutterSdkRemoved() {
      refreshDeviceDaemon();
    }
  };
  FlutterSdkManager.getInstance(project).addListener(sdkListener);
  Disposer.register(project, () -> FlutterSdkManager.getInstance(project).removeListener(sdkListener));

  // Watch for Bazel workspace changes.
  WorkspaceCache.getInstance(project).subscribe(this::refreshDeviceDaemon);

  // Watch for Java SDK changes. (Used to get the value of ANDROID_HOME.)
  ProjectRootManagerEx.getInstanceEx(project).addProjectJdkListener(this::refreshDeviceDaemon);
}
 

@BeforeClass
public static void setUp() {
  Disposable disposable = Disposer.newDisposable();
  ApplicationManager.setApplication(new MockApplication(disposable), disposable);
  Extensions.registerAreaClass("IDEA_PROJECT", null);
  ourProject = new MockProject(ApplicationManager.getApplication().getPicoContainer(), disposable);
}
 

@Override
public void dispose() {
  if (currentValueSubscription != null) {
    Disposer.dispose(currentValueSubscription);
    currentValueSubscription = null;
  }
}
 

@Nullable
@Override
public ModuleWizardStep getCustomOptionsStep(final WizardContext context, final Disposable parentDisposable) {
  if (!context.isCreatingNewProject()) {
    myProject = context.getProject();
  }
  myStep = new FlutterModuleWizardStep(context);
  mySettingsFields = new FlutterCreateAdditionalSettingsFields(new FlutterCreateAdditionalSettings(), this::getFlutterSdk, myProject);
  Disposer.register(parentDisposable, myStep);
  return myStep;
}
 

/**
 * Asynchronously shuts down the Refreshable.
 *
 * <p>Sets the published value to null and cancels any background tasks.
 *
 * <p>Also sets the state to CLOSED and notifies subscribers. Removes subscribers after delivering the last event.
 */
public void close() {
  if (!publisher.close()) {
    return; // already closed.
  }

  // Cancel any running create task.
  schedule.reschedule(null);

  // Remove from dispose tree. Calls close() again, harmlessly.
  Disposer.dispose(disposeNode);
}
 

public void addRegisteredExtensionRPCs(Isolate isolate, boolean attach) {
  // If attach was called, there is a risk we may never receive a
  // Flutter.Frame or Flutter.FirstFrame event so we need to query the
  // framework to determine if a frame has already been rendered.
  // This check would be safe to do outside of attach mode but is not needed.
  if (attach && isolate.getExtensionRPCs() != null && !firstFrameEventReceived) {
    final Set<String> bindingLibraryNames = new HashSet<>();
    bindingLibraryNames.add("package:flutter/src/widgets/binding.dart");

    final EvalOnDartLibrary flutterLibrary = new EvalOnDartLibrary(
      bindingLibraryNames,
      vmService,
      this
    );
    flutterLibrary.eval("WidgetsBinding.instance.debugDidSendFirstFrameEvent", null, null).whenCompleteAsync((v, e) -> {
      // If there is an error we assume the first frame has been received.
      final boolean didSendFirstFrameEvent = e == null ||
                                             v == null ||
                                             Objects.equals(v.getValueAsString(), "true");
      if (didSendFirstFrameEvent) {
        onFrameEventReceived();
      }
      Disposer.dispose(flutterLibrary);
    });
  }
  if (isolate.getExtensionRPCs() != null) {
    for (String extension : isolate.getExtensionRPCs()) {
      addServiceExtension(extension);
    }
  }
}
 

public final void releaseEditor(final Project project, final Editor editor) {
if (editor != null) {
    Disposer.register(project, new Disposable() {
        public void dispose() {
            EditorFactory.getInstance().releaseEditor(editor);
        }
    });
    }
}
 

@Override
public void update(final AnActionEvent e) {
  // Suppress device actions in all but the toolbars.
  final String place = e.getPlace();
  if (!Objects.equals(place, ActionPlaces.NAVIGATION_BAR_TOOLBAR) && !Objects.equals(place, ActionPlaces.MAIN_TOOLBAR)) {
    e.getPresentation().setVisible(false);
    return;
  }

  // Only show device menu when the device daemon process is running.
  final Project project = e.getProject();
  if (!isSelectorVisible(project)) {
    e.getPresentation().setVisible(false);
    return;
  }

  super.update(e);

  if (!knownProjects.contains(project)) {
    knownProjects.add(project);
    Disposer.register(project, () -> knownProjects.remove(project));

    DeviceService.getInstance(project).addListener(() -> update(project, e.getPresentation()));

    // Listen for android device changes, and rebuild the menu if necessary.
    AndroidEmulatorManager.getInstance(project).addListener(() -> update(project, e.getPresentation()));

    update(project, e.getPresentation());
  }
}
 

public void addRegisteredExtensionRPCs(Isolate isolate, boolean attach) {
  // If attach was called, there is a risk we may never receive a
  // Flutter.Frame or Flutter.FirstFrame event so we need to query the
  // framework to determine if a frame has already been rendered.
  // This check would be safe to do outside of attach mode but is not needed.
  if (attach && isolate.getExtensionRPCs() != null && !firstFrameEventReceived) {
    final Set<String> bindingLibraryNames = new HashSet<>();
    bindingLibraryNames.add("package:flutter/src/widgets/binding.dart");

    final EvalOnDartLibrary flutterLibrary = new EvalOnDartLibrary(
      bindingLibraryNames,
      vmService,
      this
    );
    flutterLibrary.eval("WidgetsBinding.instance.debugDidSendFirstFrameEvent", null, null).whenCompleteAsync((v, e) -> {
      // If there is an error we assume the first frame has been received.
      final boolean didSendFirstFrameEvent = e == null ||
                                             v == null ||
                                             Objects.equals(v.getValueAsString(), "true");
      if (didSendFirstFrameEvent) {
        onFrameEventReceived();
      }
      Disposer.dispose(flutterLibrary);
    });
  }
  if (isolate.getExtensionRPCs() != null) {
    for (String extension : isolate.getExtensionRPCs()) {
      addServiceExtension(extension);
    }
  }
}
 

@Override
public void stop() {
  myVmConnected = false;

  mapper.shutdown();

  if (myVmServiceWrapper != null) {
    Disposer.dispose(myVmServiceWrapper);
  }
}