Java CommandLineUtils类代码示例

import org.codehaus.plexus.util.cli.CommandLineUtils; //导入依赖的package包/类
private boolean hasOption(String longName, String shortName) {
    String defOpts = getDefaultOptions();
    if (defOpts != null) {
        try {
            String[] strs = CommandLineUtils.translateCommandline(defOpts);
            for (String s : strs) {
                s = s.trim();
                if (s.startsWith(shortName) || s.startsWith(longName)) {
                    return true;
                }
            }
        } catch (Exception ex) {
            Logger.getLogger(MavenSettings.class.getName()).log(Level.FINE, "Error parsing global options:{0}", defOpts);
            //will check for contains of -X be enough?
            return defOpts.contains(longName) || defOpts.contains(shortName);
        }
    }
    return false;
}
 

import org.codehaus.plexus.util.cli.CommandLineUtils; //导入依赖的package包/类
static Map<String, String> getCustomGlobalUserProperties() {
    //maybe set org.eclipse.aether.ConfigurationProperties.USER_AGENT with netbeans specific value.
    Map<String, String> toRet = new HashMap<String, String>();
    String options = getPreferences().get(PROP_DEFAULT_OPTIONS, "");
    try {
        
        String[] cmdlines = CommandLineUtils.translateCommandline(options);
        if (cmdlines != null) {
            for (String cmd : cmdlines) {
                if (cmd != null && cmd.startsWith("-D")) {
                    cmd = cmd.substring("-D".length());
                    int ind = cmd.indexOf('=');
                    if (ind > -1) {
                        String key = cmd.substring(0, ind);
                        String val = cmd.substring(ind + 1);
                        toRet.put(key, val);
                    }
                }
            }
        }
        return toRet;
    } catch (Exception ex) {
        LOG.log(Level.FINE, "cannot parse " + options, ex);
        return Collections.emptyMap();
    }
}
 

import org.codehaus.plexus.util.cli.CommandLineUtils; //导入依赖的package包/类
/**
 * Parses the argument string given by the user. Strings are recognized as everything between STRING_WRAPPER.
 * PARAMETER_DELIMITER is ignored inside a string. STRING_WRAPPER and PARAMETER_DELIMITER can be escaped using
 * ESCAPE_CHAR.
 *
 * @return Array of String representing the arguments
 * @throws MojoExecutionException for wrong formatted arguments
 */
protected String[] parseCommandlineArgs()
    throws MojoExecutionException
{
    if ( commandlineArgs == null )
    {
        return null;
    }
    else
    {
        try
        {
            return CommandLineUtils.translateCommandline( commandlineArgs );
        }
        catch ( Exception e )
        {
            throw new MojoExecutionException( e.getMessage() );
        }
    }
}
 

import org.codehaus.plexus.util.cli.CommandLineUtils; //导入依赖的package包/类
public static void execute( Commandline cl, Logger logger )
    throws NativeBuildException
{
    int ok;

    try
    {
        DefaultConsumer stdout = new DefaultConsumer();

        DefaultConsumer stderr = stdout;

        logger.info( cl.toString() );

        ok = CommandLineUtils.executeCommandLine( cl, stdout, stderr );
    }
    catch ( CommandLineException ecx )
    {
        throw new NativeBuildException( "Error executing command line", ecx );
    }

    if ( ok != 0 )
    {
        throw new NativeBuildException( "Error executing command line. Exit code:" + ok );
    }
}
 

