Example usage for org.apache.commons.cli OptionGroup 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:net.ripe.rpki.validator.cli.CommandLineOptions.java

private void addCommandGroup() {
    OptionGroup group = new OptionGroup();

    Option helpOption = new Option("h", HELP, false, "Show usage information");
    group.addOption(helpOption);//from  www  . j  a v a 2  s  .  co m

    Option versionOption = new Option(null, VERSION, false, "Show version information");
    group.addOption(versionOption);

    Option printOption = new Option("p", PRINT, false,
            "Show the certificate repository object in a readable format");
    group.addOption(printOption);

    Option talOption = new Option("t", TAL, true,
            "Trust Anchor Locator (TAL). Can be specified more than once.");
    talOption.setArgs(Option.UNLIMITED_VALUES);
    group.addOption(talOption);

    group.setRequired(true);
    options.addOptionGroup(group);
}

From source file:com.hp.mqm.clt.CliParser.java

public CliParser() {
    options.addOption("h", "help", false, "show this help");
    options.addOption("v", "version", false, "show version of this tool");

    options.addOption("i", "internal", false, "supplied XML files are in the API internal XML format");
    options.addOption("e", "skip-errors", false, "skip errors on the server side");
    options.addOption(Option.builder("o").longOpt("output-file")
            .desc("write output to file instead of pushing it to the server").hasArg().argName("FILE").build());
    options.addOption(Option.builder("c").longOpt("config-file").desc("configuration file location").hasArg()
            .argName("FILE").build());

    options.addOption(Option.builder("s").longOpt("server").desc("server URL with protocol and port").hasArg()
            .argName("URL:PORT").build());
    options.addOption(Option.builder("d").longOpt("shared-space").desc("server shared space to push to")
            .hasArg().argName("ID").type(Number.class).build());
    options.addOption(Option.builder("w").longOpt("workspace").desc("server workspace to push to").hasArg()
            .argName("ID").type(Number.class).build());

    options.addOption(//from ww  w  .  java  2 s. c o  m
            Option.builder("u").longOpt("user").desc("server username").hasArg().argName("USERNAME").build());
    OptionGroup passGroup = new OptionGroup();
    passGroup.addOption(Option.builder("p").longOpt("password").desc("server password").hasArg()
            .argName("PASSWORD").optionalArg(true).build());
    passGroup.addOption(Option.builder().longOpt("password-file").desc("location of file with server password")
            .hasArg().argName("FILE").build());
    options.addOptionGroup(passGroup);

    options.addOption(
            Option.builder().longOpt("proxy-host").desc("proxy host").hasArg().argName("HOSTNAME").build());
    options.addOption(Option.builder().longOpt("proxy-port").desc("proxy port").hasArg().argName("PORT")
            .type(Number.class).build());
    options.addOption(
            Option.builder().longOpt("proxy-user").desc("proxy username").hasArg().argName("USERNAME").build());

    OptionGroup proxyPassGroup = new OptionGroup();
    proxyPassGroup.addOption(Option.builder().longOpt("proxy-password").desc("proxy password").hasArg()
            .argName("PASSWORD").optionalArg(true).build());
    proxyPassGroup.addOption(Option.builder().longOpt("proxy-password-file")
            .desc("location of file with proxy password").hasArg().argName("FILE").build());
    options.addOptionGroup(proxyPassGroup);

    options.addOption(
            Option.builder().longOpt("check-result").desc("check test result status after push").build());
    options.addOption(Option.builder().longOpt("check-result-timeout")
            .desc("timeout for test result push status retrieval").hasArg().argName("SEC").type(Number.class)
            .build());

    options.addOption(Option.builder("t").longOpt("tag").desc("assign tag to test result").hasArg()
            .argName("TYPE:VALUE").build());
    options.addOption(Option.builder("f").longOpt("field").desc("assign field tag to test result").hasArg()
            .argName("TYPE:VALUE").build());

    options.addOption(Option.builder("r").longOpt("release").desc("assign release to test result").hasArg()
            .argName("ID").type(Number.class).build());
    options.addOption(Option.builder("a").longOpt("product-area").desc("assign the test result to product area")
            .hasArg().argName("ID").type(Number.class).build());
    options.addOption(Option.builder("b").longOpt("backlog-item").desc("assign the test result to backlog item")
            .hasArg().argName("ID").type(Number.class).build());
    options.addOption(Option.builder().longOpt("started").desc("start time in milliseconds").hasArg()
            .argName("TIMESTAMP").type(Number.class).build());

    argsWithSingleOccurrence.addAll(Arrays.asList("o", "c", "s", "d", "w", "u", "p", "password-file", "r",
            "started", "check-status", "check-status-timeout", "proxy-host", "proxy-port", "proxy-user",
            "proxy-password", "proxy-password-file"));
    argsRestrictedForInternal.addAll(Arrays.asList("o", "t", "f", "r", "a", "b", "started"));
}

