Example usage for org.apache.commons.cli OptionGroup OptionGroup

List of usage examples for org.apache.commons.cli OptionGroup OptionGroup

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

Introduction

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

Prototype

OptionGroup

Source Link

Usage

From source file:com.discursive.jccook.cmdline.CliComplexExample.java

public static void main(String[] args) throws Exception {
    CommandLineParser parser = new BasicParser();

    Options options = new Options();
    options.addOption("h", "help", false, "Print this usage information");
    options.addOption("v", "verbose", false, "Print out VERBOSE debugging information");
    OptionGroup optionGroup = new OptionGroup();
    optionGroup.addOption(OptionBuilder.hasArg(true).create('f'));
    optionGroup.addOption(OptionBuilder.hasArg(true).create('m'));
    options.addOptionGroup(optionGroup);

    CommandLine commandLine = parser.parse(options, args);

    boolean verbose = false;
    String file = "";
    String mail = "";

    if (commandLine.hasOption('h')) {
        System.out.println("Help Message");
        System.exit(0);//from   w w w  .  ja  v a  2 s .  co  m
    }

    if (commandLine.hasOption('v')) {
        verbose = true;
    }

    if (commandLine.hasOption('f')) {
        file = commandLine.getOptionValue('f');
    } else if (commandLine.hasOption('m')) {
        mail = commandLine.getOptionValue('m');
    }

    System.exit(0);
}

From source file:de.burlov.amazon.s3.S3Utils.java

public static void main(String[] args) {
    Options opts = new Options();
    OptionGroup gr = new OptionGroup();
    gr.setRequired(true);/* www  . j a  v  a 2  s.c  o  m*/
    gr.addOption(new Option(LIST, false, ""));
    gr.addOption(new Option(DELETE, false, ""));

    opts.addOptionGroup(gr);

    opts.addOption(new Option("k", true, "Access key for AWS account"));
    opts.addOption(new Option("s", true, "Secret key for AWS account"));
    opts.addOption(new Option("b", true, "Bucket"));
    CommandLine cmd = null;
    try {
        cmd = new PosixParser().parse(opts, args);

        String accessKey = cmd.getOptionValue("k");
        if (StringUtils.isBlank(accessKey)) {
            System.out.println("Missing amazon access key");
            return;
        }
        String secretKey = cmd.getOptionValue("s");
        if (StringUtils.isBlank(secretKey)) {
            System.out.println("Missing secret key");
            return;
        }
        String bucket = cmd.getOptionValue("b");
        if (cmd.hasOption(LIST)) {
            if (StringUtils.isBlank(bucket)) {
                printBuckets(accessKey, secretKey);
            } else {
                printBucket(accessKey, secretKey, bucket);
            }
        } else if (cmd.hasOption(DELETE)) {
            if (StringUtils.isBlank(bucket)) {
                System.out.println("Bucket name required");
                return;
            }
            int count = deleteBucket(accessKey, secretKey, bucket);
            System.out.println("Deleted objects in bucket: " + count);
        }
    } catch (ParseException e) {
        System.out.println(e.getMessage());
        printUsage(opts);
        return;
    } catch (Exception e) {
        e.printStackTrace(System.err);
    }
}

From source file:com.dasasian.chok.tool.ZkTool.java

public static void main(String[] args) {
    final Options options = new Options();

    Option lsOption = new Option("ls", true, "list zp path contents");
    lsOption.setArgName("path");
    Option readOption = new Option("read", true, "read and print zp path contents");
    readOption.setArgName("path");
    Option rmOption = new Option("rm", true, "remove zk files");
    rmOption.setArgName("path");
    Option rmrOption = new Option("rmr", true, "remove zk directories");
    rmrOption.setArgName("path");

    OptionGroup actionGroup = new OptionGroup();
    actionGroup.setRequired(true);//from   ww  w  . j  a v a 2  s  .  c  o m
    actionGroup.addOption(lsOption);
    actionGroup.addOption(readOption);
    actionGroup.addOption(rmOption);
    actionGroup.addOption(rmrOption);
    options.addOptionGroup(actionGroup);

    final CommandLineParser parser = new GnuParser();
    HelpFormatter formatter = new HelpFormatter();
    try {
        final CommandLine line = parser.parse(options, args);
        ZkTool zkTool = new ZkTool();
        if (line.hasOption(lsOption.getOpt())) {
            String path = line.getOptionValue(lsOption.getOpt());
            zkTool.ls(path);
        } else if (line.hasOption(readOption.getOpt())) {
            String path = line.getOptionValue(readOption.getOpt());
            zkTool.read(path);
        } else if (line.hasOption(rmOption.getOpt())) {
            String path = line.getOptionValue(rmOption.getOpt());
            zkTool.rm(path, false);
        } else if (line.hasOption(rmrOption.getOpt())) {
            String path = line.getOptionValue(rmrOption.getOpt());
            zkTool.rm(path, true);
        }
        zkTool.close();
    } catch (ParseException e) {
        System.out.println(e.getClass().getSimpleName() + ": " + e.getMessage());
        formatter.printHelp(ZkTool.class.getSimpleName(), options);
    }

}

