Java ParametersList.addParametersString方法代码示例

import com.intellij.execution.configurations.ParametersList; //导入方法依赖的package包/类
public static Map<String, String> getPropertiesFromMavenOpts() {
  Map<String, String> res = ourPropertiesFromMvnOpts;
  if (res == null) {
    String mavenOpts = System.getenv("MAVEN_OPTS");
    if (mavenOpts != null) {
      ParametersList mavenOptsList = new ParametersList();
      mavenOptsList.addParametersString(mavenOpts);
      res = mavenOptsList.getProperties();
    }
    else {
      res = Collections.emptyMap();
    }

    ourPropertiesFromMvnOpts = res;
  }

  return res;
}
 

import com.intellij.execution.configurations.ParametersList; //导入方法依赖的package包/类
private static void configureProgramParameters(ParametersList parameters, PitestConfiguration configuration) {
    if (configuration.isVerboseLogging()) {
        parameters.add("--verbose");
    }
    String targetClasses = configuration.getTargetClasses();
    checkTargetClasses(targetClasses);
    parameters.add("--targetClasses", targetClasses);
    parameters.add("--targetTests", configuration.getTargetTests());
    String excludedClasses = configuration.getExcludedClasses();
    if (StringUtils.isNotBlank(excludedClasses)) {
        parameters.add("--excludedClasses", excludedClasses);
    }
    String reportDir = configuration.getReportDir();
    parameters.add("--reportDir", reportDir);
    parameters.add("--sourceDirs", configuration.getSourceDirs());
    parameters.add("--outputFormats", "HTML,XML");
    String history = Utils.concatenatePath(reportDir, "/history.pit");
    parameters.add("--historyInputLocation", history);
    parameters.add("--historyOutputLocation", history);
    parameters.add("--timestampedReports=false");
    parameters.addParametersString(configuration.getManualParameters());
}
 

import com.intellij.execution.configurations.ParametersList; //导入方法依赖的package包/类
/**
 * Runs hlintProg with parameters if hlintProg can be executed.
 */
@NotNull
private static Either<ExecError, String> runHlint(HaskellToolsConsole toolConsole,
                                                  @NotNull String workingDirectory,
                                                  @NotNull String hlintProg,
                                                  @NotNull String hlintFlags,
                                                  @NotNull String... params) {
    GeneralCommandLine commandLine = new GeneralCommandLine();
    commandLine.setWorkDirectory(workingDirectory);
    commandLine.setExePath(hlintProg);
    ParametersList parametersList = commandLine.getParametersList();
    // Required so that hlint won't report a non-zero exit status for lint issues.
    // Otherwise, ExecUtil.readCommandLine will return an error.
    parametersList.add("--no-exit-code");
    parametersList.addParametersString(hlintFlags);
    parametersList.addAll(params);
    toolConsole.writeInput(ToolKey.HLINT_KEY, "Using working directory: " + workingDirectory);
    toolConsole.writeInput(ToolKey.HLINT_KEY, commandLine.getCommandLineString());
    return ExecUtil.readCommandLine(commandLine);
}
 

import com.intellij.execution.configurations.ParametersList; //导入方法依赖的package包/类
private void spawnProcess() throws GhcModiError {
    GeneralCommandLine commandLine = new GeneralCommandLine(
        GhcModUtil.changedPathIfStack(module.getProject(), path)
    );
    GhcModUtil.updateEnvironment(module.getProject(), commandLine.getEnvironment());
    ParametersList parametersList = commandLine.getParametersList();
    parametersList.addParametersString(
        GhcModUtil.changedFlagsIfStack(module.getProject(), path, flags)
    );
    // setWorkDirectory is deprecated but is needed to work with IntelliJ 13 which does not have withWorkDirectory.
    commandLine.setWorkDirectory(workingDirectory);
    // Make sure we can actually see the errors.
    commandLine.setRedirectErrorStream(true);
    toolConsole.writeInput(ToolKey.GHC_MODI_KEY, "Using working directory: " + workingDirectory);
    toolConsole.writeInput(ToolKey.GHC_MODI_KEY, "Starting ghc-modi process: " + commandLine.getCommandLineString());
    try {
        process = commandLine.createProcess();
    } catch (ExecutionException e) {
        toolConsole.writeError(ToolKey.GHC_MODI_KEY, "Failed to initialize process");
        throw new InitError(e.toString());
    }
    input = new BufferedReader(new InputStreamReader(process.getInputStream()));
    output = new BufferedWriter(new OutputStreamWriter(process.getOutputStream()));
}
 