From source file:com.ericsson.eiffel.remrem.publish.cli.CliOptions.java

private static OptionGroup createContentGroup() {
    OptionGroup group = new OptionGroup();
    group.addOption(createFileOption());
    group.addOption(createJsonOption());
    return group;
}

From source file:com.continuent.tungsten.common.security.KeystoreManagerCtrl.java

/**
 * Setup command line options//from  w w w .j a  v  a  2 s. c  o  m
 */
@SuppressWarnings("static-access")
private void setupCommandLine() {
    // --- Options on the command line ---
    Option help = OptionBuilder.withLongOpt(HELP).withDescription("Displays this message").create(_HELP);

    // Mutually excluding options
    OptionGroup optionGroup = new OptionGroup();
    check = OptionBuilder.withLongOpt(CHECK).hasArgs(0).withDescription("Checks key password inside a keystore")
            .create(_CHECK);

    optionGroup.addOption(check);
    optionGroup.setRequired(true); // At least 1 command required

    // --- Options replacing parameters from security.properties ---
    Option keystoreLocation = OptionBuilder.withLongOpt(KEYSTORE_LOCATION).withArgName("filename").hasArg()
            .withDescription("Location of the keystore file").isRequired().create(_KEYSTORE_LOCATION);
    Option keyAlias = OptionBuilder.withLongOpt(KEY_ALIAS).withArgName("key alias").hasArg().isRequired()
            .withDescription("Alias for the key").create(_KEY_ALIAS);
    Option keyType = OptionBuilder.withLongOpt(KEY_TYPE).withArgName("key type").hasArg().isRequired()
            .withDescription(MessageFormat.format("Type of key: {0}", KEYSTORE_TYPE.getListValues("|")))
            .create(_KEY_TYPE);

    Option keystorePassword = OptionBuilder.withLongOpt(KEYSTORE_PASSWORD).withArgName("password").hasArg()
            .withDescription("Password for the keystore file").create(_KEYSTORE_PASSWORD);
    Option keyPassword = OptionBuilder.withLongOpt(KEY_PASSWORD).withArgName("key password").hasArg()
            .withDescription("Password for the key").create(_KEY_PASSWORD);

    // --- Add options to the list ---
    // --- Help
    this.helpOptions.addOption(help);

    // --- Program command line options
    this.options.addOptionGroup(optionGroup);
    this.options.addOption(help);
    this.options.addOption(keystoreLocation);
    this.options.addOption(keyAlias);
    this.options.addOption(keyType);
    this.options.addOption(keystorePassword);
    this.options.addOption(keyPassword);
}

From source file:ditl.graphs.cli.Analyze.java

