Example usage for org.apache.commons.cli Option getOpt

List of usage examples for org.apache.commons.cli Option getOpt

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.cli.*
  5. Option
  6. getOpt

Introduction

In this page you can find the example usage for org.apache.commons.cli Option getOpt.

Prototype

public String getOpt()

Source Link

Document

Retrieve the name of this Option.

Usage

From source file:jurbano.melodyshape.ui.ConsoleUIObserver.java

/**
 * Prints the usage message to stderr./*from www  .  ja va  2  s.  com*/
 * 
 * @param options
 *            the command line options.
 */
protected void printUsage(Options options) {
    HelpFormatter formatter = new HelpFormatter();
    formatter.setOptionComparator(new Comparator<Option>() {
        public int compare(Option o1, Option o2) {
            List<String> options = Arrays.asList("q", "c", "a", "k", "l", "t", "v", "vv", "gui", "h");

            return Integer.compare(options.indexOf(o1.getOpt()), options.indexOf(o2.getOpt()));
        }
    });
    formatter.printHelp(new PrintWriter(System.err, true), Integer.MAX_VALUE,
            "melodyshape-" + MelodyShape.VERSION, null, options, 0, 2, "\n" + MelodyShape.COPYRIGHT_NOTICE,
            true);
}

From source file:com.github.lindenb.jvarkit.util.command.Command.java

protected Status visit(final Option opt) {
    if (opt.getOpt().equals("version")) {
        stdout().println(getVersion());/*  w w  w.j  a v  a2 s .c  o  m*/
        return Status.EXIT_SUCCESS;
    } else if (opt.getOpt().equals("h")) {
        usage(stdout());
        return Status.EXIT_SUCCESS;
    }

    LOG.error("Unknown option " + opt.getOpt());
    return Status.EXIT_FAILURE;
}

From source file:cz.pecina.retro.pmd85.CommandLineProcessor.java

/**
 * Creates an instance of the command line procssor.
 *
 * @param hardware the hardware object to operate on
 *///from  w w w .  ja  va2 s. co  m