import com.intellij.execution.configurations.ParametersList; //导入方法依赖的package包/类
private static void checkTokenizer(String paramString, String... expected) {
  ParametersList params = new ParametersList();
  params.addParametersString(paramString);
  assertEquals(asList(expected), params.getList());

  List<String> lines = ParametersListUtil.parse(paramString, true);
  assertEquals(paramString, StringUtil.join(lines, " "));
}
 

import com.intellij.execution.configurations.ParametersList; //导入方法依赖的package包/类
@Nullable
public static String exec(@NotNull Project project, @NotNull String workingDirectory, @NotNull String ghcModPath,
                          @NotNull String command, @NotNull String ghcModFlags, String... params) {
    if (!validateGhcVersion(project, ghcModPath, ghcModFlags)) return null;
    GeneralCommandLine commandLine = new GeneralCommandLine(ghcModPath);
    GhcModUtil.updateEnvironment(project, commandLine.getEnvironment());
    ParametersList parametersList = commandLine.getParametersList();
    parametersList.addParametersString(ghcModFlags);
    parametersList.add(command);
    parametersList.addAll(params);
    // setWorkDirectory is deprecated but is needed to work with IntelliJ 13 which does not have withWorkDirectory.
    commandLine.setWorkDirectory(workingDirectory);
    // Make sure we can actually see the errors.
    commandLine.setRedirectErrorStream(true);
    HaskellToolsConsole toolConsole = HaskellToolsConsole.get(project);
    toolConsole.writeInput(ToolKey.GHC_MOD_KEY, "Using working directory: " + workingDirectory);
    toolConsole.writeInput(ToolKey.GHC_MOD_KEY, commandLine.getCommandLineString());
    Either<ExecUtil.ExecError, String> result = ExecUtil.readCommandLine(commandLine);
    if (result.isLeft()) {
        //noinspection ThrowableResultOfMethodCallIgnored
        ExecUtil.ExecError e = EitherUtil.unsafeGetLeft(result);
        toolConsole.writeError(ToolKey.GHC_MOD_KEY, e.getMessage());
        NotificationUtil.displayToolsNotification(
            NotificationType.ERROR, project, "ghc-mod", e.getMessage()
        );
        return null;
    }
    String out = EitherUtil.unsafeGetRight(result);
    toolConsole.writeOutput(ToolKey.GHC_MOD_KEY, out);
    return out;
}
 

import com.intellij.execution.configurations.ParametersList; //导入方法依赖的package包/类
@NotNull
@Override
protected OSProcessHandler startProcess() throws ExecutionException {
    ExecutionEnvironment env = getEnvironment();
    GeneralCommandLine commandLine = new GeneralCommandLine();
    commandLine.setWorkDirectory(env.getProject().getBasePath());
    // TODO: This should probably be a bit more generic than relying on `cabal test`.
    final String cabalPath = HaskellBuildSettings.getInstance(myConfig.getProject()).getCabalPath();
    commandLine.setExePath(cabalPath);
    ParametersList parametersList = commandLine.getParametersList();
    parametersList.add("test");
    parametersList.addParametersString(myConfig.programArguments);
    return new OSProcessHandler(commandLine);
}
 

import com.intellij.execution.configurations.ParametersList; //导入方法依赖的package包/类
@NotNull
@Override
protected OSProcessHandler startProcess() throws ExecutionException {
    ExecutionEnvironment env = getEnvironment();
    GeneralCommandLine commandLine = new GeneralCommandLine();
    commandLine.setWorkDirectory(env.getProject().getBasePath());
    // TODO: This should probably be a bit more generic than relying on `cabal run`.
    final HaskellBuildSettings buildSettings = HaskellBuildSettings.getInstance(myConfig.getProject());
    commandLine.setExePath(buildSettings.getCabalPath());
    ParametersList parametersList = commandLine.getParametersList();
    parametersList.add("run");
    parametersList.add("--with-ghc=" + buildSettings.getGhcPath());
    parametersList.addParametersString(myConfig.programArguments);
    return new OSProcessHandler(commandLine);
}
 