import org.codehaus.plexus.util.cli.CommandLineUtils; //导入依赖的package包/类
private void execute(Commandline jDepsCommand) throws CommandLineException {
	StringStreamConsumer errorConsoleConsumer = new StringStreamConsumer();

	MojoLogging.logger().debug(format("Running JDeps: %s", jDepsCommand));
	MojoLogging.logger().debug(String.format(
			"(JDeps output is forwarded here. "
					+ "Lines are marked: %s = recognized as dependency; %s = not recognized.)",
			ViolationParser.MESSAGE_MARKER_JDEPS_LINE,
			ViolationParser.MESSAGE_MARKER_UNKNOWN_LINE));

	int exitCode = CommandLineUtils.executeCommandLine(
			jDepsCommand, jDepsOutputConsumer::accept, errorConsoleConsumer);

	MojoLogging.logger().debug(format("JDeps completed with exit code %d.", exitCode));

	if (exitCode != 0)
		throwCommandLineException(jDepsCommand, exitCode, errorConsoleConsumer.getOutput());
}
 

import org.codehaus.plexus.util.cli.CommandLineUtils; //导入依赖的package包/类
/**
 * Creates the environment required when launching Cassandra or the CLI tools.
 *
 * @return the environment required when launching Cassandra or the CLI tools.
 */
protected Map<String, String> createEnvironmentVars()
{
    Map<String, String> enviro = new HashMap<String, String>();
    try
    {
        Properties systemEnvVars = CommandLineUtils.getSystemEnvVars();
        for ( Map.Entry entry : systemEnvVars.entrySet() )
        {
            enviro.put( (String) entry.getKey(), (String) entry.getValue() );
        }
    }
    catch ( IOException x )
    {
        getLog().error( "Could not assign default system enviroment variables.", x );
    }
    enviro.put( "CASSANDRA_CONF", new File( cassandraDir, "conf" ).getAbsolutePath() );
    return enviro;
}
 

import org.codehaus.plexus.util.cli.CommandLineUtils; //导入依赖的package包/类
private List<String> getJvmArgs()
{
	List<String> extra = new ArrayList<String>();
	String userExtraJvmArgs = getExtraJvmArgs();
	if (userExtraJvmArgs != null)
	{
		try
		{
			return new ArrayList<String>(Arrays.asList(CommandLineUtils.translateCommandline(StringUtils
			    .removeDuplicateWhitespace(userExtraJvmArgs))));
		}
		catch (Exception e)
		{
			throw new RuntimeException(e);
		}
	}
	return extra;
}
 

import org.codehaus.plexus.util.cli.CommandLineUtils; //导入依赖的package包/类
private static boolean isSvn18()
{
    Commandline cl = new Commandline();
    cl.setExecutable( "svn" );

    StringStreamConsumer stdout = new StringStreamConsumer();
    StringStreamConsumer stderr = new StringStreamConsumer();

    try
    {
        CommandLineUtils.executeCommandLine( cl, stdout, stderr );
        return stdout.getOutput().contains( "svn, version 1.8." );
    }
    catch ( CommandLineException e )
    {
    }

    return false;
}
 

import org.codehaus.plexus.util.cli.CommandLineUtils; //导入依赖的package包/类
private static String getDotExecutable() {
  Commandline cmd = new Commandline();
  String finderExecutable = isWindows() ? "where.exe" : "which";

  cmd.setExecutable(finderExecutable);
  cmd.addArguments(new String[]{"dot"});

  CommandLineUtils.StringStreamConsumer systemOut = new CommandLineUtils.StringStreamConsumer();
  CommandLineUtils.StringStreamConsumer systemErr = new CommandLineUtils.StringStreamConsumer();

  try {
    int exitCode = CommandLineUtils.executeCommandLine(cmd, systemOut, systemErr);
    if (exitCode != 0) {
      return null;
    }
  } catch (CommandLineException e) {
    return null;
  }

  return systemOut.getOutput();
}
 

import org.codehaus.plexus.util.cli.CommandLineUtils; //导入依赖的package包/类
static List<String> extractDebugJVMOptions(String argLine) throws Exception {
    String[] split = CommandLineUtils.translateCommandline(argLine);
    List<String> toRet = new ArrayList<String>();
    for (String arg : split) {
        if ("-Xdebug".equals(arg)) { //NOI18N
            continue;
        }
        if ("-Djava.compiler=none".equals(arg)) { //NOI18N
            continue;
        }
        if ("-Xnoagent".equals(arg)) { //NOI18N
            continue;
        }
        if (arg.startsWith("-Xrunjdwp")) { //NOI18N
            continue;
        }
        if (arg.equals("-agentlib:jdwp")) { //NOI18N
            continue;
        }
        if (arg.startsWith("-agentlib:jdwp=")) { //NOI18N
            continue;
        }
        if (arg.trim().length() == 0) {
            continue;
        }
        toRet.add(arg);
    }
    return toRet;
}
 

