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

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

Introduction

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

Prototype

public void setRequired(boolean required) 

Source Link

Usage

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

/**
 * Setup command line options/*from www  .  ja  v a2 s  .  co 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:net.kyllercg.acms.ACMgen.java

/**
 * Creates the valid command line options
 *//*from  w  ww  .ja v  a  2s  . co m*/
private void createOptions() {

    Option op_help = new Option("h", "help", false, ACMgen.msg.getMessage("help_desc"));

    Option op_rrbb = new Option("r", "rrbb", true, ACMgen.msg.getMessage("rrbb_desc"));
    op_rrbb.setArgs(1);
    op_rrbb.setArgName("size");
    Option op_owbb = new Option("o", "owbb", true, ACMgen.msg.getMessage("owbb_desc"));
    op_owbb.setArgs(1);
    op_owbb.setArgName("size");
    Option op_owrrbb = new Option("b", "owrrbb", true, ACMgen.msg.getMessage("owrrbb_desc"));
    op_owrrbb.setArgs(1);
    op_owrrbb.setArgName("size");

    Option op_cpp = new Option("C", "cpp", false, ACMgen.msg.getMessage("cpp_desc"));
    Option op_verilog = new Option("v", "verilog", false, ACMgen.msg.getMessage("verilog_desc"));
    Option op_pep = new Option("p", "pep", false, ACMgen.msg.getMessage("pep_desc"));
    Option op_petrify = new Option("P", "petrify", false, ACMgen.msg.getMessage("petrify_desc"));
    Option op_smv = new Option("s", "smv", false, ACMgen.msg.getMessage("smv_desc"));
    Option op_smv_pn = new Option("S", "smvpn", false, ACMgen.msg.getMessage("smvpn_desc"));

    OptionGroup op_acm_group = new OptionGroup();
    op_acm_group.setRequired(true);
    op_acm_group.addOption(op_help);
    op_acm_group.addOption(op_rrbb);
    op_acm_group.addOption(op_owbb);
    op_acm_group.addOption(op_owrrbb);

    this.options = new Options();
    this.options.addOptionGroup(op_acm_group);
    this.options.addOption(op_cpp);
    this.options.addOption(op_verilog);
    this.options.addOption(op_pep);
    this.options.addOption(op_petrify);
    this.options.addOption(op_smv);
    this.options.addOption(op_smv_pn);
}

From source file:de.bmw.yamaica.common.console.CommandExecuter.java

private OptionGroup createOptionGroup(IConfigurationElement optionGroupConfiguration,
        Map<String, IConfigurationElement> referenceableOptionConfigurations) {
    String required = optionGroupConfiguration.getAttribute(OPTION_GROUP_REQUIRED_ATTRIBUTE_NAME);

    OptionGroup optionGroup = new OptionGroup();
    optionGroup.setRequired(Boolean.parseBoolean(required));

    for (IConfigurationElement optionConfiguration : optionGroupConfiguration.getChildren()) {
        Option option = getOptionByConfiguration(optionConfiguration, referenceableOptionConfigurations);

        if (null != option) {
            optionGroup.addOption(option);
        }/* ww w.ja va 2 s .  c  o  m*/
    }

    return optionGroup;
}

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

/**
 * The only constructor of this class. It sets the toolString and the
 * versionString. In this constructor the two options -h and -v are created
 * and added. It also ensures that only -h or -v can be set.
 * //w w w  .j a  v a 2 s .c  o m
 * @param toolString
 *            the name of the tool
 * @param versionString
 *            the version information of the tool
 */
public OptionHandler(String toolString, String versionString) {
    options = new Options();
    optionList = new ArrayList<>();
    optionGroupList = new ArrayList<>();
    requiredOptions = new HashSet<>();
    requiredOptionGroups = new HashSet<>();
    helpFormatter = new HelpFormatter();
    parserType = ParserType.GNU;
    this.toolString = toolString;
    this.versionString = versionString;

    Option help = new Option("h", "help", false, "(optional): print this help message.");
    help.setRequired(false);
    addOption(help);

    Option version = new Option("v", "version", false, "(optional): print version information");
    version.setRequired(false);
    addOption(version);

    OptionGroup mainOptions = new OptionGroup();
    mainOptions.setRequired(false);
    mainOptions.addOption(help);
    mainOptions.addOption(version);

    options.addOptionGroup(mainOptions);
    argumentCount = 0;
    argumentName = "parameter";
    optionalArgument = false;
}