From source file:com.discursive.jccook.cmdline.SomeApp.java

public static void main(String[] args) throws Exception {

    // Create a Parser
    CommandLineParser parser = new BasicParser();
    Options options = new Options();
    options.addOption("h", "help", false, "Print this usage information");
    options.addOption("v", "verbose", false, "Print out VERBOSE information");

    OptionGroup optionGroup = new OptionGroup();
    optionGroup.addOption(OptionBuilder.hasArg(true).withArgName("file").withLongOpt("file").create('f'));
    optionGroup.addOption(OptionBuilder.hasArg(true).withArgName("email").withLongOpt("email").create('m'));
    options.addOptionGroup(optionGroup);

    // Parse the program arguments
    try {/*from  w w  w.j  a  va  2 s  .  co m*/
        CommandLine commandLine = parser.parse(options, args);

        if (commandLine.hasOption('h')) {
            printUsage(options);
            System.exit(0);
        }

        // ... do important stuff ...
    } catch (Exception e) {
        System.out.println("You provided bad program arguments!");
        printUsage(options);
        System.exit(1);
    }
}

From source file:com.quanticate.opensource.pdftkbox.PDFtkBox.java

public static void main(String[] args) throws Exception {
    // For printing help
    Options optsHelp = new Options();
    optsHelp.addOption(Option.builder("help").required().desc("print this message").build());

    // Normal-style import/export
    Options optsNormal = new Options();
    OptionGroup normal = new OptionGroup();
    Option optExport = Option.builder("export").required().hasArg().desc("export bookmarks from pdf")
            .argName("source-pdf").build();
    normal.addOption(optExport);/*from  w  w w.j  av  a  2  s  .c  om*/
    Option optImport = Option.builder("import").required().hasArg().desc("import bookmarks into pdf")
            .argName("source-pdf").build();
    normal.addOption(optImport);
    optsNormal.addOptionGroup(normal);
    Option optBookmarks = Option.builder("bookmarks").hasArg().desc("bookmarks definition file")
            .argName("bookmarks").build();
    optsNormal.addOption(optBookmarks);
    Option optOutput = Option.builder("output").hasArg().desc("output to new pdf").argName("pdf").build();
    optsNormal.addOption(optOutput);

    // PDFtk style options
    Options optsPDFtk = new Options();
    OptionGroup pdftk = new OptionGroup();
    Option optDumpData = Option.builder("dump_data").required().desc("dump bookmarks from pdf").build();
    pdftk.addOption(optDumpData);
    Option optUpdateInfo = Option.builder("update_info").required().hasArg().desc("update bookmarks in pdf")
            .argName("bookmarks").build();
    pdftk.addOption(optUpdateInfo);
    optsPDFtk.addOptionGroup(pdftk);
    optsPDFtk.addOption(optOutput);

    // What are we doing?
    CommandLineParser parser = new DefaultParser();

    // Did they want help?
    try {
        parser.parse(optsHelp, args);

        // If we get here, they asked for help
        doPrintHelp(optsHelp, optsNormal, optsPDFtk);
        return;
    } catch (ParseException pe) {
    }

    // Normal-style import/export?
    try {
        CommandLine line = parser.parse(optsNormal, args);

        // Export
        if (line.hasOption(optExport.getOpt())) {
            doExport(line.getOptionValue(optExport.getOpt()), line.getOptionValue(optBookmarks.getOpt()),
                    line.getArgs());
            return;
        }
        // Import with explicit output filename
        if (line.hasOption(optImport.getOpt()) && line.hasOption(optOutput.getOpt())) {
            doImport(line.getOptionValue(optImport.getOpt()), line.getOptionValue(optBookmarks.getOpt()),
                    line.getOptionValue(optOutput.getOpt()), null);
            return;
        }
        // Import with implicit output filename
        if (line.hasOption(optImport.getOpt()) && line.getArgs().length > 0) {
            doImport(line.getOptionValue(optImport.getOpt()), line.getOptionValue(optBookmarks.getOpt()), null,
                    line.getArgs());
            return;
        }
    } catch (ParseException pe) {
    }

    // PDFtk-style
    if (args.length > 1) {
        // Nobble things for PDFtk-style options and Commons CLI
        for (int i = 1; i < args.length; i++) {
            for (Option opt : optsPDFtk.getOptions()) {
                if (args[i].equals(opt.getOpt())) {
                    args[i] = "-" + args[i];
                }
            }
        }
        try {
            // Input file comes first, then arguments
            String input = args[0];
            String[] pargs = new String[args.length - 1];
            System.arraycopy(args, 1, pargs, 0, pargs.length);

            // Parse what's left and check
            CommandLine line = parser.parse(optsPDFtk, pargs);

            if (line.hasOption(optDumpData.getOpt())) {
                doExport(input, line.getOptionValue(optOutput.getOpt()), line.getArgs());
                return;
            }
            if (line.hasOption(optUpdateInfo.getOpt())) {
                doImport(input, line.getOptionValue(optUpdateInfo.getOpt()),
                        line.getOptionValue(optOutput.getOpt()), line.getArgs());
                return;
            }
        } catch (ParseException pe) {
        }
    }

    // If in doubt, print help
    doPrintHelp(optsHelp, optsNormal, optsPDFtk);
}