public CommandLineProcessor(final Hardware hardware) {
    log.fine("New CommandLineProcessor creation started");
    this.hardware = hardware;

    // build options
    log.fine("Building options");
    options.addOption(
            Option.builder("?").longOpt("help").desc(Application.getString(this, "option.help")).build());
    options.addOption(
            Option.builder("V").longOpt("version").desc(Application.getString(this, "option.version")).build());
    options.addOption(Option.builder("l").longOpt("language").hasArg().argName("CODE")
            .desc(Application.getString(this, "option.language")).build());
    options.addOption(Option.builder("p").longOpt("pixel-size").hasArg().argName("SIZE")
            .desc(Application.getString(this, "option.pixelSize")).build());
    options.addOption(Option.builder("a").longOpt("address").hasArg().argName("ADDR")
            .desc(Application.getString(this, "option.address")).build());
    options.addOption(Option.builder("o").longOpt("ROM-file").hasArg().argName("FILE")
            .desc(Application.getString(this, "option.ROM")).build());
    options.addOption(Option.builder("m").longOpt("RMM-file").hasArg().argName("FILE")
            .desc(Application.getString(this, "option.RMM")).build());
    options.addOption(Option.builder("b").longOpt("binary").hasArgs().numberOfArgs(2).argName("FILE>,<ADDR")
            .valueSeparator(',').desc(Application.getString(this, "option.binary")).build());
    options.addOption(Option.builder("h").longOpt("intel-hex").hasArg().argName("FILE")
            .desc(Application.getString(this, "option.intelHex")).build());
    options.addOption(Option.builder("x").longOpt("xml").hasArg().argName("FILE")
            .desc(Application.getString(this, "option.xml")).build());
    options.addOption(Option.builder("s").longOpt("snapshot").hasArg().argName("FILE")
            .desc(Application.getString(this, "option.snapshot")).build());
    options.addOption(Option.builder("w").longOpt("write-snapshot").hasArg().argName("FILE")
            .desc(Application.getString(this, "option.writeSnapshot")).build());
    options.addOption(Option.builder("S").longOpt("speed-up").hasArg().argName("FACTOR")
            .desc(Application.getString(this, "option.speedUp")).build());
    options.addOption(
            Option.builder("g").longOpt("opengl").desc(Application.getString(this, "option.openGL")).build());
    options.addOption(Option.builder("G").longOpt("no-opengl")
            .desc(Application.getString(this, "option.noOpenGL")).build());
    log.finer("Options set up");

    // parse the command line
    final CommandLineParser parser = new DefaultParser();
    CommandLine line = null;
    try {
        line = parser.parse(options, Parameters.arguments);
    } catch (final Exception exception) {
        usage();
        error();
    }
    log.finer("Command line parsed");

    // load default snapshot if exists
    boolean success = false;
    for (String name : DEFAULT_SNAPSHOT_NAMES) {
        final File defaultSnapshot = new File(name);
        if (defaultSnapshot.canRead()) {
            try {
                new Snapshot(hardware).read(defaultSnapshot);
            } catch (final RuntimeException exception) {
                log.fine("Error reading default snapshot");
                System.out.println(Application.getString(this, "error.errorDefaultShapshot"));
                error();
            }
            log.fine("Default snapshot read from the current directory");
            success = true;
            break;
        }
    }
    if (!success) {
        for (String name : DEFAULT_SNAPSHOT_NAMES) {
            final File defaultSnapshot = new File(new File(System.getProperty("user.home")), name);
            if (defaultSnapshot.canRead()) {
                try {
                    new Snapshot(hardware).read(defaultSnapshot);
                } catch (final Exception exception) {
                    log.fine("Error reading default snapshot");
                    System.out.println(Application.getString(this, "error.errorDefaultShapshot"));
                    error();
                }
                log.fine("Default snapshot read from the user's home directory");
                break;
            }
        }
    }
    log.finer("Default files processed");

    // process the options
    if (!line.getArgList().isEmpty()) {
        usage();
        error();
    }
    if (line.hasOption("?")) {
        log.finer("Processing -?");
        usage();
        System.exit(0);
    }
    if (line.hasOption("V")) {
        log.finer("Processing -V");
        System.out.println(Application.getString(this, "longAppName") + " "
                + Application.getString(this, "version") + " @VERSION@");
        System.exit(0);
    }
    try {
        for (Option option : line.getOptions()) {
            switch (option.getOpt()) {
            case "l":
                log.finer("Processing -l");
                final String language = option.getValue();
                if (!Arrays.asList(GeneralConstants.SUPPORTED_LOCALES).contains(language)) {
                    System.out.println(Application.getString(this, "error.unsupportedLanguage"));
                    error();
                }
                UserPreferences.setLocale(language);
                break;
            case "p":
                log.finer("Processing -p");
                final int pixelSize = Integer.parseInt(option.getValue());
                if (!Arrays.asList(GeneralConstants.PIXEL_SIZES).contains(pixelSize)) {
                    System.out.println(Application.getString(this, "error.unsupportedPixelSize"));
                    error();
                }
                UserPreferences.setPixelSize(pixelSize);
                break;
            case "o":
                log.finer("Processing -o");
                fileNameROM = option.getValue();
                break;
            case "m":
                log.finer("Processing -m");
                fileNameRMM = option.getValue();
                break;
            case "a":
                log.finer("Processing -a");
                int address = Integer.parseInt(option.getValue(), 16);
                if ((address < 0) || (address >= 0x10000)) {
                    System.out.println(Application.getString(this, "error.invalidAddress"));
                    error();
                }
                Parameters.cpu.setPC(address);
                break;
            case "b":
                log.finer("Processing -b");
                File file = new File(option.getValue(0));
                address = Integer.parseInt(option.getValue(1), 16);
                if ((address < 0) || (address >= 0x10000)) {
                    System.out.println(Application.getString(this, "error.invalidAddress"));
                    error();
                }
                new Raw(hardware, DEFAULT_BANK, DEFAULT_BANK).read(file, address);
                break;
            case "h":
                log.finer("Processing -h");
                file = new File(option.getValue());
                new IntelHEX(hardware, DEFAULT_BANK, DEFAULT_BANK).read(file);
                break;
            case "x":
                log.finer("Processing -x");
                file = new File(option.getValue());
                new XML(hardware, DEFAULT_BANK, DEFAULT_BANK).read(file);
                break;
            case "s":
                log.finer("Processing -s");
                file = new File(option.getValue());
                new Snapshot(hardware).read(file);
                break;
            case "w":
                log.finer("Processing -w");
                file = new File(option.getValue());
                new Snapshot(hardware).write(file);
                System.exit(0);
                break;
            case "S":
                log.finer("Processing -S");
                Parameters.speedUp = Integer.parseInt(option.getValue());
                if (Parameters.speedUp < 1) {
                    System.out.println(Application.getString(this, "error.nonPositiveSpeedUp"));
                    error();
                }
                break;
            case "g":
                log.finer("Processing -g");
                Parameters.openGL = true;
                break;
            case "G":
                log.finer("Processing -G");
                Parameters.openGL = false;
                break;
            }
        }
    } catch (final Exception exception) {
        usage();
        error();
    }

    log.fine("New CommandLineProcessor creation completed");
}

