Java PluginException类代码示例

import com.intellij.diagnostic.PluginException; //导入依赖的package包/类
@NotNull
protected Class compute() {
  if (key == null) {
    String error = "No key specified for mixin with implementation class " + implementationClass;
    if (myPluginDescriptor != null) {
      throw new PluginException(error, myPluginDescriptor.getPluginId());
    }
    throw new IllegalArgumentException(error);
  }
  try {
    return findClass(key);
  }
  catch (ClassNotFoundException e) {
    throw new RuntimeException(e);
  }
}
 

import com.intellij.diagnostic.PluginException; //导入依赖的package包/类
@Nullable
private synchronized Class loadClassInsideSelf(@Nonnull String name) {
  Class c = findLoadedClass(name);
  if (c != null) {
    return c;
  }

  try {
    c = _findClass(name);
  }
  catch (IncompatibleClassChangeError | UnsupportedClassVersionError e) {
    throw new PluginException("While loading class " + name + ": " + e.getMessage(), e, myPluginId);
  }
  if (c != null) {
    PluginManagerCore.addPluginClass(myPluginId);
  }

  return c;
}
 

import com.intellij.diagnostic.PluginException; //导入依赖的package包/类
private static Exception wrapException(InvalidMirrorException e, VirtualFile file) {
  ClassFileDecompilers.Decompiler decompiler = ClassFileDecompilers.find(file);
  if (decompiler instanceof ClassFileDecompilers.Light) {
    PluginId pluginId = PluginManagerCore.getPluginByClassName(decompiler.getClass().getName());
    if (pluginId != null) {
      return new PluginException(e, pluginId);
    }
  }

  return e;
}
 

import com.intellij.diagnostic.PluginException; //导入依赖的package包/类
private static void reportActionError(final PluginId pluginId, @NonNls @NotNull String message) {
  if (pluginId == null) {
    LOG.error(message);
  }
  else {
    LOG.error(new PluginException(message, null, pluginId));
  }
}
 

import com.intellij.diagnostic.PluginException; //导入依赖的package包/类
private static void reportActionWarning(final PluginId pluginId, @NonNls @NotNull String message) {
  if (pluginId == null) {
    LOG.warn(message);
  }
  else {
    LOG.warn(new PluginException(message, null, pluginId).getMessage());
  }
}
 

import com.intellij.diagnostic.PluginException; //导入依赖的package包/类
@NotNull
public static State getStateSpecOrError(@NotNull Class<? extends PersistentStateComponent> componentClass) {
  State spec = getStateSpec(componentClass);
  if (spec != null) {
    return spec;
  }

  PluginId pluginId = PluginManagerCore.getPluginByClassName(componentClass.getName());
  if (pluginId == null) {
    throw new RuntimeException("No @State annotation found in " + componentClass);
  }
  else {
    throw new PluginException("No @State annotation found in " + componentClass, pluginId);
  }
}
 

import com.intellij.diagnostic.PluginException; //导入依赖的package包/类
public static void processException(Throwable t) {
  if (!IdeaApplication.isLoaded()) {
    @SuppressWarnings("ThrowableResultOfMethodCallIgnored") StartupAbortedException se = findCause(t, StartupAbortedException.class);
    if (se == null) se = new StartupAbortedException(t);
    @SuppressWarnings("ThrowableResultOfMethodCallIgnored") PluginException pe = findCause(t, PluginException.class);
    PluginId pluginId = pe != null ? pe.getPluginId() : null;

    if (Logger.isInitialized() && !(t instanceof ProcessCanceledException)) {
      try {
        getLogger().error(t);
      }
      catch (Throwable ignore) { }
    }

    if (pluginId != null && !CORE_PLUGIN_ID.equals(pluginId.getIdString())) {
      disablePlugin(pluginId.getIdString());

      StringWriter message = new StringWriter();
      message.append("Plugin '").append(pluginId.getIdString()).append("' failed to initialize and will be disabled. ");
      message.append(" Please restart ").append(ApplicationNamesInfo.getInstance().getFullProductName()).append('.');
      message.append("\n\n");
      pe.getCause().printStackTrace(new PrintWriter(message));

      Main.showMessage("Plugin Error", message.toString(), false);
      System.exit(Main.PLUGIN_ERROR);
    }
    else {
      Main.showMessage("Start Failed", t);
      System.exit(se.exitCode());
    }
  }
  else if (!(t instanceof ProcessCanceledException)) {
    getLogger().error(t);
  }
}
 