From source file:fdtutilscli.Main.java

/**
 * /*w  ww. j a  v  a  2s  . c  o m*/
 * @param args the command line arguments
 */
public static void main(String[] args) {

    CommandLineParser parser = new PosixParser();
    CommandLine line = null;
    Options options = new Options();
    OptionGroup optCommand = new OptionGroup();
    OptionGroup optOutput = new OptionGroup();
    HelpFormatter formatter = new HelpFormatter();
    TRACE trace = TRACE.DEFAULT;

    optCommand.addOption(OptionBuilder.withArgName("ndf odf nif key seperator").hasArgs(5)
            .withValueSeparator(' ').withDescription("Description").create("delta"));
    optCommand.addOption(OptionBuilder.withArgName("dupsfile key seperator").hasArgs(3)
            .withDescription("Description").create("duplicates"));
    optCommand.addOption(OptionBuilder.withLongOpt("help").withDescription("print this message.").create("h"));
    optCommand.addOption(
            OptionBuilder.withLongOpt("version").withDescription("print version information.").create("V"));
    optOutput.addOption(new Option("verbose", "be extra verbose"));
    optOutput.addOption(new Option("quiet", "be extra quiet"));
    optOutput.addOption(new Option("silent", "same as --quiet"));
    options.addOptionGroup(optCommand);
    options.addOptionGroup(optOutput);

    try {
        line = parser.parse(options, args);

        if (line.hasOption("verbose")) {
            trace = TRACE.VERBOSE;
        } else if (line.hasOption("quiet") || line.hasOption("silent")) {
            trace = TRACE.QUIET;
        }

        if (line.hasOption("h")) {
            formatter.printHelp(HELP_SYNTAX, HELP_HEADER, options, null, true);
            return;
        } else if (line.hasOption("V")) {
            System.out.println(APP_NAME + " version " + VERSION);
            System.out.println("fDTDeltaBuilder version " + DTDeltaBuilder.version());
            System.out.println("DTDuplicateKeyFinder version " + DTDuplicateKeyFinder.version());
            return;
        } else if (line.hasOption("delta")) {
            String ndf = line.getOptionValues("delta")[0];
            String odf = line.getOptionValues("delta")[1];
            String nif = line.getOptionValues("delta")[2];
            Integer key = (line.getOptionValues("delta").length <= 3) ? DEFAULT_KEY
                    : new Integer(line.getOptionValues("delta")[3]);
            String seperator = (line.getOptionValues("delta").length <= 4) ? DEFAULT_SEPERATOR
                    : line.getOptionValues("delta")[4];

            doDelta(ndf, odf, nif, key.intValue(), seperator, trace);

            return;
        } else if (line.hasOption("duplicates")) {
            String dupsFile = line.getOptionValues("duplicates")[0];
            Integer key = (line.getOptionValues("duplicates").length <= 1) ? DEFAULT_KEY
                    : new Integer(line.getOptionValues("duplicates")[1]);
            String seperator = (line.getOptionValues("duplicates").length <= 2) ? DEFAULT_SEPERATOR
                    : line.getOptionValues("duplicates")[2];
            doDuplicates(dupsFile, key.intValue(), seperator, trace);
            return;
        } else if (args.length == 0) {
            formatter.printHelp(HELP_SYNTAX, HELP_HEADER, options, null, true);
        } else {
            throw new UnrecognizedOptionException(E_MSG_UNREC_OPT);
        }

    } catch (UnrecognizedOptionException e) {
        formatter.printHelp(HELP_SYNTAX, HELP_HEADER, options, HELP_FOOTER + e.getMessage(), true);
    } catch (ParseException e) {
        formatter.printHelp(HELP_SYNTAX, HELP_HEADER, options, HELP_FOOTER + e.getMessage(), true);
    }
}