From source file:cz.pecina.retro.pmi80.CommandLineProcessor.java

/**
 * Creates an instance of the command line procssor.
 *
 * @param hardware the hardware object to operate on
 *//*www .j  a va 2  s  .com*/
public CommandLineProcessor(final Hardware hardware) {
    log.fine("New CommandLineProcessor creation started");
    this.hardware = hardware;

    // build options
    log.fine("Building options");
    options.addOption(
            Option.builder("?").longOpt("help").desc(Application.getString(this, "option.help")).build());
    options.addOption(
            Option.builder("V").longOpt("version").desc(Application.getString(this, "option.version")).build());
    options.addOption(Option.builder("l").longOpt("language").hasArg().argName("CODE")
            .desc(Application.getString(this, "option.language")).build());
    options.addOption(Option.builder("p").longOpt("pixel-size").hasArg().argName("SIZE")
            .desc(Application.getString(this, "option.pixelSize")).build());
    options.addOption(Option.builder("a").longOpt("address").hasArg().argName("ADDR")
            .desc(Application.getString(this, "option.address")).build());
    options.addOption(Option.builder("O").longOpt("start-rom").hasArg().argName("ADDR")
            .desc(Application.getString(this, "option.startRom")).build());
    options.addOption(Option.builder("A").longOpt("start-ram").hasArg().argName("ADDR")
            .desc(Application.getString(this, "option.startRam")).build());
    options.addOption(Option.builder("b").longOpt("binary").hasArgs().numberOfArgs(2).argName("FILE>,<ADDR")
            .valueSeparator(',').desc(Application.getString(this, "option.binary")).build());
    options.addOption(Option.builder("h").longOpt("intel-hex").hasArg().argName("FILE")
            .desc(Application.getString(this, "option.intelHex")).build());
    options.addOption(Option.builder("x").longOpt("xml").hasArg().argName("FILE")
            .desc(Application.getString(this, "option.xml")).build());
    options.addOption(Option.builder("s").longOpt("snapshot").hasArg().argName("FILE")
            .desc(Application.getString(this, "option.snapshot")).build());
    options.addOption(Option.builder("w").longOpt("write-snapshot").hasArg().argName("FILE")
            .desc(Application.getString(this, "option.writeSnapshot")).build());
    options.addOption(Option.builder("S").longOpt("speed-up").hasArg().argName("FACTOR")
            .desc(Application.getString(this, "option.speedUp")).build());
    options.addOption(
            Option.builder("g").longOpt("opengl").desc(Application.getString(this, "option.openGL")).build());
    options.addOption(Option.builder("G").longOpt("no-opengl")
            .desc(Application.getString(this, "option.noOpenGL")).build());
    log.finer("Options set up");

    // parse the command line
    final CommandLineParser parser = new DefaultParser();
    CommandLine line = null;
    try {
        line = parser.parse(options, Parameters.arguments);
    } catch (final Exception exception) {
        usage();
        error();
    }
    log.finer("Command line parsed");

    // load default snapshot if exists
    boolean success = false;
    for (String name : DEFAULT_SNAPSHOT_NAMES) {
        final File defaultSnapshot = new File(name);
        if (defaultSnapshot.canRead()) {
            try {
                new Snapshot(hardware).read(defaultSnapshot);
            } catch (final Exception exception) {
                log.fine("Error reading default snapshot");
                System.out.println(Application.getString(this, "error.errorDefaultShapshot"));
                error();
            }
            log.fine("Default snapshot read from the current directory");
            success = true;
            break;
        }
    }
    if (!success) {
        for (String name : DEFAULT_SNAPSHOT_NAMES) {
            final File defaultSnapshot = new File(new File(System.getProperty("user.home")), name);
            if (defaultSnapshot.canRead()) {
                try {
                    new Snapshot(hardware).read(defaultSnapshot);
                } catch (final RuntimeException exception) {
                    log.fine("Error reading default snapshot");
                    System.out.println(Application.getString(this, "error.errorDefaultShapshot"));
                    error();
                }
                log.fine("Default snapshot read from the user's home directory");
                break;
            }
        }
    }
    log.finer("Default files processed");

    // process the options
    if (!line.getArgList().isEmpty()) {
        usage();
        error();
    }
    if (line.hasOption("?")) {
        log.finer("Processing -?");
        usage();
        System.exit(0);
    }
    if (line.hasOption("V")) {
        log.finer("Processing -V");
        System.out.println(Application.getString(this, "longAppName") + " "
                + Application.getString(this, "version") + " @VERSION@");
        System.exit(0);
    }
    try {
        for (Option option : line.getOptions()) {
            switch (option.getOpt()) {
            case "l":
                log.finer("Processing -l");
                final String language = option.getValue();
                if (!Arrays.asList(GeneralConstants.SUPPORTED_LOCALES).contains(language)) {
                    System.out.println(Application.getString(this, "error.unsupportedLanguage"));
                    error();
                }
                UserPreferences.setLocale(language);
                break;
            case "p":
                log.finer("Processing -p");
                final int pixelSize = Integer.parseInt(option.getValue());
                if (!Arrays.asList(GeneralConstants.PIXEL_SIZES).contains(pixelSize)) {
                    System.out.println(Application.getString(this, "error.unsupportedPixelSize"));
                    error();
                }
                UserPreferences.setPixelSize(pixelSize);
                break;
            case "a":
                log.finer("Processing -a");
                int address = Integer.parseInt(option.getValue(), 16);
                if ((address < 0) || (address >= 0x10000)) {
                    System.out.println(Application.getString(this, "error.invalidAddress"));
                    error();
                }
                Parameters.cpu.setPC(address);
                break;
            case "O":
                log.finer("Processing -O");
                final int startROM = Integer.parseInt(option.getValue());
                if ((startROM < 0) || (startROM > 64)) {
                    System.out.println(Application.getString(this, "error.unsupportedMemoryStart"));
                    error();
                }
                UserPreferences.setStartROM(startROM);
                break;
            case "A":
                log.finer("Processing -A");
                final int startRAM = Integer.parseInt(option.getValue());
                if ((startRAM < 0) || (startRAM > 64)) {
                    System.out.println(Application.getString(this, "error.unsupportedMemoryStart"));
                    error();
                }
                UserPreferences.setStartRAM(startRAM);
                break;
            case "b":
                log.finer("Processing -b");
                File file = new File(option.getValue(0));
                address = Integer.parseInt(option.getValue(1), 16);
                if ((address < 0) || (address >= 0x10000)) {
                    System.out.println(Application.getString(this, "error.invalidAddress"));
                    error();
                }
                new Raw(hardware, DEFAULT_BANK, DEFAULT_BANK).read(file, address);
                break;
            case "h":
                log.finer("Processing -h");
                file = new File(option.getValue());
                new IntelHEX(hardware, DEFAULT_BANK, DEFAULT_BANK).read(file);
                break;
            case "x":
                log.finer("Processing -x");
                file = new File(option.getValue());
                new XML(hardware, DEFAULT_BANK, DEFAULT_BANK).read(file);
                break;
            case "s":
                log.finer("Processing -s");
                file = new File(option.getValue());
                new Snapshot(hardware).read(file);
                break;
            case "w":
                log.finer("Processing -w");
                file = new File(option.getValue());
                new Snapshot(hardware).write(file);
                System.exit(0);
                break;
            case "S":
                log.finer("Processing -S");
                Parameters.speedUp = Integer.parseInt(option.getValue());
                if (Parameters.speedUp < 1) {
                    System.out.println(Application.getString(this, "error.nonPositiveSpeedUp"));
                    error();
                }
                break;
            case "g":
                log.finer("Processing -g");
                Parameters.openGL = true;
                break;
            case "G":
                log.finer("Processing -G");
                Parameters.openGL = false;
                break;
            }
        }
    } catch (final Exception exception) {
        usage();
        error();
    }

    log.fine("New CommandLineProcessor creation completed");
}