From source file:de.uni_koblenz.jgralab.utilities.rsa2tg.SchemaGraph2XMI.java

/**
 * Processes all command line parameters and returns a {@link CommandLine}
 * object, which holds all values included in the given {@link String}
 * array.//from   ww w  . ja v a 2  s  .c  om
 * 
 * @param args
 *            {@link CommandLine} parameters.
 * @return {@link CommandLine} object, which holds all necessary values.
 */
public static CommandLine processCommandLineOptions(String[] args) {

    // Creates a OptionHandler.
    String toolString = "java " + SchemaGraph2XMI.class.getName();
    String versionString = JGraLab.getInfo(false);

    OptionHandler oh = new OptionHandler(toolString, versionString);

    // Several Options are declared.
    Option output = new Option("o", "output", true, "(required): the output xmi file name");
    output.setRequired(true);
    output.setArgName("file");
    oh.addOption(output);

    Option schemaGraph = new Option("ig", "inputSchemaGraph", true,
            "(required or -i):if set, the schemaGraph is converted into a xmi.");
    schemaGraph.setRequired(false);
    schemaGraph.setArgs(0);
    output.setArgName("file");
    oh.addOption(schemaGraph);

    Option schema = new Option("i", "inputSchema", true,
            "(required or -ig): TG-file of the schema which should be converted into a xmi.");
    schema.setRequired(false);
    schema.setArgName("file");
    oh.addOption(schema);

    // either graph or schema has to be provided
    OptionGroup input = new OptionGroup();
    input.addOption(schemaGraph);
    input.addOption(schema);
    input.setRequired(true);
    oh.addOptionGroup(input);

    Option bidirectional = new Option("b", "bidirectional", false,
            "(optional): If set the EdgeClasses are created as bidirectional associations.");
    bidirectional.setRequired(false);
    oh.addOption(bidirectional);

    return oh.parse(args);
}

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

public void addOptionGroup(OptionGroup og) {
    if (og.isRequired()) {
        requiredOptionGroups.add(og);/*  w w  w .  j a  v a2s  .  co m*/
        og.setRequired(false);
    }
    optionGroupList.add(og);
    options.addOptionGroup(og);
}

From source file:gobblin.cli.JobCommand.java

private Options createCommandLineOptions() {
    Options options = new Options();

    OptionGroup actionGroup = new OptionGroup();
    actionGroup.addOption(new Option("h", HELP_OPT, false, "Shows the help message."));
    actionGroup.addOption(new Option("d", DETAILS_OPT, false, "Show details about a job/task."));
    actionGroup.addOption(new Option("l", LIST_OPT, false, "List jobs/tasks."));
    actionGroup.addOption(new Option("p", PROPS_OPT, false, "Fetch properties with the query."));
    actionGroup.setRequired(true);
    options.addOptionGroup(actionGroup);

    OptionGroup idGroup = new OptionGroup();
    idGroup.addOption(new Option("j", NAME_OPT, true, "Find job(s) matching given job name."));
    idGroup.addOption(new Option("i", ID_OPT, true, "Find the job/task with the given id."));
    options.addOptionGroup(idGroup);// ww w.  j  av  a2 s.  com

    options.addOption("n", true,
            "Limit the number of results returned. (default:" + DEFAULT_RESULTS_LIMIT + ")");
    options.addOption("r", RECENT_OPT, false, "List the most recent jobs (instead of a list of unique jobs)");

    return options;
}

From source file:com.github.braully.graph.BatchExecuteOperation.java