import com.intellij.diagnostic.PluginException; //导入依赖的package包/类
public static void handleComponentError(Throwable t, @Nullable String componentClassName, @Nullable PluginId pluginId) {
  Application app = ApplicationManager.getApplication();
  if (app != null && app.isUnitTestMode()) {
    if (t instanceof Error) throw (Error)t;
    if (t instanceof RuntimeException) throw (RuntimeException)t;
    throw new RuntimeException(t);
  }

  if (t instanceof StartupAbortedException) {
    throw (StartupAbortedException)t;
  }

  if (pluginId == null || CORE_PLUGIN_ID.equals(pluginId.getIdString())) {
    if (componentClassName != null) {
      pluginId = getPluginByClassName(componentClassName);
    }
  }
  if (pluginId == null || CORE_PLUGIN_ID.equals(pluginId.getIdString())) {
    if (t instanceof PicoPluginExtensionInitializationException) {
      pluginId = ((PicoPluginExtensionInitializationException)t).getPluginId();
    }
  }

  if (pluginId != null && !CORE_PLUGIN_ID.equals(pluginId.getIdString())) {
    throw new StartupAbortedException(new PluginException(t, pluginId));
  }
  else {
    throw new StartupAbortedException("Fatal error initializing '" + componentClassName + "'", t);
  }
}
 

import com.intellij.diagnostic.PluginException; //导入依赖的package包/类
public void testPresentation() {
  ActionManager manager = ActionManager.getInstance();

  List<String> failures = new SmartList<String>();
  for (String id : manager.getActionIds("")) {
    if (!ACTION_WITHOUT_TEXT_AND_DESCRIPTION.equals(id)) {
      try {
        AnAction stub = manager.getActionOrStub(id);
        AnAction action = manager.getAction(id);
        String message = id + " (" + action.getClass().getName() + ")";
        if (stub != action) {
          Presentation before = stub.getTemplatePresentation();
          Presentation after = action.getTemplatePresentation();
          checkPresentationProperty("icon", message, before.getIcon(), after.getIcon());
          checkPresentationProperty("text", message, before.getText(), after.getText());
          checkPresentationProperty("description", message, before.getDescription(), after.getDescription());
        }
        if (action instanceof ActionGroup) {
          System.out.println("ignored action group: " + message);
        }
        else if (StringUtil.isEmpty(action.getTemplatePresentation().getText())) {
          failures.add("no text: " + message);
        }
      }
      catch (PluginException exception) {
        System.out.println(id + " ignored because " + exception.getMessage());
      }
    }
  }

  assertEmpty(failures);
}
 

import com.intellij.diagnostic.PluginException; //导入依赖的package包/类
public void _saveSettings() { // public for testing purposes
  if (mySaveSettingsIsInProgress.compareAndSet(false, true)) {
    try {
      StoreUtil.doSave(getStateStore());
    }
    catch (final Throwable ex) {
      if (isUnitTestMode()) {
        System.out.println("Saving application settings failed");
        ex.printStackTrace();
      }
      else {
        LOG.info("Saving application settings failed", ex);
        invokeLater(new Runnable() {
          @Override
          public void run() {
            if (ex instanceof PluginException) {
              final PluginException pluginException = (PluginException)ex;
              PluginManagerCore.disablePlugin(pluginException.getPluginId().getIdString());
              Messages.showMessageDialog("The plugin " +
                                         pluginException.getPluginId() +
                                         " failed to save settings and has been disabled. Please restart " +
                                         ApplicationNamesInfo.getInstance().getFullProductName(), CommonBundle.getErrorTitle(),
                                         Messages.getErrorIcon());
            }
            else {
              Messages.showMessageDialog(ApplicationBundle.message("application.save.settings.error", ex.getLocalizedMessage()),
                                         CommonBundle.getErrorTitle(), Messages.getErrorIcon());

            }
          }
        });
      }
    }
    finally {
      mySaveSettingsIsInProgress.set(false);
    }
  }
}
 

import com.intellij.diagnostic.PluginException; //导入依赖的package包/类
private static <T> State getStateSpec(@NotNull final PersistentStateComponent<T> persistentStateComponent) {
  final Class<? extends PersistentStateComponent> aClass = persistentStateComponent.getClass();
  final State stateSpec = aClass.getAnnotation(State.class);
  if (stateSpec == null) {
    final PluginId pluginId = PluginManager.getPluginByClassName(aClass.getName());
    if (pluginId != null) {
      throw new PluginException("No @State annotation found in " + aClass, pluginId);
    }
    throw new RuntimeException("No @State annotation found in " + aClass);
  }
  return stateSpec;
}
 