@Override
protected void initOptions() {
    super.initOptions();
    graph_options.setOptions(options);//from ww  w  . j  a  va  2  s .co m
    final OptionGroup reportGroup = new OptionGroup();
    reportGroup.addOption(new Option(null, nodeCountOption, false, "node count report"));
    reportGroup.addOption(new Option(null, transitTimesOption, false, "transit times report"));
    reportGroup.addOption(new Option(null, timeToFirstContactOption, false, "time to first contact report"));
    reportGroup.addOption(new Option(null, numContactsOption, false, "number of contacs distribution"));
    reportGroup.addOption(new Option(null, nodeDegreeOption, false, "node degree distribution over time"));
    reportGroup.addOption(new Option(null, contactsOption, false, "contact time distribution"));
    reportGroup.addOption(new Option(null, interContactsOption, false, "inter-contact time distribution"));
    reportGroup.addOption(new Option(null, anyContactsOption, false, "any-contact time distribution"));
    reportGroup
            .addOption(new Option(null, interAnyContactsOption, false, "inter-any-contact time distribution"));
    reportGroup.addOption(
            new Option(null, clusteringOption, false, "clustering coefficient distribution over time"));
    reportGroup.addOption(new Option(null, groupSizeOption, false, "distribution of group sizes over time"));
    reportGroup.addOption(new Option(null, reachabilityOption, false,
            "proportion of bi-directional and directional edges in the reachability graph"));
    reportGroup.setRequired(true);
    options.addOptionGroup(reportGroup);
    options.addOption(null, maxTimeOption, true, "Ignore event after <arg> seconds");
    options.addOption(null, minTimeOption, true, "Ignore event before <arg> seconds");
}

From source file:iDynoOptimizer.MOEAFramework26.src.org.moeaframework.analysis.sensitivity.ExtractData.java

@SuppressWarnings("static-access")
@Override//from w w  w. j  a  v a  2s . c om
public Options getOptions() {
    Options options = super.getOptions();

    OptionGroup group = new OptionGroup();
    group.setRequired(true);
    group.addOption(OptionBuilder.withLongOpt("problem").hasArg().withArgName("name").create('b'));
    group.addOption(OptionBuilder.withLongOpt("dimension").hasArg().withArgName("number").create('d'));
    options.addOptionGroup(group);

    options.addOption(OptionBuilder.withLongOpt("input").hasArg().withArgName("file").isRequired().create('i'));
    options.addOption(OptionBuilder.withLongOpt("output").hasArg().withArgName("file").create('o'));
    options.addOption(OptionBuilder.withLongOpt("separator").hasArg().withArgName("value").create('s'));
    options.addOption(OptionBuilder.withLongOpt("reference").hasArg().withArgName("file").create('r'));
    options.addOption(OptionBuilder.withLongOpt("epsilon").hasArg().withArgName("e1,e2,...").create('e'));
    options.addOption(OptionBuilder.withLongOpt("noheader").create('n'));

    return options;
}

From source file:bdsup2sub.cli.CommandLineOptions.java