From source file:edu.mit.csail.sdg.alloy4.Terminal.java

/**
 * @param args/*  w w  w  . j a v  a 2 s .co  m*/
 * @throws Exception
 */
public static int execute(String[] args) throws Exception {
    // create the command line parser
    CommandLineParser parser = new PosixParser();

    // create the Options
    Options optionsArg = new Options();
    Option helpOpt = new Option("?", "help", false, "print this message");
    Option alloyOpt = new Option("alloy", true, "the alloy input file to check");
    alloyOpt.setRequired(true);
    Option commandOpt = new Option("c", "command", true, "the command to run");
    Option runAllCommandsOpt = new Option("a", "runall", false, "run all commands");
    Option keepResultsOpt = new Option("k", "keep", false, "keep result files");
    Option solverOpt = new Option("s", "solver", true,
            "name of SAT Solver. Options are: " + getAvaliableSatSolvers());

    optionsArg.addOption(helpOpt);
    optionsArg.addOption(alloyOpt);
    optionsArg.addOption(commandOpt);
    optionsArg.addOption(runAllCommandsOpt);
    optionsArg.addOption(keepResultsOpt);
    optionsArg.addOption(solverOpt);

    CommandLine line = null;
    try {
        // parse the command line arguments
        line = parser.parse(optionsArg, args);

        if (line.hasOption(helpOpt.getOpt())) {
            // automatically generate the help statement
            HelpFormatter formatter = new HelpFormatter();
            formatter.printHelp("vdm2alloy", optionsArg);
            return 0;
        }

    } catch (ParseException exp) {
        System.err.println("Unexpected exception:" + exp.getMessage());
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp("vdm2alloy", optionsArg);
        return 1;
    }

    String intputAlloyModel = null;
    if (line.hasOption(alloyOpt.getOpt())) {
        intputAlloyModel = line.getOptionValue(alloyOpt.getOpt());
    }

    // Setup solver and alloy libs
    copyFromJAR();

    A4Reporter rep = new A4Reporter();

    A4Options options = new A4Options();

    options.solver = A4Options.SatSolver.MiniSatProverJNI;
    if (line.hasOption(solverOpt.getOpt())) {
        String solverName = line.getOptionValue(solverOpt.getOpt());
        A4Options.SatSolver solver = getSolver(solverName);
        if (solver == null) {
            System.err.println("Solver could not be resolved with value: " + solverName);
            return 1;
        }
        options.solver = solver;
    }

    Module someWorld = null;
    try {
        someWorld = CompUtil.parseEverything_fromFile(rep, null, intputAlloyModel);
        System.out.println();
    } catch (Err e) {
        System.err.println(e);
        System.err.println();
        System.err.flush();
        return 1;
    }

    List<Command> commandsToRun = new Vector<Command>();

    if (line.hasOption(commandOpt.getOpt())) {
        String commandName = line.getOptionValue(commandOpt.getOpt());
        for (Command command : someWorld.getAllCommands()) {
            if (command.label.equals(commandName)) {
                commandsToRun.add(command);
                break;
            }
        }
        if (commandsToRun.isEmpty()) {
            System.err.println("Command: " + commandName + " not found in " + someWorld.getAllCommands());
            return 1;
        }
    }

    if (commandsToRun.isEmpty() || line.hasOption(runAllCommandsOpt.getOpt())) {
        commandsToRun.addAll(someWorld.getAllCommands());
    }

    System.out.println("Alloy Analysis");
    int i = 0;
    for (Command command : commandsToRun) {
        i++;
        A4Solution ans = TranslateAlloyToKodkod.execute_command(rep, someWorld.getAllReachableSigs(), command,
                options);
        show(ans, commandsToRun, command, i);

        if (line.hasOption(keepResultsOpt.getOpt())) {
            final String tempdir = alloyHome() + fs + "binary" + File.separatorChar;
            if (ans.satisfiable()) {
                ans.writeXML(tempdir + "tmp" + i + "cnf.xml");
            }
            final File tempCNF = new File(tempdir + "tmp.cnf");
            copyFile(tempCNF, new File(tempdir + "tmp" + i + ".cnf"));
        }
    }
    System.out.println("Done.");
    return 0;
}

