Example usage for org.apache.commons.cli2.builder ArgumentBuilder withMaximum

Introduction

In this page you can find the example usage for org.apache.commons.cli2.builder ArgumentBuilder withMaximum.

Prototype

public final ArgumentBuilder withMaximum(final int newMaximum) 

Source Link

Document

Sets the maximum number of values allowed for the argument to be valid.

Usage

From source file:egat.cli.AbstractGameCommandHandler.java

protected Option createFileOption() {
    DefaultOptionBuilder defaultOptionBuilder = new DefaultOptionBuilder();
    ArgumentBuilder argumentBuilder = new ArgumentBuilder();

    return fileOption = defaultOptionBuilder.withLongName("file").withShortName("f")
            .withDescription("game file")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("file").create()).create();
}

---

From source file:it.jnrpe.server.console.PluginCommand.java

private Option toOption(PluginOption po) {
    DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();

    oBuilder.withShortName(po.getOption()).withDescription(po.getDescription())
            .withRequired("true".equalsIgnoreCase(po.getRequired()));

    if (po.getLongOpt() != null) {
        oBuilder.withLongName(po.getLongOpt());
    }/*from  w  w  w .j  a v  a 2s . co  m*/

    if (po.hasArgs()) {
        ArgumentBuilder aBuilder = new ArgumentBuilder();

        if (po.getArgName() != null) {
            aBuilder.withName(po.getArgName());
        }

        if (po.getArgsOptional()) {
            aBuilder.withMinimum(0);
        }

        if (po.getArgsCount() != null) {
            aBuilder.withMaximum(po.getArgsCount());
        } else {
            aBuilder.withMaximum(1);
        }

        if (po.getValueSeparator() != null && po.getValueSeparator().length() != 0) {
            aBuilder.withInitialSeparator(po.getValueSeparator().charAt(0));
            aBuilder.withSubsequentSeparator(po.getValueSeparator().charAt(0));
        }
        oBuilder.withArgument(aBuilder.create());
    }

    return oBuilder.create();
}

---

From source file:it.jnrpe.plugins.PluginOption.java

/**
 * Convert this {@link PluginOption} to the Option required by Apache.
 * Commons Cli.//from   w w  w  .j a va 2 s. c  om
 *
        
 * @return The option object required by commons cli */
public Option toOption() {
    DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();

    oBuilder.withShortName(option).withDescription(description).withRequired(required);

    if (longOptionName != null) {
        oBuilder.withLongName(longOptionName);
    }

    if (hasArgs) {
        ArgumentBuilder aBuilder = new ArgumentBuilder();

        if (argName != null) {
            aBuilder.withName(argName);
        }

        if (argsAreOptional) {
            aBuilder.withMinimum(0);
        }

        if (argsCount != null) {
            aBuilder.withMaximum(argsCount);
        } else {
            aBuilder.withMaximum(1);
        }

        if (argsValueSeparator != null && argsValueSeparator.length() != 0) {
            aBuilder.withInitialSeparator(argsValueSeparator.charAt(0));
            aBuilder.withSubsequentSeparator(argsValueSeparator.charAt(0));
        }
        oBuilder.withArgument(aBuilder.create());
    }

    return oBuilder.create();
}

---

From source file:org.apache.mahout.classifier.sequencelearning.hmm.BaumWelchTrainer.java