private void createAndAddOptions() {
    Option help = OptionBuilder.withLongOpt("help").withDescription("Show usage information and exit.")
            .hasArg(false).create(HELP);
    options.addOption(help);//  ww  w. ja va 2 s .  c  o  m

    Option version = OptionBuilder.withLongOpt("version").withDescription("Show version information and exit.")
            .hasArg(false).create(VERSION);
    options.addOption(version);

    Option output = OptionBuilder.withLongOpt("output").withDescription("Specify output file.").hasArg()
            .create(OUTPUT_FILE);
    options.addOption(output);

    Option verbose = OptionBuilder.withLongOpt("verbose").withDescription("Verbose console output mode.")
            .hasArg(false).create(VERBOSE);
    options.addOption(verbose);

    Option loadSettings = OptionBuilder.withLongOpt("load-settings")
            .withDescription("Load settings stored in configuration file even if running in command-line mode.")
            .hasArg(false).create(LOAD_SETTINGS);
    options.addOption(loadSettings);

    Option resolution = OptionBuilder.withArgName("resolution").withLongOpt("resolution").withDescription(
            "Set resolution to: keep, ntsc=480, pal=576, 720p=720, 1080p=1080, 1440x1080\nDefault: keep")
            .hasArg().create(RESOLUTION);
    options.addOption(resolution);

    OptionGroup framerateGroup = new OptionGroup();
    Option targetFrameRate = OptionBuilder.withArgName("fps").withLongOpt("fps-target").withDescription(
            "Synchronize target frame rate to <fps>.\nPredefined values: 24p=23.976, pal or 25p=25, ntsc or 30p=29.967, keep (preserves the source fps for BD&XML, else default)\nDefault: automatic (dumb!).")
            .hasArg().create(TARGET_FRAMERATE);
    framerateGroup.addOption(targetFrameRate);

    Option convertFrameRate = OptionBuilder.withArgName("src>, <trg").withLongOpt("convert-fps")
            .withDescription(
                    "Convert frame rate from <src> to <trg>\nSupported values: 24p=23.976, 25p=25, 30p=29.970\nauto,<trg> detects source frame rate.")
            .withValueSeparator(',').hasArgs(2).create(CONVERT_FRAMERATE);
    framerateGroup.addOption(convertFrameRate);

    options.addOptionGroup(framerateGroup);

    Option delay = OptionBuilder.withArgName("delay").withLongOpt("delay")
            .withDescription("Set delay in ms\nDefault: 0.0").hasArg().create(DELAY);
    options.addOption(delay);

    Option filter = OptionBuilder.withArgName("filter").withLongOpt("filter").withDescription(
            "Set the filter to use for scaling.\nSupported values: bilinear, triangle, bicubic, bell, b-spline, hermite, lanczos3, mitchell\nDefault: bilinear")
            .hasArg().create(SCALING_FILTER);
    options.addOption(filter);

    Option paletteMode = OptionBuilder.withArgName("mode").withLongOpt("palette-mode")
            .withDescription("Set palette mode.\nSupported values: keep, create, dither\nDefault: create")
            .hasArg().create(PALETTE_MODE);
    options.addOption(paletteMode);

    Option minDisplayTime = OptionBuilder.withArgName("time").withLongOpt("minimum-time")
            .withDescription("Set minimum display time in ms.\nDefault: 500").hasArg().create(MIN_DISPLAY_TIME);
    options.addOption(minDisplayTime);

    Option maxTimeDiff = OptionBuilder.withArgName("time").withLongOpt("merge-time")
            .withDescription("Set maximum time difference for merging subtitles in ms.\nDefault: 200").hasArg()
            .create(MAX_TIME_DIFF);
    options.addOption(maxTimeDiff);

    OptionGroup moveGroup = new OptionGroup();
    Option moveIn = OptionBuilder.withArgName("ratio, offset").withLongOpt("move-in")
            .withDescription("Move captions inside screen ratio <ratio>, +/- offset <offset>")
            .withValueSeparator(',').hasArgs(2).create(MOVE_IN);
    moveGroup.addOption(moveIn);

    Option moveOut = OptionBuilder.withArgName("ratio, offset").withLongOpt("move-out")
            .withDescription("Move captions outside screen ratio <ratio>, +/- offset <offset>")
            .withValueSeparator(',').hasArgs(2).create(MOVE_OUT);
    moveGroup.addOption(moveOut);

    options.addOptionGroup(moveGroup);

    Option moveX = OptionBuilder.withArgName("pos[, offset]").withLongOpt("move-x").withDescription(
            "Move captions horizontally from specified position. <pos> may be left, right, center\n+/- optional offset <offset> (only if moving left or right)")
            .withValueSeparator(',').hasOptionalArgs(2).create(MOVE_X);
    options.addOption(moveX);

    Option cropLines = OptionBuilder.withArgName("n").withLongOpt("crop-y")
            .withDescription("Crop the upper/lower n lines.\nDefault: 0").hasArg().create(CROP_LINES);
    options.addOption(cropLines);

    Option alphaCropThreshold = OptionBuilder.withArgName("n").withLongOpt("alpha-crop")
            .withDescription("Set the alpha cropping threshold.\nDefault: 10").hasArg()
            .create(ALPHA_CROP_THRESHOLD);
    options.addOption(alphaCropThreshold);

    Option scale = OptionBuilder.withArgName("x, y").withLongOpt("scale")
            .withDescription("Scale captions horizontally and vertically.\nDefault: 1.0,1.0")
            .withValueSeparator(',').hasArgs(2).create(SCALE);
    options.addOption(scale);

    Option exportPalette = OptionBuilder.withLongOpt("export-palette")
            .withDescription("Export target palette in PGCEdit format.").hasArg(false).create(EXPORT_PALETTE);
    options.addOption(exportPalette);

    Option exportForcedSubtitlesOnly = OptionBuilder.withLongOpt("forced-only")
            .withDescription("Export only forced subtitles (when converting from BD-SUP).").hasArg(false)
            .create(EXPORT_FORCED_SUBTITLES_ONLY);
    options.addOption(exportForcedSubtitlesOnly);

    Option setForcedFlag = OptionBuilder.withArgName("state").withLongOpt("force-all")
            .withDescription("Set or clear the forced flag for all subtitles.\nSupported values: set, clear")
            .hasArg().create(FORCED_FLAG);
    options.addOption(setForcedFlag);

    Option swapCrCb = OptionBuilder.withLongOpt("swap")
            .withDescription("Swap Cr/Cb components when loading a BD/HD-DVD sup file.").hasArg(false)
            .create(SWAP_CR_CB);
    options.addOption(swapCrCb);

    Option fixInvisibleFrames = OptionBuilder.withLongOpt("fix-invisible")
            .withDescription("Fix zero alpha frame palette for SUB/IDX and SUP/IFO.").hasArg(false)
            .create(FIX_INVISIBLE_FRAMES);
    options.addOption(fixInvisibleFrames);

    Option alphaThreshold = OptionBuilder.withArgName("n").withLongOpt("alpha-thr")
            .withDescription("Set alpha threshold 0..255 for SUB/IDX conversion.\nDefault: 80").hasArg()
            .create(ALPHA_THRESHOLD);
    options.addOption(alphaThreshold);

    Option luminanceLowMedThreshold = OptionBuilder.withArgName("n").withLongOpt("lum-low-med-thr")
            .withDescription("Set luminance lo/med threshold 0..255 for SUB/IDX conversion.\nDefault: auto")
            .hasArg().create(LUM_LOW_MED_THRESHOLD);
    options.addOption(luminanceLowMedThreshold);

    Option luminanceMedHighThreshold = OptionBuilder.withArgName("n").withLongOpt("lum-med-hi-thr")
            .withDescription("Set luminance med/hi threshold 0..255 for SUB/IDX conversion.\nDefault: auto")
            .hasArg().create(LUM_MED_HIGH_THRESHOLD);
    options.addOption(luminanceMedHighThreshold);

    Option languageCode = OptionBuilder.withArgName("language").withLongOpt("language")
            .withDescription("Set language for SUB/IDX export.\nDefault: en").hasArg().create(LANGUAGE_CODE);
    options.addOption(languageCode);

    Option paletteFile = OptionBuilder.withArgName("file").withLongOpt("palette-file")
            .withDescription("Load palette file for SUB/IDX conversion. Overrides default palette.").hasArg()
            .create(PALETTE_FILE);
    options.addOption(paletteFile);
}

