import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
private void createRemoteDebug(
    final RunManagerImpl runManager,
    final HybrisProjectDescriptor hybrisProjectDescriptor
) {
    final RemoteConfigurationType remoteConfigurationType = ConfigurationTypeUtil.findConfigurationType(
        RemoteConfigurationType.class);
    final ConfigurationFactory configurationFactory = remoteConfigurationType.getConfigurationFactories()[0];
    final String debugName = HybrisI18NBundleUtils.message("hybris.project.import.run.configuration.remote.debug");
    final RunnerAndConfigurationSettings runner = runManager.createRunConfiguration(
        debugName,
        configurationFactory
    );
    final RemoteConfiguration remoteConfiguration = (RemoteConfiguration) runner.getConfiguration();
    remoteConfiguration.PORT = getDebugPort(hybrisProjectDescriptor);

    ApplicationManager.getApplication().invokeLater(() -> ApplicationManager.getApplication().runWriteAction(() -> {
        runner.setSingleton(true);
        runner.setActivateToolWindowBeforeRun(true);
        runManager.addConfiguration(runner, true);
        runManager.setSelectedConfiguration(runner);
    }));
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
@Override
protected boolean setupConfigurationFromContext(BeakerRunConfiguration configuration, ConfigurationContext context, Ref<PsiElement> element) {

    RunConfiguration original = context.getOriginalConfiguration(null);
    if (original != null && !ConfigurationTypeUtil.equals(original.getType(),
            ConfigurationTypeUtil.findConfigurationType(BeakerConfigurationType.class))) {
        return false;
    }

    BeakerRunSettings settings = getBeakerRunSettings(configuration.getRunSettings(), context);
    configuration.setRunSettings(settings);

    configuration.setName(configuration.suggestedName());

    return true;
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
private void removeMake(final Project project) {
    final RunManagerImpl runManager = RunManagerImpl.getInstanceImpl(project);
    if (runManager == null) {
        return;
    }
    final AntRunConfigurationType antRunConfigurationType = ConfigurationTypeUtil.findConfigurationType(
        AntRunConfigurationType.class);
    final ConfigurationFactory configurationFactory = antRunConfigurationType.getConfigurationFactories()[0];
    final RunnerAndConfigurationSettings template = runManager.getConfigurationTemplate(configurationFactory);
    final AntRunConfiguration runConfiguration = (AntRunConfiguration) template.getConfiguration();
    runManager.setBeforeRunTasks(runConfiguration, Collections.<BeforeRunTask>emptyList(), false);
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
/**
 * Creates a run configuration, using the given template. The created configuration is then
 * added to RunManager.
 */
public void createConfiguration() {
    logger.info("Creating configuration.");
    ConfigurationType type = ConfigurationTypeUtil.findConfigurationType(configurationType);
    RunnerAndConfigurationSettings settings =
            runManager.createRunConfiguration(
                    module.getName(), type.getConfigurationFactories()[0]);
    logger.info("Adding configuration to RunManager.");
    runManager.addConfiguration(settings, true);
    logger.info("Setting created configuration to be the selected.");
    runManager.setSelectedConfiguration(settings);
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
public Icon getIcon(String file) {
  final ConfigurationBean bean = myState.getHistoryElements().get(file);
  if (bean != null) {
    ConfigurationType type = ConfigurationTypeUtil.findConfigurationType(bean.configurationId);
    if (type != null) return type.getIcon();
  }
  return null;
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
/**
 * Returns original {@link RunConfiguration} from this context.
 * For example, it could be some test framework runtime configuration that had been launched
 * and that had brought a result test tree on which a right-click action was performed.
 *
 * @param type {@link ConfigurationType} instance to filter original runtime configuration by its type
 * @return {@link RunConfiguration} instance, it could be null
 */
@Nullable
public RunConfiguration getOriginalConfiguration(@Nullable ConfigurationType type) {
  if (type == null) {
    return myRuntimeConfiguration;
  }
  if (myRuntimeConfiguration != null
      && ConfigurationTypeUtil.equals(myRuntimeConfiguration.getType(), type)) {
    return myRuntimeConfiguration;
  }
  return null;
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
@NotNull
public static RunnerAndConfigurationSettings createRunnerAndConfigurationSettings(@Nullable MavenGeneralSettings generalSettings,
                                                                                  @Nullable MavenRunnerSettings runnerSettings,
                                                                                  MavenRunnerParameters params,
                                                                                  Project project) {
  MavenRunConfigurationType type = ConfigurationTypeUtil.findConfigurationType(MavenRunConfigurationType.class);

  RunnerAndConfigurationSettings settings = RunManager.getInstance(project).createRunConfiguration(generateName(project, params), type.myFactory);
  MavenRunConfiguration runConfiguration = (MavenRunConfiguration)settings.getConfiguration();
  runConfiguration.setRunnerParameters(params);
  runConfiguration.setGeneralSettings(generalSettings);
  runConfiguration.setRunnerSettings(runnerSettings);
  return settings;
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
private static RunnerAndConfigurationSettings createRunnerAndConfigurationSettings(@Nullable MavenGeneralSettings generalSettings,
                                                                                  @Nullable MavenRunnerSettings runnerSettings,
                                                                                  MavenRunnerParameters params,
                                                                                  Project project) {
    MvnRunConfigurationType type = ConfigurationTypeUtil.findConfigurationType(MvnRunConfigurationType.class);
    final RunnerAndConfigurationSettings settings = RunManagerEx.getInstanceEx(project).createRunConfiguration(generateName(project, params), type.myFactory);
    MvnRunConfiguration runConfiguration = (MvnRunConfiguration)settings.getConfiguration();
    runConfiguration.setRunType(getPhaseRunType(params.getGoals()));
    runConfiguration.setRunnerParameters(params);
    runConfiguration.setGeneralSettings(generalSettings);
    runConfiguration.setRunnerSettings(runnerSettings);
    return settings;
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
public static RunnerAndConfigurationSettings createRunnerAndConfigurationSettings(@Nullable MavenGeneralSettings generalSettings,
                                                                           @Nullable MavenRunnerSettings runnerSettings,
                                                                           MavenRunnerParameters params,
                                                                           Project project) {
  MavenRunConfigurationType type = ConfigurationTypeUtil.findConfigurationType(MavenRunConfigurationType.class);

  final RunnerAndConfigurationSettings settings = RunManagerEx.getInstanceEx(project)
    .createConfiguration(generateName(project, params), type.myFactory);
  MavenRunConfiguration runConfiguration = (MavenRunConfiguration)settings.getConfiguration();
  runConfiguration.setRunnerParameters(params);
  runConfiguration.setGeneralSettings(generalSettings);
  runConfiguration.setRunnerSettings(runnerSettings);

  return settings;
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
/**
 * Returns original {@link RunConfiguration} from this context.
 * For example, it could be some test framework runtime configuration that had been launched
 * and that had brought a result test tree on which a right-click action was performed.
 *
 * @param type {@link ConfigurationType} instance to filter original runtime configuration by its type
 * @return {@link RunConfiguration} instance, it could be null
 */
@Nullable
public RunConfiguration getOriginalConfiguration(@Nullable ConfigurationType type) {
  if (type == null) {
    return myRuntimeConfiguration;
  }
  if (myRuntimeConfiguration != null && ConfigurationTypeUtil.equals(myRuntimeConfiguration.getType(), type)) {
    return myRuntimeConfiguration;
  }
  return null;
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
public static PyCCRunTestsConfigurationType getInstance() {
  return ConfigurationTypeUtil.findConfigurationType(PyCCRunTestsConfigurationType.class);
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
public static ProcessingConfigurationType getInstance() {
    return ConfigurationTypeUtil.findConfigurationType(ProcessingConfigurationType.class);
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
@NotNull
public static MuleRemoteConfigurationType getInstance() {
  return ConfigurationTypeUtil.findConfigurationType(MuleRemoteConfigurationType.class);
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
@NotNull
public static MuleConfigurationType getInstance() {
    return ConfigurationTypeUtil.findConfigurationType(MuleConfigurationType.class);
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
@NotNull
public static WeaveConfigurationType getInstance()
{
    return ConfigurationTypeUtil.findConfigurationType(WeaveConfigurationType.class);
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
static TesterTestMethodRunConfigurationType getInstance() {
    return ConfigurationTypeUtil.findConfigurationType(TesterTestMethodRunConfigurationType.class);
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
static TesterRunConfigurationType getInstance() {
    return ConfigurationTypeUtil.findConfigurationType(TesterRunConfigurationType.class);
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
public static ConfigurationTypeLivingDoc getInstance() {
    return ConfigurationTypeUtil.findConfigurationType(ConfigurationTypeLivingDoc.class);
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
public static MigrationRunConfigurationType getInstance() {
    return ConfigurationTypeUtil.findConfigurationType(MigrationRunConfigurationType.class);
}
 

import com.intellij.execution.configurations.ConfigurationTypeUtil; //导入依赖的package包/类
public static AtoumLocalRunConfigurationType getInstance() {
    return (AtoumLocalRunConfigurationType) ConfigurationTypeUtil.findConfigurationType(AtoumLocalRunConfigurationType.class);
}