From source file:com.buildml.main.BMLAdminMain.java

/**
 * Display a set of options (as defined by the Options class). This methods is used
 * in displaying the help text./*w w  w. j a v a  2  s.  c o  m*/
 * @param opts A set of command line options, as defined by the Options class.
 */
@SuppressWarnings("unchecked")
private void displayOptions(Options opts) {

    /* obtain a list of all the options */
    Collection<Option> optList = opts.getOptions();

    /* if there are no options for this command ... */
    if (optList.size() == 0) {
        System.err.println("    No options available.");
    }

    /* 
     * Else, we have options to display. Show them in a nicely tabulated
     * format, with the short option name (e.g. -p) and the long option name
     * (--show-pkgs) first, followed by a text description of the option.
     */
    else {
        for (Iterator<Option> iterator = optList.iterator(); iterator.hasNext();) {
            Option thisOpt = iterator.next();
            String shortOpt = thisOpt.getOpt();
            String longOpt = thisOpt.getLongOpt();
            String line = "    ";
            if (shortOpt != null) {
                line += "-" + shortOpt;
            } else {
                line += "  ";
            }
            if (shortOpt != null && longOpt != null) {
                line += " | ";
            } else {
                line += "   ";
            }
            if (longOpt != null) {
                line += "--" + thisOpt.getLongOpt();
            }
            if (thisOpt.hasArg()) {
                line += " <" + thisOpt.getArgName() + ">";
            }
            formattedDisplayLine(line, thisOpt.getDescription());
        }
    }
}