import com.intellij.execution.configurations.ParametersList; //导入方法依赖的package包/类
@Override
protected final JavaParameters createJavaParameters() throws ExecutionException {
    JavaParameters javaParameters = new JavaParameters();

    for(RunConfigurationExtension ext: Extensions.getExtensions(RunConfigurationExtension.EP_NAME)) {
        ext.updateJavaParameters(configuration, javaParameters, getRunnerSettings());
    }

    // @TODO What is the classpath entry constant class?
    javaParameters.configureByModule(module, 3);

    javaParameters.setMainClass(configuration.getRunSettings().getSketchClass());

    ParametersList programParameters = javaParameters.getProgramParametersList();

    int display = configuration.getRunSettings().getDisplay();
    programParameters.addParametersString(CliArg.DISPLAY.text() + ARG_VAL_SEP + display);

    String windowColorHex = configuration.getRunSettings().getWindowBackgroundColor();

    if (windowColorHex != null && ! windowColorHex.isEmpty()) {
        programParameters.addParametersString(CliArg.WINDOW_COLOR.text() + ARG_VAL_SEP + windowColorHex);
    }

    String stopButtonColorHex = configuration.getRunSettings().getStopButtonColor();

    if (stopButtonColorHex != null && ! stopButtonColorHex.isEmpty()) {
        programParameters.addParametersString(CliArg.STOP_BUTTON_COLOR.text() + ARG_VAL_SEP + stopButtonColorHex);
    }

    DisplayLocation sketchLocation = DisplayLocation.toEnum(configuration.getRunSettings().getLocation());

    // Processing Core automatically aligns sketch at the center of the screen, incorporating sketch size.
    if (sketchLocation != DisplayLocation.CENTER) {
        GraphicsDevice[] screens = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices();

        GraphicsDevice screen;
        if (display >= screens.length) {
            logger.warn("The display with index " + display + " is no longer connected.");
            screen = screens[0];
        } else {
            screen = screens[display];
        }

        Point sketchLocationPoint = sketchLocation.getLocation(screen);

        programParameters.addParametersString(CliArg.SKETCH_SCREEN_LOCATION.text() + ARG_VAL_SEP +
                ((int) sketchLocationPoint.getX()) + "," + ((int) sketchLocationPoint.getY()));
    }

    String sketchOutputPath = configuration.getRunSettings().getSketchOutputPath();
    if (sketchOutputPath != null && !sketchOutputPath.isEmpty()) {
        programParameters.addParametersString(CliArg.SKETCH_OUTPUT_PATH.text() + ARG_VAL_SEP + sketchOutputPath);
    }

    if (configuration.getRunSettings().isHideStopButton()) {
        programParameters.add(CliArg.HIDE_STOP_BUTTON.text());
    }

    if (configuration.getRunSettings().isFullscreen()) {
        programParameters.addParametersString(CliArg.PRESENTATION_MODE.text());
    }

    programParameters.add(configuration.getRunSettings().getSketchClass());
    programParameters.addParametersString(configuration.getRunSettings().getSketchArguments());

    javaParameters.getVMParametersList().addParametersString(configuration.getRunSettings().getJvmArguments());

    return javaParameters;
}
 

import com.intellij.execution.configurations.ParametersList; //导入方法依赖的package包/类
public Process configure() throws IOException, ExecutionException {
    GeneralCommandLine commandLine = getCommandLine("configure");
    ParametersList parametersList = commandLine.getParametersList();
    parametersList.addParametersString(myBuildOptions.myCabalFlags);
    return commandLine.createProcess();
}
 

import com.intellij.execution.configurations.ParametersList; //导入方法依赖的package包/类
public Map<String, String> getAnnotationProcessorOptions() {
  Element compilerConfig = getCompilerConfig();

  if (compilerConfig == null) return Collections.emptyMap();

  Map<String, String> res = null;

  String compilerArgument = compilerConfig.getChildText("compilerArgument");
  if (!StringUtil.isEmptyOrSpaces(compilerArgument)) {
    ParametersList parametersList = new ParametersList();
    parametersList.addParametersString(compilerArgument);

    for (String param : parametersList.getParameters()) {
      if (param.startsWith("-A")) {
        int idx = param.indexOf('=', 3);
        if (idx >= 0) {
          if (res == null) {
            res = new LinkedHashMap<String, String>();
          }

          res.put(param.substring(2, idx), param.substring(idx + 1));
        }
      }
    }
  }

  Element compilerArguments = compilerConfig.getChild("compilerArguments");
  if (compilerArguments != null) {
    for (Element e : (Collection<Element>)compilerArguments.getChildren()){
      String name = e.getName();
      if (name.startsWith("-")) {
        name = name.substring(1);
      }

      if (name.length() > 1 && name.charAt(0) == 'A') {
        if (res == null) {
          res = new LinkedHashMap<String, String>();
        }

        res.put(name.substring(1), e.getTextTrim());
      }
    }
  }

  if (res == null) return Collections.emptyMap();

  return res;
}
 

import com.intellij.execution.configurations.ParametersList; //导入方法依赖的package包/类
public static void addVMParameters(ParametersList parametersList, String mavenHome, MavenRunnerSettings runnerSettings) {
  parametersList.addParametersString(System.getenv(MAVEN_OPTS));

  parametersList.addParametersString(runnerSettings.getVmOptions());

  parametersList.addProperty("maven.home", mavenHome);
}