From source file:edu.wisc.doit.tcrypt.cli.TokenCrypt.java

public static void main(String[] args) throws IOException {
    // create Options object
    final Options options = new Options();

    // operation opt group
    final OptionGroup cryptTypeGroup = new OptionGroup();
    cryptTypeGroup.addOption(new Option("e", "encrypt", false, "Encrypt a token"));
    cryptTypeGroup.addOption(new Option("d", "decrypt", false, "Decrypt a token"));
    cryptTypeGroup//from   w  ww . j av  a2s. c  o m
            .addOption(new Option("c", "check", false, "Check if the string looks like an encrypted token"));
    cryptTypeGroup.setRequired(true);
    options.addOptionGroup(cryptTypeGroup);

    // token source opt group
    final OptionGroup tokenGroup = new OptionGroup();
    final Option tokenOpt = new Option("t", "token", true, "The token(s) to operate on");
    tokenOpt.setArgs(Option.UNLIMITED_VALUES);
    tokenGroup.addOption(tokenOpt);
    final Option tokenFileOpt = new Option("f", "file", true,
            "A file with one token per line to operate on, if - is specified stdin is used");
    tokenGroup.addOption(tokenFileOpt);
    tokenGroup.setRequired(true);
    options.addOptionGroup(tokenGroup);

    final Option keyOpt = new Option("k", "keyFile", true,
            "Key file to use. Must be a private key for decryption and a public key for encryption");
    keyOpt.setRequired(true);
    options.addOption(keyOpt);

    // create the parser
    final CommandLineParser parser = new GnuParser();
    CommandLine line = null;
    try {
        // parse the command line arguments
        line = parser.parse(options, args);
    } catch (ParseException exp) {
        // automatically generate the help statement
        System.err.println(exp.getMessage());
        final HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp("java " + TokenCrypt.class.getName(), options, true);
        System.exit(1);
    }

    final Reader keyReader = createKeyReader(line);

    final TokenHandler tokenHandler = createTokenHandler(line, keyReader);

    if (line.hasOption("t")) {
        //tokens on cli
        final String[] tokens = line.getOptionValues("t");
        for (final String token : tokens) {
            handleToken(tokenHandler, token);
        }
    } else {
        //tokens from a file
        final String tokenFile = line.getOptionValue("f");
        final BufferedReader fileReader;
        if ("-".equals(tokenFile)) {
            fileReader = new BufferedReader(new InputStreamReader(System.in));
        } else {
            fileReader = new BufferedReader(new FileReader(tokenFile));
        }

        while (true) {
            final String token = fileReader.readLine();
            if (token == null) {
                break;
            }

            handleToken(tokenHandler, token);
        }
    }
}

From source file:io.github.azige.whitespace.Cli.java