public static void main(String[] args) throws IOException {
    DefaultOptionBuilder optionBuilder = new DefaultOptionBuilder();
    ArgumentBuilder argumentBuilder = new ArgumentBuilder();

    Option inputOption = DefaultOptionCreator.inputOption().create();

    Option outputOption = DefaultOptionCreator.outputOption().create();

    Option stateNumberOption = optionBuilder.withLongName("nrOfHiddenStates")
            .withDescription("Number of hidden states").withShortName("nh")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("number").create())
            .withRequired(true).create();

    Option observedStateNumberOption = optionBuilder.withLongName("nrOfObservedStates")
            .withDescription("Number of observed states").withShortName("no")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("number").create())
            .withRequired(true).create();

    Option epsilonOption = optionBuilder.withLongName("epsilon").withDescription("Convergence threshold")
            .withShortName("e")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("number").create())
            .withRequired(true).create();

    Option iterationsOption = optionBuilder.withLongName("max-iterations")
            .withDescription("Maximum iterations number").withShortName("m")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("number").create())
            .withRequired(true).create();

    Group optionGroup = new GroupBuilder().withOption(inputOption).withOption(outputOption)
            .withOption(stateNumberOption).withOption(observedStateNumberOption).withOption(epsilonOption)
            .withOption(iterationsOption).withName("Options").create();

    try {//from w ww .j  ava2 s  .  c o  m
        Parser parser = new Parser();
        parser.setGroup(optionGroup);
        CommandLine commandLine = parser.parse(args);

        String input = (String) commandLine.getValue(inputOption);
        String output = (String) commandLine.getValue(outputOption);

        int nrOfHiddenStates = Integer.parseInt((String) commandLine.getValue(stateNumberOption));
        int nrOfObservedStates = Integer.parseInt((String) commandLine.getValue(observedStateNumberOption));

        double epsilon = Double.parseDouble((String) commandLine.getValue(epsilonOption));
        int maxIterations = Integer.parseInt((String) commandLine.getValue(iterationsOption));

        //constructing random-generated HMM
        HmmModel model = new HmmModel(nrOfHiddenStates, nrOfObservedStates, new Date().getTime());
        List<Integer> observations = Lists.newArrayList();

        //reading observations
        Scanner scanner = new Scanner(new FileInputStream(input), "UTF-8");
        try {
            while (scanner.hasNextInt()) {
                observations.add(scanner.nextInt());
            }
        } finally {
            scanner.close();
        }

        int[] observationsArray = new int[observations.size()];
        for (int i = 0; i < observations.size(); ++i) {
            observationsArray[i] = observations.get(i);
        }

        //training
        HmmModel trainedModel = HmmTrainer.trainBaumWelch(model, observationsArray, epsilon, maxIterations,
                true);

        //serializing trained model
        DataOutputStream stream = new DataOutputStream(new FileOutputStream(output));
        try {
            LossyHmmSerializer.serialize(trainedModel, stream);
        } finally {
            Closeables.close(stream, false);
        }

        //printing tranied model
        System.out.println("Initial probabilities: ");
        for (int i = 0; i < trainedModel.getNrOfHiddenStates(); ++i) {
            System.out.print(i + " ");
        }
        System.out.println();
        for (int i = 0; i < trainedModel.getNrOfHiddenStates(); ++i) {
            System.out.print(trainedModel.getInitialProbabilities().get(i) + " ");
        }
        System.out.println();

        System.out.println("Transition matrix:");
        System.out.print("  ");
        for (int i = 0; i < trainedModel.getNrOfHiddenStates(); ++i) {
            System.out.print(i + " ");
        }
        System.out.println();
        for (int i = 0; i < trainedModel.getNrOfHiddenStates(); ++i) {
            System.out.print(i + " ");
            for (int j = 0; j < trainedModel.getNrOfHiddenStates(); ++j) {
                System.out.print(trainedModel.getTransitionMatrix().get(i, j) + " ");
            }
            System.out.println();
        }
        System.out.println("Emission matrix: ");
        System.out.print("  ");
        for (int i = 0; i < trainedModel.getNrOfOutputStates(); ++i) {
            System.out.print(i + " ");
        }
        System.out.println();
        for (int i = 0; i < trainedModel.getNrOfHiddenStates(); ++i) {
            System.out.print(i + " ");
            for (int j = 0; j < trainedModel.getNrOfOutputStates(); ++j) {
                System.out.print(trainedModel.getEmissionMatrix().get(i, j) + " ");
            }
            System.out.println();
        }
    } catch (OptionException e) {
        CommandLineUtil.printHelp(optionGroup);
    }
}

---

From source file:org.apache.mahout.classifier.sequencelearning.hmm.hadoop.BaumWelchDriver.java