From source file:com.example.dlp.RiskAnalysis.java

/**
 * Command line application to perform risk analysis using the Data Loss Prevention API.
 * Supported data format: BigQuery tables
 *///w w  w.  j a va 2 s. c o  m
public static void main(String[] args) throws Exception {

    OptionGroup optionsGroup = new OptionGroup();
    optionsGroup.setRequired(true);

    Option numericalAnalysisOption = new Option("n", "numerical");
    optionsGroup.addOption(numericalAnalysisOption);

    Option categoricalAnalysisOption = new Option("c", "categorical");
    optionsGroup.addOption(categoricalAnalysisOption);

    Option kanonymityOption = new Option("k", "kAnonymity");
    optionsGroup.addOption(kanonymityOption);

    Option ldiversityOption = new Option("l", "lDiversity");
    optionsGroup.addOption(ldiversityOption);

    Options commandLineOptions = new Options();
    commandLineOptions.addOptionGroup(optionsGroup);

    Option datasetIdOption = Option.builder("datasetId").hasArg(true).required(false).build();
    commandLineOptions.addOption(datasetIdOption);

    Option tableIdOption = Option.builder("tableId").hasArg(true).required(false).build();
    commandLineOptions.addOption(tableIdOption);

    Option projectIdOption = Option.builder("projectId").hasArg(true).required(false).build();
    commandLineOptions.addOption(projectIdOption);

    Option columnNameOption = Option.builder("columnName").hasArg(true).required(false).build();
    commandLineOptions.addOption(columnNameOption);

    Option sensitiveAttributeOption = Option.builder("sensitiveAttribute").hasArg(true).required(false).build();
    commandLineOptions.addOption(sensitiveAttributeOption);

    Option quasiIdColumnNamesOption = Option.builder("quasiIdColumnNames").hasArg(true).required(false).build();
    commandLineOptions.addOption(quasiIdColumnNamesOption);

    CommandLineParser parser = new DefaultParser();
    HelpFormatter formatter = new HelpFormatter();
    CommandLine cmd;

    try {
        cmd = parser.parse(commandLineOptions, args);
    } catch (ParseException e) {
        System.out.println(e.getMessage());
        formatter.printHelp(RiskAnalysis.class.getName(), commandLineOptions);
        System.exit(1);
        return;
    }

    String datasetId = cmd.getOptionValue(datasetIdOption.getOpt());
    String tableId = cmd.getOptionValue(tableIdOption.getOpt());
    // use default project id when project id is not specified
    String projectId = cmd.getOptionValue(projectIdOption.getOpt(), ServiceOptions.getDefaultProjectId());

    if (cmd.hasOption("n")) {
        // numerical stats analysis
        String columnName = cmd.getOptionValue(columnNameOption.getOpt());
        calculateNumericalStats(projectId, datasetId, tableId, columnName);
    } else if (cmd.hasOption("c")) {
        // categorical stats analysis
        String columnName = cmd.getOptionValue(columnNameOption.getOpt());
        calculateCategoricalStats(projectId, datasetId, tableId, columnName);
    } else if (cmd.hasOption("k")) {
        // k-anonymity analysis
        List<String> quasiIdColumnNames = Arrays.asList(cmd.getOptionValues(quasiIdColumnNamesOption.getOpt()));
        calculateKAnonymity(projectId, datasetId, tableId, quasiIdColumnNames);
    } else if (cmd.hasOption("l")) {
        // l-diversity analysis
        String sensitiveAttribute = cmd.getOptionValue(sensitiveAttributeOption.getOpt());
        List<String> quasiIdColumnNames = Arrays.asList(cmd.getOptionValues(quasiIdColumnNamesOption.getOpt()));
        calculateLDiversity(projectId, datasetId, tableId, sensitiveAttribute, quasiIdColumnNames);
    }
}