public static void main(String[] args) {
    Options options = new Options().addOption("h", "help", false, "??")
            .addOptionGroup(new OptionGroup()
                    .addOption(new Option("p",
                            "????????"))
                    .addOption(new Option("c", "?????")))
            .addOption(null, "szm", false,
                    "????")
            .addOption("e", "encoding", true, "??" + DEFAULT_ENCODING);

    try {/*  w ww . ja v  a2s .  com*/
        CommandLineParser parser = new BasicParser();
        CommandLine cl = parser.parse(options, args);

        if (cl.hasOption('h')) {
            printHelp(System.out, options);
            return;
        }

        if (cl.hasOption('e')) {
            encoding = Charset.forName(cl.getOptionValue('e'));
        } else {
            encoding = Charset.forName(DEFAULT_ENCODING);
        }

        if (cl.hasOption("szm")) {
            useSzm = true;
        }

        String[] fileArgs = cl.getArgs();
        if (fileArgs.length != 1) {
            printHelp(System.err, options);
            return;
        }

        try (InputStream input = Files.newInputStream(Paths.get(fileArgs[0]))) {
            if (cl.hasOption('p')) {
                printPseudoCode(input);
            } else if (cl.hasOption('c')) {
                compile(input, fileArgs[0]);
            } else {
                execute(input, fileArgs[0]);
            }
        }
    } catch (ParseException ex) {
        ex.printStackTrace();
        printHelp(System.err, options);
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

From source file:de.uni_koblenz.jgralabtest.non_junit_tests.TryCLI.java

/**
 * @param args/*w w w.  ja  v  a  2 s.c  o m*/
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    OptionHandler oh = new OptionHandler("TryCli", "version 0.0");

    // Option multipleValues = new Option("m", "multiple", true,
    // "Can occur multiple times.");
    // multipleValues.setRequired(true);
    // multipleValues.setArgName("arg");
    // multipleValues.setValueSeparator(',');
    // multipleValues.setArgs(Option.UNLIMITED_VALUES);

    // Option multipleValues2 = new Option("M", "Multiple", true,
    // "Can occur multiple times.");
    // multipleValues2.setRequired(false);
    // multipleValues2.setArgName("arg");
    // multipleValues2.setValueSeparator(',');
    // multipleValues2.setOptionalArg(true);
    // multipleValues2.setArgs(Option.UNLIMITED_VALUES);

    Option test = new Option("t", "test", false, "For testing purpose.");
    test.setRequired(false);
    oh.addOption(test);

    Option test2 = new Option("T", "Test", false, "For testing purpose.");
    test2.setRequired(false);
    oh.addOption(test2);

    OptionGroup og = new OptionGroup();
    og.addOption(test);
    og.addOption(test2);
    og.setRequired(true);
    oh.addOptionGroup(og);

    // oh.addOption(multipleValues);
    // oh.addOption(multipleValues2);

    CommandLine cmd = oh.parse(args);

    if (cmd.hasOption('t')) {
        System.out.println("Test1 set");
    }
    if (cmd.hasOption('T')) {
        System.out.println("Test2 set");
    }

}

From source file:name.wagners.fssp.Main.java

/**
 * @param args//from  w w w.j ava 2 s.co m
 *            command-line arguments
 */
public static void main(final String[] args) {
    // create the command line parser
    CommandLineParser parser = new PosixParser();

    // create the Options
    Options options = new Options();

    options.addOption(OptionBuilder.hasArg().withArgName("gn").withLongOpt("generations")
            .withDescription("Number of generations [default: 50]").withType(Integer.valueOf(0)).create("g"));

    options.addOption(OptionBuilder.hasArg().withArgName("mp").withLongOpt("mutation")
            .withDescription("Mutation propability [default: 0.5]").withType(Double.valueOf(0)).create("m"));

    options.addOption(OptionBuilder.hasArg().withArgName("ps").withLongOpt("populationsize")
            .withDescription("Size of population [default: 20]").withType(Integer.valueOf(0)).create("p"));

    options.addOption(OptionBuilder.hasArg().withArgName("rp").withLongOpt("recombination")
            .withDescription("Recombination propability [default: 0.8]").withType(Double.valueOf(0))
            .create("r"));

    options.addOption(OptionBuilder.hasArg().withArgName("sp").withLongOpt("selectionpressure")
            .withDescription("Selection pressure [default: 4]").withType(Integer.valueOf(0)).create("s"));

    options.addOption(OptionBuilder.withLongOpt("help").withDescription("print this message").create("h"));

    options.addOption(OptionBuilder.hasArg().withArgName("filename").isRequired().withLongOpt("file")
            .withDescription("Problem file [default: \"\"]").withType(String.valueOf("")).create("f"));

    options.addOptionGroup(new OptionGroup()
            .addOption(OptionBuilder.withLongOpt("verbose").withDescription("be extra verbose").create("v"))
            .addOption(OptionBuilder.withLongOpt("quiet").withDescription("be extra quiet").create("q")));

    options.addOption(OptionBuilder.withLongOpt("version")
            .withDescription("print the version information and exit").create("V"));

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

        // validate that block-size has been set
        if (line.hasOption("h")) {
            // automatically generate the help statement
            HelpFormatter formatter = new HelpFormatter();
            formatter.printHelp("fssp", options);
        }

    } catch (MissingOptionException exp) {
        log.info("An option was missing:" + exp.getMessage(), exp);

        // automatically generate the help statement
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp("fssp", options);
    } catch (MissingArgumentException exp) {
        log.info("An argument was missing:" + exp.getMessage(), exp);

        // automatically generate the help statement
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp("fssp", options);
    } catch (AlreadySelectedException exp) {
        // automatically generate the help statement
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp("fssp", options);
    } catch (ParseException exp) {
        log.info("Unexpected exception:" + exp.getMessage(), exp);

        // automatically generate the help statement
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp("fssp", options);

        System.exit(1);
    }

    // Ausgabe der eingestellten Optionen

    log.info("Configuration");
    // log.info(" Datafile: {}", fname);
}