@Override
public int run(String[] args) throws Exception {

    DefaultOptionBuilder optionBuilder = new DefaultOptionBuilder();
    ArgumentBuilder argumentBuilder = new ArgumentBuilder();

    Option inputOption = optionBuilder.withLongName("input")
            .withDescription("Sequence file containing VectorWritables as training sequence").withShortName("i")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("path").create())
            .withRequired(true).create();

    Option outputOption = optionBuilder.withLongName("output")
            .withDescription("Output path to store the trained model encoded as Sequence Files")
            .withShortName("o")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("path").create())
            .withRequired(true).create();

    Option modelOption = optionBuilder.withLongName("model")
            .withDescription("Initial HmmModel encoded as a Sequence File. "
                    + "Will be constructed with a random distribution if the 'buildRandom' option is set to true.")
            .withShortName("im")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("path").create())
            .withRequired(false).create();

    Option hiddenStateMapPath = optionBuilder.withLongName("hiddenStateToIDMap")
            .withDescription("Hidden states to ID map path.").withShortName("hmap")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("path").create())
            .withRequired(true).create();

    Option emitStateMapPath = optionBuilder.withLongName("emittedStateToIDMap")
            .withDescription("Emitted states to ID map path.").withShortName("smap")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("path").create())
            .withRequired(true).create();

    Option randomOption = optionBuilder.withLongName("buildRandom")
            .withDescription(//from   ww w.j  ava 2  s .c  om
                    "Optional argument to generate a random initial HmmModel and store it in 'model' directory")
            .withShortName("r")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("boolean").create())
            .withRequired(false).create();

    Option scalingOption = optionBuilder.withLongName("Scaling")
            .withDescription("Optional argument to invoke scaled training").withShortName("l")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("string").create())
            .withRequired(true).create();

    Option stateNumberOption = optionBuilder.withLongName("nrOfHiddenStates")
            .withDescription("Number of hidden states").withShortName("nh")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("number").create())
            .withRequired(true).create();

    Option observedStateNumberOption = optionBuilder.withLongName("nrOfObservedStates")
            .withDescription("Number of observed states").withShortName("no")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("number").create())
            .withRequired(true).create();

    Option epsilonOption = optionBuilder.withLongName("epsilon").withDescription("Convergence threshold")
            .withShortName("e")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("number").create())
            .withRequired(true).create();

    Option iterationsOption = optionBuilder.withLongName("maxIterations")
            .withDescription("Maximum iterations number").withShortName("m")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("number").create())
            .withRequired(true).create();

    Group optionGroup = new GroupBuilder().withOption(inputOption).withOption(outputOption)
            .withOption(modelOption).withOption(hiddenStateMapPath).withOption(emitStateMapPath)
            .withOption(randomOption).withOption(scalingOption).withOption(stateNumberOption)
            .withOption(observedStateNumberOption).withOption(epsilonOption).withOption(iterationsOption)
            .withName("Options").create();

    try {
        Parser parser = new Parser();
        parser.setGroup(optionGroup);
        CommandLine commandLine = parser.parse(args);

        String input = (String) commandLine.getValue(inputOption);
        String output = (String) commandLine.getValue(outputOption);
        String modelIn = (String) commandLine.getValue(modelOption);
        String hiddenStateToIdMap = (String) commandLine.getValue(hiddenStateMapPath);
        String emittedStateToIdMap = (String) commandLine.getValue(emitStateMapPath);

        Boolean buildRandom = commandLine.hasOption(randomOption);
        String scaling = (String) commandLine.getValue(scalingOption);

        int numHidden = Integer.parseInt((String) commandLine.getValue(stateNumberOption));
        int numObserved = Integer.parseInt((String) commandLine.getValue(observedStateNumberOption));

        double convergenceDelta = Double.parseDouble((String) commandLine.getValue(epsilonOption));
        int maxIterations = Integer.parseInt((String) commandLine.getValue(iterationsOption));

        if (getConf() == null) {
            setConf(new Configuration());
        }
        if (buildRandom) {

            BaumWelchUtils.buildRandomModel(numHidden, numObserved, new Path(modelIn), getConf());
        }
        run(getConf(), new Path(input), new Path(modelIn), new Path(output), new Path(hiddenStateToIdMap),
                new Path(emittedStateToIdMap), numHidden, numObserved, convergenceDelta, scaling,
                maxIterations);
    } catch (OptionException e) {
        CommandLineUtil.printHelp(optionGroup);
    }

    return 0;

}

---

From source file:org.apache.mahout.classifier.sequencelearning.hmm.RandomSequenceGenerator.java