import org.codehaus.plexus.util.cli.CommandLineUtils; //导入依赖的package包/类
private static String[] parseArgs(String arguments) {
	if (arguments == null || arguments.trim().isEmpty()) {
		return NO_ARGS;
	}
	try {
		arguments = arguments.replace('\n', ' ').replace('\t', ' ');
		return CommandLineUtils.translateCommandline(arguments);
	}
	catch (Exception ex) {
		throw new IllegalArgumentException(
				"Failed to parse arguments [" + arguments + "]", ex);
	}
}
 

import org.codehaus.plexus.util.cli.CommandLineUtils; //导入依赖的package包/类
private void handleSystemPropertyArguments( String argsProp, List<String> commandArguments )
    throws MojoExecutionException
{
    getLog().debug( "got arguments from system properties: " + argsProp );

    try
    {
        String[] args = CommandLineUtils.translateCommandline( argsProp );
        commandArguments.addAll( Arrays.asList( args ) );
    }
    catch ( Exception e )
    {
        throw new MojoExecutionException( "Couldn't parse systemproperty 'exec.args'" );
    }
}
 

import org.codehaus.plexus.util.cli.CommandLineUtils; //导入依赖的package包/类
private void execute(Commandline jDepsCommand) throws CommandLineException {
	StringStreamConsumer errorConsoleConsumer = new StringStreamConsumer();
	int exitCode = CommandLineUtils.executeCommandLine(
			jDepsCommand, jDepsOutputConsumer::accept, errorConsoleConsumer);
	if (exitCode != 0)
		throwCommandLineException(jDepsCommand, exitCode, errorConsoleConsumer.getOutput());
}
 

import org.codehaus.plexus.util.cli.CommandLineUtils; //导入依赖的package包/类
private static void throwCommandLineException(Commandline jDepsCommand, int exitCode, String errorOutput)
		throws CommandLineException {
	StringBuilder message = new StringBuilder("JDeps returned with exit code '" + exitCode + "'.\n");
	message.append("\t Executed command: "
			+ CommandLineUtils.toString(jDepsCommand.getCommandline()).replaceAll("'", ""));
	message.append("\t Error output:\n");
	streamLines(errorOutput).forEachOrdered(errorLine -> message.append("\t\t " + errorLine + "\n"));

	throw new CommandLineException(message.toString());
}
 

import org.codehaus.plexus.util.cli.CommandLineUtils; //导入依赖的package包/类
public static String getValue( String valueType, String folderName, String folderKey )
    throws NativeBuildException
{
    Commandline cl = new Commandline();
    cl.setExecutable( "reg" );
    cl.createArg().setValue( "query" );
    cl.createArg().setValue( folderName );
    cl.createArg().setValue( "/v" );
    cl.createArg().setValue( folderKey );

    CommandLineUtils.StringStreamConsumer stdout = new CommandLineUtils.StringStreamConsumer();
    CommandLineUtils.StringStreamConsumer stderr = new CommandLineUtils.StringStreamConsumer();

    try
    {
        int ok = CommandLineUtils.executeCommandLine( cl, stdout, stderr );

        if ( ok != 0 )
        {
            return null;
        }
    }
    catch ( CommandLineException e )
    {
        throw new NativeBuildException( e.getMessage(), e );
    }

    String result = stdout.getOutput();

    int p = result.indexOf( valueType );

    if ( p == -1 )
    {
        return null;
    }

    return result.substring( p + valueType.length() ).trim();
}