From source file:net.sf.clichart.main.FixedHelpFormatter.java

protected StringBuffer renderOptions(StringBuffer sb, int width, Options options, int leftPad, int descPad) {
    final String lpad = createPadding(leftPad);
    final String dpad = createPadding(descPad);

    //first create list containing only <lpad>-a,--aaa where -a is opt and --aaa is
    //long opt; in parallel look for the longest opt string
    //this list will be then used to sort options ascending
    int max = 0;/*from   w  w  w .  j  av  a2s.co m*/
    StringBuffer optBuf;
    List prefixList = new ArrayList();
    Option option;

    //List optList = options.helpOptions();
    Collection optionsCollection = options.getOptions();
    List optList = new ArrayList(optionsCollection);

    Collections.sort(optList, new StringBufferComparator());
    for (Iterator i = optList.iterator(); i.hasNext();) {
        option = (Option) i.next();
        optBuf = new StringBuffer(8);

        if (option.getOpt().equals(" ")) {
            optBuf.append(lpad).append("   " + defaultLongOptPrefix).append(option.getLongOpt());
        } else {
            optBuf.append(lpad).append(defaultOptPrefix).append(option.getOpt());
            if (option.hasLongOpt()) {
                optBuf.append(',').append(defaultLongOptPrefix).append(option.getLongOpt());
            }

        }

        if (option.hasArg()) {
            if (option.hasArgName()) {
                optBuf.append(" <").append(option.getArgName()).append('>');
            } else {
                optBuf.append(' ');
            }
        }

        prefixList.add(optBuf);
        max = optBuf.length() > max ? optBuf.length() : max;
    }
    int x = 0;
    for (Iterator i = optList.iterator(); i.hasNext();) {
        option = (Option) i.next();
        optBuf = new StringBuffer(prefixList.get(x++).toString());

        if (optBuf.length() < max) {
            optBuf.append(createPadding(max - optBuf.length()));
        }
        optBuf.append(dpad);

        int nextLineTabStop = max + descPad;
        renderWrappedText(sb, width, nextLineTabStop, optBuf.append(option.getDescription()).toString());
        if (i.hasNext()) {
            sb.append(defaultNewLine);
        }
    }

    return sb;
}

From source file:de.uni_koblenz.ist.utilities.option_handler.OptionHandler.java

/**
 * Used by the method getUsageString for adding an Option to the String.
 * /*from  www  .  j a v  a 2  s  . c  o  m*/
 * @param out
 *            The StringBuilder to write into.
 * @param current
 *            The option to add.
 */