public static void main(String[] args) throws IOException {
    DefaultOptionBuilder optionBuilder = new DefaultOptionBuilder();
    ArgumentBuilder argumentBuilder = new ArgumentBuilder();

    Option outputOption = optionBuilder.withLongName("output")
            .withDescription("Output file with sequence of observed states").withShortName("o")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("path").create())
            .withRequired(false).create();

    Option modelOption = optionBuilder.withLongName("model").withDescription("Path to serialized HMM model")
            .withShortName("m")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("path").create())
            .withRequired(true).create();

    Option lengthOption = optionBuilder.withLongName("length").withDescription("Length of generated sequence")
            .withShortName("l")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("number").create())
            .withRequired(true).create();

    Group optionGroup = new GroupBuilder().withOption(outputOption).withOption(modelOption)
            .withOption(lengthOption).withName("Options").create();

    try {/*from w ww.j  av  a2s  . c  o  m*/
        Parser parser = new Parser();
        parser.setGroup(optionGroup);
        CommandLine commandLine = parser.parse(args);

        String output = (String) commandLine.getValue(outputOption);

        String modelPath = (String) commandLine.getValue(modelOption);

        int length = Integer.parseInt((String) commandLine.getValue(lengthOption));

        //reading serialized HMM
        DataInputStream modelStream = new DataInputStream(new FileInputStream(modelPath));
        HmmModel model;
        try {
            model = LossyHmmSerializer.deserialize(modelStream);
        } finally {
            Closeables.close(modelStream, true);
        }

        //generating observations
        int[] observations = HmmEvaluator.predict(model, length, System.currentTimeMillis());

        //writing output
        PrintWriter writer = new PrintWriter(
                new OutputStreamWriter(new FileOutputStream(output), Charsets.UTF_8), true);
        try {
            for (int observation : observations) {
                writer.print(observation);
                writer.print(' ');
            }
        } finally {
            Closeables.close(writer, false);
        }
    } catch (OptionException e) {
        CommandLineUtil.printHelp(optionGroup);
    }
}

---

From source file:org.apache.mahout.classifier.sequencelearning.hmm.ViterbiEvaluator.java

public static void main(String[] args) throws IOException {
    DefaultOptionBuilder optionBuilder = new DefaultOptionBuilder();
    ArgumentBuilder argumentBuilder = new ArgumentBuilder();

    Option inputOption = DefaultOptionCreator.inputOption().create();

    Option outputOption = DefaultOptionCreator.outputOption().create();

    Option modelOption = optionBuilder.withLongName("model").withDescription("Path to serialized HMM model")
            .withShortName("m")
            .withArgument(argumentBuilder.withMaximum(1).withMinimum(1).withName("path").create())
            .withRequired(true).create();

    Option likelihoodOption = optionBuilder.withLongName("likelihood")
            .withDescription("Compute likelihood of observed sequence").withShortName("l").withRequired(false)
            .create();/* w  w w  .  jav  a 2s . c  o  m*/

    Group optionGroup = new GroupBuilder().withOption(inputOption).withOption(outputOption)
            .withOption(modelOption).withOption(likelihoodOption).withName("Options").create();

    try {
        Parser parser = new Parser();
        parser.setGroup(optionGroup);
        CommandLine commandLine = parser.parse(args);

        String input = (String) commandLine.getValue(inputOption);
        String output = (String) commandLine.getValue(outputOption);

        String modelPath = (String) commandLine.getValue(modelOption);

        boolean computeLikelihood = commandLine.hasOption(likelihoodOption);

        //reading serialized HMM
        DataInputStream modelStream = new DataInputStream(new FileInputStream(modelPath));
        HmmModel model;
        try {
            model = LossyHmmSerializer.deserialize(modelStream);
        } finally {
            Closeables.close(modelStream, true);
        }

        //reading observations
        List<Integer> observations = Lists.newArrayList();
        Scanner scanner = new Scanner(new FileInputStream(input), "UTF-8");
        try {
            while (scanner.hasNextInt()) {
                observations.add(scanner.nextInt());
            }
        } finally {
            scanner.close();
        }

        int[] observationsArray = new int[observations.size()];
        for (int i = 0; i < observations.size(); ++i) {
            observationsArray[i] = observations.get(i);
        }

        //decoding
        int[] hiddenStates = HmmEvaluator.decode(model, observationsArray, true);

        //writing output
        PrintWriter writer = new PrintWriter(
                new OutputStreamWriter(new FileOutputStream(output), Charsets.UTF_8), true);
        try {
            for (int hiddenState : hiddenStates) {
                writer.print(hiddenState);
                writer.print(' ');
            }
        } finally {
            Closeables.close(writer, false);
        }

        if (computeLikelihood) {
            System.out.println("Likelihood: " + HmmEvaluator.modelLikelihood(model, observationsArray, true));
        }
    } catch (OptionException e) {
        CommandLineUtil.printHelp(optionGroup);
    }
}

---