import com.intellij.diagnostic.PluginException; //导入依赖的package包/类
private static void reportActionError(final PluginId pluginId, @NonNls final String message) {
  if (pluginId == null) {
    LOG.error(message);
  }
  else {
    LOG.error(new PluginException(message, null, pluginId));
  }
}
 

import com.intellij.diagnostic.PluginException; //导入依赖的package包/类
private static Exception wrapException(InvalidMirrorException e, VirtualFile file)
{
	ClassFileDecompilers.Decompiler decompiler = ClassFileDecompilers.find(file);
	if(decompiler instanceof ClassFileDecompilers.Light)
	{
		PluginId pluginId = PluginManagerCore.getPluginByClassName(decompiler.getClass().getName());
		if(pluginId != null)
		{
			return new PluginException(e, pluginId);
		}
	}

	return e;
}
 

import com.intellij.diagnostic.PluginException; //导入依赖的package包/类
@Nullable
private ExtensionPoint<KeyedLazyInstance<T>> getPoint() {
  ExtensionPoint<KeyedLazyInstance<T>> point = myPoint;
  if (point == null && Extensions.getRootArea().hasExtensionPoint(myEpName)) {
    ExtensionPointName<KeyedLazyInstance<T>> typesafe = ExtensionPointName.create(myEpName);
    myPoint = point = Extensions.getRootArea().getExtensionPoint(typesafe);
    myListener = new ExtensionPointAndAreaListener<KeyedLazyInstance<T>>() {
      @Override
      public void extensionAdded(@NotNull final KeyedLazyInstance<T> bean, @Nullable final PluginDescriptor pluginDescriptor) {
        synchronized (lock) {
          if (bean.getKey() == null) {
            if (pluginDescriptor != null) {
              throw new PluginException("No key specified for extension of class " + bean.getInstance().getClass(),
                                        pluginDescriptor.getPluginId());
            }
            LOG.error("No key specified for extension of class " + bean.getInstance().getClass());
            return;
          }
          myCache.remove(bean.getKey());
          for (ExtensionPointListener<T> listener : myListeners) {
            listener.extensionAdded(bean.getInstance(), null);
          }
        }
      }

      @Override
      public void extensionRemoved(@NotNull final KeyedLazyInstance<T> bean, @Nullable final PluginDescriptor pluginDescriptor) {
        synchronized (lock) {
          myCache.remove(bean.getKey());
          for (ExtensionPointListener<T> listener : myListeners) {
            listener.extensionRemoved(bean.getInstance(), null);
          }
        }
      }

      @Override
      public void areaReplaced(final ExtensionsArea area) {
        resetAreaListener();
      }
    };

    point.addExtensionPointListener(myListener);
  }
  return point;
}
 

import com.intellij.diagnostic.PluginException; //导入依赖的package包/类
@Override
public Object getComponentInstance(PicoContainer picoContainer) throws PicoInitializationException, PicoIntrospectionException, ProcessCanceledException {
  Object instance = myInitializedComponentInstance;
  if (instance != null) {
    return instance;
  }

  try {
    //noinspection SynchronizeOnThis
    synchronized (this) {
      instance = myInitializedComponentInstance;
      if (instance != null) {
        return instance;
      }

      long startTime = System.nanoTime();

      instance = super.getComponentInstance(picoContainer);

      if (myInitializing) {
        String errorMessage = "Cyclic component initialization: " + getComponentKey();
        if (myPluginId != null) {
          LOG.error(new PluginException(errorMessage, myPluginId));
        }
        else {
          LOG.error(new Throwable(errorMessage));
        }
      }

      try {
        myInitializing = true;
        registerComponentInstance(instance);

        ProgressIndicator indicator = getProgressIndicator();
        if (indicator != null) {
          indicator.checkCanceled();
          setProgressDuringInit(indicator);
        }
        initializeComponent(instance, false);
        if (instance instanceof BaseComponent) {
          ((BaseComponent)instance).initComponent();
        }

        long ms = (System.nanoTime() - startTime) / 1000000;
        if (ms > 10 && logSlowComponents()) {
          LOG.info(instance.getClass().getName() + " initialized in " + ms + " ms");
        }
      }
      finally {
        myInitializing = false;
      }
      myInitializedComponentInstance = instance;
    }
  }
  catch (ProcessCanceledException e) {
    throw e;
  }
  catch (Throwable t) {
    handleInitComponentError(t, ((Class)getComponentKey()).getName(), myPluginId);
  }

  return instance;
}