void processMain(String... args) {
    GraphCaratheodoryHeuristic.verbose = false;

    Options options = new Options();

    OptionGroup exec = new OptionGroup();
    exec.setRequired(false);
    IGraphOperation[] opers = getOperations();
    Option[] execs = new Option[opers.length];
    for (int i = 0; i < opers.length; i++) {
        IGraphOperation oper = opers[i];
        execs[i] = new Option("" + i, false, oper.getName());
        options.addOption(execs[i]);/*from   ww  w .  j  a  v  a 2  s .c o m*/
    }
    //        options.addOptionGroup(exec);

    Option input = new Option("i", "input", true, "input file or directory");
    options.addOption(input);

    Option cont = new Option("c", "continue", false, "continue from last processing");
    cont.setRequired(false);
    options.addOption(cont);

    Option verb = new Option("v", "verbose", false, "verbose processing");
    options.addOption(verb);

    Option output = new Option("o", "output", true, "output file");
    output.setRequired(false);
    options.addOption(output);

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

    //        input.setRequired(true);
    //        exec.setRequired(true);
    try {
        cmd = parser.parse(options, args);
    } catch (ParseException e) {
        System.out.println(e.getMessage());
        formatter.printHelp("BatchExecuteOperation", options);
        System.exit(1);
        return;
    }

    boolean contProcess = false;

    String inputFilePath = cmd.getOptionValue("input");
    if (inputFilePath == null) {
        inputFilePath = getDefaultInput();
    }
    if (inputFilePath == null) {
        return;
    }

    if (cmd.hasOption("continue")) {
        contProcess = true;
    }

    if (cmd.hasOption("verbose")) {
        verbose = true;
    }

    List<IGraphOperation> operationsToExecute = new ArrayList<IGraphOperation>();
    for (int i = 0; i < opers.length; i++) {
        IGraphOperation oper = opers[i];
        String value = execs[i].getOpt();
        if (cmd.hasOption(value)) {
            operationsToExecute.add(oper);
        }
    }

    if (operationsToExecute.isEmpty()) {
        operationsToExecute.add(opers[0]);
        //            formatter.printHelp("BatchExecuteOperation", options);
        //            System.exit(1);
        //            return;
    }
    File dir = new File(inputFilePath);
    if (dir.isDirectory()) {
        processDirectory(operationsToExecute, inputFilePath, contProcess);
    } else if (inputFilePath.toLowerCase().endsWith(".mat")) {
        try {
            for (IGraphOperation operation : operationsToExecute) {
                processFileMat(operation, dir);
            }
        } catch (Exception ex) {
            Logger.getLogger(BatchExecuteOperation.class.getName()).log(Level.SEVERE, null, ex);
        }
    } else if (inputFilePath.toLowerCase().endsWith(".g6")) {
        try {
            for (IGraphOperation operation : operationsToExecute) {
                processFileG6(operation, dir);
            }
        } catch (Exception ex) {
            Logger.getLogger(BatchExecuteOperation.class.getName()).log(Level.SEVERE, null, ex);
        }
    } else if (inputFilePath.toLowerCase().endsWith(".g6.gz")) {
        try {
            for (IGraphOperation operation : operationsToExecute) {
                processFileG6GZ(operation, dir);
            }
        } catch (Exception ex) {
            Logger.getLogger(BatchExecuteOperation.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

From source file:com.linkedin.helix.tools.ClusterSetup.java

@SuppressWarnings("static-access")
private static Options constructCommandLineOptions() {
    Option helpOption = OptionBuilder.withLongOpt(help).withDescription("Prints command-line options info")
            .create();/*w  w  w.  j a v  a 2  s.c om*/

    Option zkServerOption = OptionBuilder.withLongOpt(zkServerAddress)
            .withDescription("Provide zookeeper address").create();
    zkServerOption.setArgs(1);
    zkServerOption.setRequired(true);
    zkServerOption.setArgName("ZookeeperServerAddress(Required)");

    Option listClustersOption = OptionBuilder.withLongOpt(listClusters)
            .withDescription("List existing clusters").create();
    listClustersOption.setArgs(0);
    listClustersOption.setRequired(false);

    Option listResourceOption = OptionBuilder.withLongOpt(listResources)
            .withDescription("List resources hosted in a cluster").create();
    listResourceOption.setArgs(1);
    listResourceOption.setRequired(false);
    listResourceOption.setArgName("clusterName");

    Option listInstancesOption = OptionBuilder.withLongOpt(listInstances)
            .withDescription("List Instances in a cluster").create();
    listInstancesOption.setArgs(1);
    listInstancesOption.setRequired(false);
    listInstancesOption.setArgName("clusterName");

    Option addClusterOption = OptionBuilder.withLongOpt(addCluster).withDescription("Add a new cluster")
            .create();
    addClusterOption.setArgs(1);
    addClusterOption.setRequired(false);
    addClusterOption.setArgName("clusterName");

    Option activateClusterOption = OptionBuilder.withLongOpt(activateCluster)
            .withDescription("Enable/disable a cluster in distributed controller mode").create();
    activateClusterOption.setArgs(3);
    activateClusterOption.setRequired(false);
    activateClusterOption.setArgName("clusterName grandCluster true/false");

    Option deleteClusterOption = OptionBuilder.withLongOpt(dropCluster).withDescription("Delete a cluster")
            .create();
    deleteClusterOption.setArgs(1);
    deleteClusterOption.setRequired(false);
    deleteClusterOption.setArgName("clusterName");

    Option addInstanceOption = OptionBuilder.withLongOpt(addInstance)
            .withDescription("Add a new Instance to a cluster").create();
    addInstanceOption.setArgs(2);
    addInstanceOption.setRequired(false);
    addInstanceOption.setArgName("clusterName InstanceAddress(host:port)");

    Option addResourceOption = OptionBuilder.withLongOpt(addResource)
            .withDescription("Add a resource to a cluster").create();
    addResourceOption.setArgs(4);
    addResourceOption.setRequired(false);
    addResourceOption.setArgName("clusterName resourceName partitionNum stateModelRef <-mode modeValue>");

    Option expandResourceOption = OptionBuilder.withLongOpt(expandResource)
            .withDescription("Expand resource to additional nodes").create();
    expandResourceOption.setArgs(2);
    expandResourceOption.setRequired(false);
    expandResourceOption.setArgName("clusterName resourceName");

    Option expandClusterOption = OptionBuilder.withLongOpt(expandCluster)
            .withDescription("Expand a cluster and all the resources").create();
    expandClusterOption.setArgs(1);
    expandClusterOption.setRequired(false);
    expandClusterOption.setArgName("clusterName");

    Option resourceModeOption = OptionBuilder.withLongOpt(mode)
            .withDescription("Specify resource mode, used with addResourceGroup command").create();
    resourceModeOption.setArgs(1);
    resourceModeOption.setRequired(false);
    resourceModeOption.setArgName("IdealState mode");

    Option resourceBucketSizeOption = OptionBuilder.withLongOpt(bucketSize)
            .withDescription("Specify size of a bucket, used with addResourceGroup command").create();
    resourceBucketSizeOption.setArgs(1);
    resourceBucketSizeOption.setRequired(false);
    resourceBucketSizeOption.setArgName("Size of a bucket for a resource");

    Option resourceKeyOption = OptionBuilder.withLongOpt(resourceKeyPrefix)
            .withDescription("Specify resource key prefix, used with rebalance command").create();
    resourceKeyOption.setArgs(1);
    resourceKeyOption.setRequired(false);
    resourceKeyOption.setArgName("Resource key prefix");

    Option addStateModelDefOption = OptionBuilder.withLongOpt(addStateModelDef)
            .withDescription("Add a State model to a cluster").create();
    addStateModelDefOption.setArgs(2);
    addStateModelDefOption.setRequired(false);
    addStateModelDefOption.setArgName("clusterName <filename>");

    Option addIdealStateOption = OptionBuilder.withLongOpt(addIdealState)
            .withDescription("Add a State model to a cluster").create();
    addIdealStateOption.setArgs(3);
    addIdealStateOption.setRequired(false);
    addIdealStateOption.setArgName("clusterName resourceName <filename>");

    Option dropInstanceOption = OptionBuilder.withLongOpt(dropInstance)
            .withDescription("Drop an existing Instance from a cluster").create();
    dropInstanceOption.setArgs(2);
    dropInstanceOption.setRequired(false);
    dropInstanceOption.setArgName("clusterName InstanceAddress(host:port)");

    Option swapInstanceOption = OptionBuilder.withLongOpt(swapInstance)
            .withDescription("Swap an old instance from a cluster with a new instance").create();
    swapInstanceOption.setArgs(3);
    swapInstanceOption.setRequired(false);
    swapInstanceOption.setArgName("clusterName oldInstance newInstance");

    Option dropResourceOption = OptionBuilder.withLongOpt(dropResource)
            .withDescription("Drop an existing resource from a cluster").create();
    dropResourceOption.setArgs(2);
    dropResourceOption.setRequired(false);
    dropResourceOption.setArgName("clusterName resourceName");

    Option rebalanceOption = OptionBuilder.withLongOpt(rebalance)
            .withDescription("Rebalance a resource in a cluster").create();
    rebalanceOption.setArgs(3);
    rebalanceOption.setRequired(false);
    rebalanceOption.setArgName("clusterName resourceName replicas");

    Option instanceInfoOption = OptionBuilder.withLongOpt(listInstanceInfo)
            .withDescription("Query info of a Instance in a cluster").create();
    instanceInfoOption.setArgs(2);
    instanceInfoOption.setRequired(false);
    instanceInfoOption.setArgName("clusterName InstanceName");

    Option clusterInfoOption = OptionBuilder.withLongOpt(listClusterInfo)
            .withDescription("Query info of a cluster").create();
    clusterInfoOption.setArgs(1);
    clusterInfoOption.setRequired(false);
    clusterInfoOption.setArgName("clusterName");

    Option resourceInfoOption = OptionBuilder.withLongOpt(listResourceInfo)
            .withDescription("Query info of a resource").create();
    resourceInfoOption.setArgs(2);
    resourceInfoOption.setRequired(false);
    resourceInfoOption.setArgName("clusterName resourceName");

    Option addResourcePropertyOption = OptionBuilder.withLongOpt(addResourceProperty)
            .withDescription("Add a resource property").create();
    addResourcePropertyOption.setArgs(4);
    addResourcePropertyOption.setRequired(false);
    addResourcePropertyOption.setArgName("clusterName resourceName propertyName propertyValue");

    Option removeResourcePropertyOption = OptionBuilder.withLongOpt(removeResourceProperty)
            .withDescription("Remove a resource property").create();
    removeResourcePropertyOption.setArgs(3);
    removeResourcePropertyOption.setRequired(false);
    removeResourcePropertyOption.setArgName("clusterName resourceName propertyName");

    Option partitionInfoOption = OptionBuilder.withLongOpt(listPartitionInfo)
            .withDescription("Query info of a partition").create();
    partitionInfoOption.setArgs(3);
    partitionInfoOption.setRequired(false);
    partitionInfoOption.setArgName("clusterName resourceName partitionName");

    Option enableInstanceOption = OptionBuilder.withLongOpt(enableInstance)
            .withDescription("Enable/disable a Instance").create();
    enableInstanceOption.setArgs(3);
    enableInstanceOption.setRequired(false);
    enableInstanceOption.setArgName("clusterName InstanceName true/false");

    Option enablePartitionOption = OptionBuilder.hasArgs().withLongOpt(enablePartition)
            .withDescription("Enable/disable partitions").create();
    enablePartitionOption.setRequired(false);
    enablePartitionOption.setArgName("true/false clusterName instanceName resourceName partitionName1...");

    Option enableClusterOption = OptionBuilder.withLongOpt(enableCluster)
            .withDescription("pause/resume the controller of a cluster").create();
    enableClusterOption.setArgs(2);
    enableClusterOption.setRequired(false);
    enableClusterOption.setArgName("clusterName true/false");

    Option resetPartitionOption = OptionBuilder.withLongOpt(resetPartition)
            .withDescription("Reset a partition in error state").create();
    resetPartitionOption.setArgs(4);
    resetPartitionOption.setRequired(false);
    resetPartitionOption.setArgName("clusterName instanceName resourceName partitionName");

    Option resetInstanceOption = OptionBuilder.withLongOpt(resetInstance)
            .withDescription("Reset all partitions in error state for an instance").create();
    resetInstanceOption.setArgs(2);
    resetInstanceOption.setRequired(false);
    resetInstanceOption.setArgName("clusterName instanceName");

    Option resetResourceOption = OptionBuilder.withLongOpt(resetResource)
            .withDescription("Reset all partitions in error state for a resource").create();
    resetResourceOption.setArgs(2);
    resetResourceOption.setRequired(false);
    resetResourceOption.setArgName("clusterName resourceName");

    Option listStateModelsOption = OptionBuilder.withLongOpt(listStateModels)
            .withDescription("Query info of state models in a cluster").create();
    listStateModelsOption.setArgs(1);
    listStateModelsOption.setRequired(false);
    listStateModelsOption.setArgName("clusterName");

    Option listStateModelOption = OptionBuilder.withLongOpt(listStateModel)
            .withDescription("Query info of a state model in a cluster").create();
    listStateModelOption.setArgs(2);
    listStateModelOption.setRequired(false);
    listStateModelOption.setArgName("clusterName stateModelName");

    Option addStatOption = OptionBuilder.withLongOpt(addStat).withDescription("Add a persistent stat").create();
    addStatOption.setArgs(2);
    addStatOption.setRequired(false);
    addStatOption.setArgName("clusterName statName");
    Option addAlertOption = OptionBuilder.withLongOpt(addAlert).withDescription("Add an alert").create();
    addAlertOption.setArgs(2);
    addAlertOption.setRequired(false);
    addAlertOption.setArgName("clusterName alertName");

    Option dropStatOption = OptionBuilder.withLongOpt(dropStat).withDescription("Drop a persistent stat")
            .create();
    dropStatOption.setArgs(2);
    dropStatOption.setRequired(false);
    dropStatOption.setArgName("clusterName statName");
    Option dropAlertOption = OptionBuilder.withLongOpt(dropAlert).withDescription("Drop an alert").create();
    dropAlertOption.setArgs(2);
    dropAlertOption.setRequired(false);
    dropAlertOption.setArgName("clusterName alertName");

    // set/get configs option
    Option setConfOption = OptionBuilder.withLongOpt(setConfig).withDescription("Set a config").create();
    setConfOption.setArgs(2);
    setConfOption.setRequired(false);
    setConfOption
            .setArgName("ConfigScope(e.g. CLUSTER=cluster,RESOURCE=rc,...) KeyValueMap(e.g. k1=v1,k2=v2,...)");

    Option getConfOption = OptionBuilder.withLongOpt(getConfig).withDescription("Get a config").create();
    getConfOption.setArgs(2);
    getConfOption.setRequired(false);
    getConfOption.setArgName("ConfigScope(e.g. CLUSTER=cluster,RESOURCE=rc,...) KeySet(e.g. k1,k2,...)");

    OptionGroup group = new OptionGroup();
    group.setRequired(true);
    group.addOption(rebalanceOption);
    group.addOption(addResourceOption);
    group.addOption(resourceModeOption);
    group.addOption(resourceBucketSizeOption);
    group.addOption(expandResourceOption);
    group.addOption(expandClusterOption);
    group.addOption(resourceKeyOption);
    group.addOption(addClusterOption);
    group.addOption(activateClusterOption);
    group.addOption(deleteClusterOption);
    group.addOption(addInstanceOption);
    group.addOption(listInstancesOption);
    group.addOption(listResourceOption);
    group.addOption(listClustersOption);
    group.addOption(addIdealStateOption);
    group.addOption(rebalanceOption);
    group.addOption(dropInstanceOption);
    group.addOption(swapInstanceOption);
    group.addOption(dropResourceOption);
    group.addOption(instanceInfoOption);
    group.addOption(clusterInfoOption);
    group.addOption(resourceInfoOption);
    group.addOption(partitionInfoOption);
    group.addOption(enableInstanceOption);
    group.addOption(enablePartitionOption);
    group.addOption(enableClusterOption);
    group.addOption(resetPartitionOption);
    group.addOption(resetInstanceOption);
    group.addOption(resetResourceOption);
    group.addOption(addStateModelDefOption);
    group.addOption(listStateModelsOption);
    group.addOption(listStateModelOption);
    group.addOption(addStatOption);
    group.addOption(addAlertOption);
    group.addOption(dropStatOption);
    group.addOption(dropAlertOption);
    group.addOption(setConfOption);
    group.addOption(getConfOption);
    group.addOption(addResourcePropertyOption);
    group.addOption(removeResourcePropertyOption);

    Options options = new Options();
    options.addOption(helpOption);
    options.addOption(zkServerOption);
    options.addOptionGroup(group);
    return options;
}

From source file:edu.internet2.middleware.psp.PspOptions.java

/**
 * Construct the <code>Options</code>.
 *///from   ww w.j  a v a2  s .c  o m
private void initOptions() {

    options = new Options();

    OptionGroup requestOp = new OptionGroup();
    requestOp.setRequired(true);
    requestOp.addOption(Mode.calc.getOption());
    requestOp.addOption(Mode.diff.getOption());
    requestOp.addOption(Mode.sync.getOption());
    requestOp.addOption(Mode.bulkCalc.getOption());
    requestOp.addOption(Mode.bulkDiff.getOption());
    requestOp.addOption(Mode.bulkSync.getOption());
    options.addOptionGroup(requestOp);

    OptionGroup returnData = new OptionGroup();
    returnData.addOption(Opts.returnData.getOption());
    returnData.addOption(Opts.returnEverything.getOption());
    returnData.addOption(Opts.returnIdentifier.getOption());
    returnData.setRequired(false);
    options.addOptionGroup(returnData);

    options.addOption(Opts.conf.getOption());
    options.addOption(Opts.entityName.getOption());
    options.addOption(Opts.interval.getOption());
    options.addOption(Opts.iterations.getOption());
    options.addOption(Opts.logSpml.getOption());
    options.addOption(Opts.output.getOption());
    options.addOption(Opts.requestID.getOption());
    options.addOption(Opts.printRequests.getOption());
    options.addOption(Opts.targetID.getOption());
    options.addOption(Opts.omitDiffResponses.getOption());
    options.addOption(Opts.omitSyncResponses.getOption());
}