From source file:com.github.triceo.robozonky.app.CommandLineInterface.java

/**
 * Parse the command line./*from  ww w  .j ava2  s .c om*/
 *
 * @param args Command line arguments as received by {@link App#main(String...)}.
 * @return Empty if parsing failed, at which point it will write standard help message to sysout.
 */
public static Optional<CommandLineInterface> parse(final String... args) {
    // create the mode of operation
    final OptionGroup operatingModes = new OptionGroup();
    operatingModes.setRequired(true);
    Stream.of(OperatingMode.values()).forEach(mode -> operatingModes.addOption(mode.getSelectingOption()));
    // find all options from all modes of operation
    final Collection<Option> ops = Stream.of(OperatingMode.values()).map(OperatingMode::getOtherOptions)
            .collect(LinkedHashSet::new, LinkedHashSet::addAll, LinkedHashSet::addAll);
    // include authentication options
    final OptionGroup authenticationModes = new OptionGroup();
    authenticationModes.setRequired(true);
    authenticationModes.addOption(CommandLineInterface.OPTION_USERNAME);
    authenticationModes.addOption(CommandLineInterface.OPTION_KEYSTORE);
    ops.add(CommandLineInterface.OPTION_PASSWORD);
    ops.add(CommandLineInterface.OPTION_USE_TOKEN);
    ops.add(CommandLineInterface.OPTION_FAULT_TOLERANT);
    ops.add(CommandLineInterface.OPTION_CLOSED_SEASON);
    ops.add(CommandLineInterface.OPTION_ZONK);
    // join all in a single config
    final Options options = new Options();
    options.addOptionGroup(operatingModes);
    options.addOptionGroup(authenticationModes);
    ops.forEach(options::addOption);
    final CommandLineParser parser = new DefaultParser();
    // and parse
    try {
        final CommandLine cli = parser.parse(options, args);
        CommandLineInterface.logOptionValues(cli);
        return Optional.of(new CommandLineInterface(options, cli));
    } catch (final ParseException ex) {
        CommandLineInterface.printHelp(options, ex.getMessage(), true);
        return Optional.empty();
    }
}

From source file:com.falcon.orca.helpers.CommandHelper.java

public static Options createOptions() {
    Option start = Option.builder("s").longOpt("start").build();
    Option stop = Option.builder("st").longOpt("stop").build();
    Option pause = Option.builder("p").longOpt("pause").build();
    Option continueOpt = Option.builder("re").longOpt("resume").build();
    Option exit = Option.builder("e").longOpt("exit").build();
    Option url = Option.builder("U").longOpt("url").hasArg(true).build();
    Option durationMode = Option.builder("DM").longOpt("durationMode").hasArg(true).build();
    Option duration = Option.builder("DU").longOpt("duration").hasArg(true).build();
    Option repeats = Option.builder("R").longOpt("repeats").hasArg(true).build();
    Option method = Option.builder("M").longOpt("method").hasArg(true).build();
    Option header = Option.builder("H").longOpt("header").hasArg(true).build();
    Option concurrency = Option.builder("C").longOpt("concurrency").hasArg(true).build();
    Option templateFile = Option.builder("TF").longOpt("template").hasArg(true).build();
    Option dataFile = Option.builder("DF").longOpt("dataFile").hasArg(true).build();
    Option cookies = Option.builder("CO").longOpt("cookie").hasArg(true).build();
    Option data = Option.builder("D").longOpt("data").hasArg(true).type(String.class).build();

    OptionGroup optionGroup = new OptionGroup();
    optionGroup.setRequired(true);/*w  w  w  .ja  va  2  s .  com*/
    optionGroup.addOption(start);
    optionGroup.addOption(stop);
    optionGroup.addOption(pause);
    optionGroup.addOption(continueOpt);
    optionGroup.addOption(exit);
    Options options = new Options();
    options.addOptionGroup(optionGroup);
    options.addOption(url);
    options.addOption(durationMode);
    options.addOption(duration);
    options.addOption(repeats);
    options.addOption(method);
    options.addOption(header);
    options.addOption(concurrency);
    options.addOption(cookies);
    options.addOption(data);
    options.addOption(templateFile);
    options.addOption(dataFile);
    return options;
}