private void appendOption(StringBuilder out, Option current) {
    out.append("-");
    out.append(current.getOpt());
    int numberOfArgs = current.getArgs();
    out.append(" ");
    if (current.hasOptionalArg()) {
        out.append("[");
    }
    if (numberOfArgs == Option.UNLIMITED_VALUES) {
        appendArgName(out, current);
        out.append("{");
        out.append(current.getValueSeparator());
        appendArgName(out, current);
        out.append("}");
    }
    if (numberOfArgs >= 1) {
        appendArgName(out, current);
        for (int i = 1; i < numberOfArgs; i++) {
            out.append(current.getValueSeparator());
            appendArgName(out, current);
        }
    }
    if (current.hasOptionalArg()) {
        out.append("]");
    }
}

From source file:com.netcrest.pado.tools.pado.command.put.java

@SuppressWarnings({ "unchecked", "rawtypes" })
@Override//  w  ww .  ja  v a2 s .  c o m
public void run(CommandLine commandLine, String command) throws Exception {
    String path = commandLine.getOptionValue("path");
    String bufferName = commandLine.getOptionValue("buffer");
    List<String> argList = commandLine.getArgList();

    if (path != null && bufferName != null) {
        PadoShell.printlnError(this, "Specifying both path and buffer not allowed. Only one option allowed.");
        return;
    }
    if (argList.size() < 2) {
        PadoShell.println(this, "Must specify key/value pair(s).");
        return;
    }
    if (path == null && bufferName == null) {
        path = padoShell.getCurrentPath();
    }

    boolean keyEnumerated = commandLine.hasOption('k');
    boolean valueEnumerated = commandLine.hasOption('v');
    Option options[] = commandLine.getOptions();
    for (Option option : options) {
        if (keyEnumerated == false) {
            keyEnumerated = option.getOpt().contains("k");
        }
        if (valueEnumerated == false) {
            valueEnumerated = option.getOpt().contains("v");
        }
    }

    int keyIndex = argList.indexOf(argList.get(1));
    String fullPath;
    String gridId;
    String gridPath;
    BufferInfo bufferInfo = null;
    if (path != null) {
        fullPath = padoShell.getFullPath(path);
        gridPath = GridUtil.getChildPath(fullPath);
        gridId = SharedCache.getSharedCache().getGridId(fullPath);
    } else {
        bufferInfo = SharedCache.getSharedCache().getBufferInfo(bufferName);
        if (bufferInfo == null) {
            PadoShell.printlnError(this, bufferName + ": Buffer undefined.");
            return;
        }
        gridId = bufferInfo.getGridId();
        gridPath = bufferInfo.getGridPath();
        if (gridId == null || gridPath == null) {
            PadoShell.printlnError(this, bufferName + ": Invalid buffer. This buffer does not contain keys.");
            return;
        }
        fullPath = SharedCache.getSharedCache().getPado().getCatalog().getGridService().getFullPath(gridId,
                gridPath);
    }
    Map map = getEntryMap(fullPath, bufferInfo, argList, keyEnumerated, valueEnumerated, keyIndex);
    IGridMapBiz gridMapBiz = SharedCache.getSharedCache().getPado().getCatalog().newInstance(IGridMapBiz.class,
            gridPath);
    gridMapBiz.getBizContext().getGridContextClient().setGridIds(gridId);
    gridMapBiz.putAll(map);

    // ArrayList keyList = new ArrayList();
    if (padoShell.isShowResults()) {
        PrintUtil.printEntries(gridMapBiz, map.keySet(), null);
    }
}

From source file:edu.cmu.tetrad.cli.ExtendedCommandLineParser.java

/**
 * Query to see if the option is passed in from command-line.
 *
 * @param option option to search for/*from  w ww.j  a v a  2 s .  co m*/
 * @param arguments inputs from the command-line
 * @return true if the option is passed in from command-line
 */
public boolean hasOption(Option option, String[] arguments) {
    if (option == null || arguments == null) {
        return false;
    }

    for (String argument : arguments) {
        if (argument.startsWith("--")) {
            argument = argument.substring(2, argument.length());
            if (argument.equals(option.getLongOpt())) {
                return true;
            }
        } else if (argument.startsWith("-")) {
            argument = argument.substring(1, argument.length());
            if (argument.equals(option.getOpt())) {
                return true;
            }
        }
    }

    return false;
}