public void test13666() { Options options = new Options(); Option dir = OptionBuilder.withDescription("dir").hasArg().create('d'); options.addOption(dir); final PrintStream oldSystemOut = System.out; try { final ByteArrayOutputStream bytes = new ByteArrayOutputStream(); final PrintStream print = new PrintStream(bytes); // capture this platform's eol symbol print.println(); final String eol = bytes.toString(); bytes.reset(); System.setOut(new PrintStream(bytes)); try { HelpFormatter formatter = new HelpFormatter(); formatter.printHelp("dir", options); } catch (Exception exp) { fail("Unexpected Exception: " + exp.getMessage()); } assertEquals("usage: dir" + eol + " -d <arg> dir" + eol, bytes.toString()); } finally { System.setOut(oldSystemOut); } }
public static void main(String args[]) throws IOException, ParseException { Options options = new Options(); options.addOption("u", "uniquehits", false, "only output hits with a single mapping"); options.addOption( "s", "nosuboptimal", false, "do not include hits whose score is not equal to the best score for the read"); CommandLineParser parser = new GnuParser(); CommandLine cl = parser.parse(options, args, false); boolean uniqueOnly = cl.hasOption("uniquehits"); boolean filterSubOpt = cl.hasOption("nosuboptimal"); ArrayList<String[]> lines = new ArrayList<String[]>(); String line; String lastRead = ""; BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); while ((line = reader.readLine()) != null) { String pieces[] = line.split("\t"); if (!pieces[0].equals(lastRead)) { printLines(lines, uniqueOnly, filterSubOpt); lines.clear(); } lines.add(pieces); lastRead = pieces[0]; } printLines(lines, uniqueOnly, filterSubOpt); }
public void run(String[] args) throws ParseException, TransformationException, IOException, AnalysisException { Options options = new Options(); options.addOption("input", true, "input path"); options.addOption("output", true, "output path"); options.addOption("ext", true, "extension"); CommandLineParser parser = new DefaultParser(); CommandLine line = parser.parse(options, args); String inDir = line.getOptionValue("input"); String outDir = line.getOptionValue("output"); String extension = line.getOptionValue("ext"); File dir = new File(inDir); for (File f : FileUtils.listFiles(dir, new String[] {extension}, true)) { TrueVizToBxDocumentReader tvReader = new TrueVizToBxDocumentReader(); List<BxPage> pages = tvReader.read(new FileReader(f)); BxDocument doc = new BxDocument().setPages(pages); doc.setFilename(f.getName()); BxDocument rewritten = transform(doc); File f2 = new File(outDir + doc.getFilename()); BxDocumentToTrueVizWriter wrt = new BxDocumentToTrueVizWriter(); boolean created = f2.createNewFile(); if (!created) { throw new IOException("Cannot create file: "); } FileWriter fw = new FileWriter(f2); wrt.write(fw, Lists.newArrayList(rewritten)); fw.flush(); fw.close(); } }
public static Options constructGnuOptions() { final Options gnuOptions = new Options(); Option aminoDefaultConfigurationOption = new Option( "d", "amino_default_config_path", true, "The path where the amino default file lives."); aminoDefaultConfigurationOption.setRequired(true); gnuOptions.addOption(aminoDefaultConfigurationOption); gnuOptions.addOption("b", "base_dir", true, "The base directory of the running job"); gnuOptions.addOption( "c", "amino_config_file_path", true, "A CSV of filenames or paths which will be acted like a classpath setting up configurations!"); gnuOptions.addOption( "stop", "stop_on_first_phase", false, "Stop after the first phase of an AminoEnrichmentJob"); Option propertyOverride = new Option( "D", "property_override", true, "A map of key/value configuration properties to override (ie: 'key=value')"); propertyOverride.setValueSeparator('='); propertyOverride.setArgs(2); gnuOptions.addOption(propertyOverride); return gnuOptions; }
private static boolean setOptions(String[] lcommand) { Options loptions = new Options(); loptions.addOption(new Option("d", "debug", false, "print debug information (highly verbose)")); loptions.addOption(new Option("o", "stdout", false, "print output files to standard output")); loptions.addOption(new Option("w", "warning", false, "print warning messages")); CommandLineParser clparser = new PosixParser(); try { cmd = clparser.parse(loptions, lcommand); } catch (org.apache.commons.cli.ParseException e) { String mytoolcmd = "java -jar stave.jar"; String myoptlist = " <options> <source files>"; String myheader = "Convert JavaParser's AST to OpenJDK's AST"; String myfooter = "More info: https://github.com/pcgomes/javaparser2jctree"; HelpFormatter formatter = new HelpFormatter(); // formatter.printUsage( new PrintWriter(System.out,true), 100, "java -jar synctask.jar", // loptions ); // formatter.printHelp( mytoolcmd + myoptlist, myheader, loptions, myfooter, false); formatter.printHelp(mytoolcmd + myoptlist, loptions, false); return (false); } return (true); }
public void test11456() { // Posix Options options = new Options(); options.addOption(OptionBuilder.hasOptionalArg().create('a')); options.addOption(OptionBuilder.hasArg().create('b')); String[] args = new String[] {"-a", "-bvalue"}; CommandLineParser parser = new PosixParser(); try { CommandLine cmd = parser.parse(options, args); assertEquals(cmd.getOptionValue('b'), "value"); } catch (ParseException exp) { fail("Unexpected Exception: " + exp.getMessage()); } // GNU options = new Options(); options.addOption(OptionBuilder.hasOptionalArg().create('a')); options.addOption(OptionBuilder.hasArg().create('b')); args = new String[] {"-a", "-b", "value"}; parser = new GnuParser(); try { CommandLine cmd = parser.parse(options, args); assertEquals(cmd.getOptionValue('b'), "value"); } catch (ParseException exp) { fail("Unexpected Exception: " + exp.getMessage()); } }
/** Add the commandline options common to any command */ static { options.addOption("h", "help", false, "print this message"); options.addOption("p", "project", true, "project name"); options.addOption("a", "action", true, "action to run {create | remove}"); options.addOption("v", "verbose", false, "verbose messages"); options.addOption("G", "cygwin", false, "for create, indicate that the node is using cygwin"); // options.addOption("N", "nodeslist", true, "Path to arbitrary nodes.properties file"); }
private static Options createOptions() { Options options = new Options(); options.addOption("h", "help", false, "Prints this message"); options.addOption("w", "wmprt", true, "Path to WMPRT folder"); options.addOption("o", "output", true, "Output Folder for generated code"); options.addOption("n", "namespace", true, "The desired namespace for the generated code"); return options; }
// wrapper function to add an option private void addOptionWrapper(Option opt, boolean isStandard) { // for parsing command-line options options.addOption(opt); // for printing help messages getOptionList().add(opt); if (isStandard) { optionsStandard.addOption(opt); } else { optionsExperimental.addOption(opt); } }
public void test12210() { // create the main options object which will handle the first parameter Options mainOptions = new Options(); // There can be 2 main exclusive options: -exec|-rep // Therefore, place them in an option group String[] argv = new String[] {"-exec", "-exec_opt1", "-exec_opt2"}; OptionGroup grp = new OptionGroup(); grp.addOption(new Option("exec", false, "description for this option")); grp.addOption(new Option("rep", false, "description for this option")); mainOptions.addOptionGroup(grp); // for the exec option, there are 2 options... Options execOptions = new Options(); execOptions.addOption("exec_opt1", false, " desc"); execOptions.addOption("exec_opt2", false, " desc"); // similarly, for rep there are 2 options... Options repOptions = new Options(); repOptions.addOption("repopto", false, "desc"); repOptions.addOption("repoptt", false, "desc"); // create the parser GnuParser parser = new GnuParser(); // finally, parse the arguments: // first parse the main options to see what the user has specified // We set stopAtNonOption to true so it does not touch the remaining // options try { CommandLine cmd = parser.parse(mainOptions, argv, true); // get the remaining options... argv = cmd.getArgs(); if (cmd.hasOption("exec")) { cmd = parser.parse(execOptions, argv, false); // process the exec_op1 and exec_opt2... assertTrue(cmd.hasOption("exec_opt1")); assertTrue(cmd.hasOption("exec_opt2")); } else if (cmd.hasOption("rep")) { cmd = parser.parse(repOptions, argv, false); // process the rep_op1 and rep_opt2... } else { fail("exec option not found"); } } catch (ParseException exp) { fail("Unexpected exception: " + exp.getMessage()); } }
private static void parseArguments(String[] args) throws ParseException { Options options = new Options(); options.addOption("input", true, "The input file path"); options.addOption("output", true, "The output file path"); options.addOption("threads", true, "The number of threads"); CommandLine commandLine = new PosixParser().parse(options, args); inputFilePath = commandLine.getOptionValue("input", "price_moves.csv"); outputFilePath = commandLine.getOptionValue("output", "result.txt"); numberOfThreads = Integer.valueOf(commandLine.getOptionValue("threads", "1")); }
/** Method to create command line parser */ private void createCmdLineParser() { cmdOptions = new Options(); // add a accession option cmdOptions.addOption( ACCESSION_CMD, true, "a list of pride experiment accessions, separated by comma"); // add a user name option cmdOptions.addOption(USER_NAME_CMD, true, "pride user name"); // add a password option cmdOptions.addOption(PASSWORD_CMD, true, "pride password"); // create cmd line parser cmdParser = new GnuParser(); }
public void test15046() throws Exception { CommandLineParser parser = new PosixParser(); final String[] CLI_ARGS = new String[] {"-z", "c"}; Option option = new Option("z", "timezone", true, "affected option"); Options cliOptions = new Options(); cliOptions.addOption(option); parser.parse(cliOptions, CLI_ARGS); // now add conflicting option cliOptions.addOption("c", "conflict", true, "conflict option"); CommandLine line = parser.parse(cliOptions, CLI_ARGS); assertEquals(option.getValue(), "c"); assertTrue(!line.hasOption("c")); }
public static void main(String[] args) throws Exception { String propertyFile = null; // create the command line parser CommandLineParser parser = new PosixParser(); Options options = new Options(); options.addOption("f", "file", true, "The properties file"); options.addOption("v", "verbose", false, "Verbose logging output"); options.addOption("h", "help", false, "Help output"); try { CommandLine line = parser.parse(options, args); if (line.hasOption('v')) { org.apache.log4j.Logger.getRootLogger().setLevel(org.apache.log4j.Level.DEBUG); } if (line.hasOption('h')) { usage(options); } if (line.hasOption('f')) { propertyFile = line.getOptionValue('f'); } else { throw new Exception("Please supply -f"); } } catch (Exception e) { log.error("Invalid command line: " + e, e); usage(options); } Properties props = new Properties(); props.load(new FileReader(propertyFile)); startFromProperties(props); Runtime.getRuntime() .addShutdownHook( new Thread( new Runnable() { @Override public void run() { log.info("Received shutdown signal. Shutting down..."); server.stop(3); } })); }
public void test13425() { Options options = new Options(); Option oldpass = OptionBuilder.withLongOpt("old-password") .withDescription("Use this option to specify the old password") .hasArg() .create('o'); Option newpass = OptionBuilder.withLongOpt("new-password") .withDescription("Use this option to specify the new password") .hasArg() .create('n'); String[] args = {"-o", "-n", "newpassword"}; options.addOption(oldpass); options.addOption(newpass); Parser parser = new PosixParser(); try { CommandLine line = parser.parse(options, args); } // catch the exception and leave the method catch (Exception exp) { assertTrue(exp != null); return; } fail("MissingArgumentException not caught."); }
public static Options buildCommandLineOptions(final Options options) { Option opt = new Option("h", "help", false, "Print help"); opt.setRequired(false); options.addOption(opt); opt = new Option( "n", "namesrvAddr", true, "Name server address list, eg : 192.168.0.1:9876; 192.168.0.2:9876"); opt.setRequired(false); options.addOption(opt); return options; }
/* public static String optarg; //TODO import gnu.getopt.Getopt; in ginit() public static int optind; //TODO import gnu.getopt.Getopt; in ginit(); //TODO make long_options(struct) private static String[] long_options = { "verbose", "verbose:gc", "verbose:sugar", "verbose:code", "interactive", "typecheck", "start-with", "test", "test-with", "builtin-test", "NULL" }; */ static { longOptions = new Options(); longOptions.addOption(null, "verbose", false, null); longOptions.addOption(null, "verbose:gc", false, null); longOptions.addOption(null, "verbose:sugar", false, null); longOptions.addOption(null, "verbose:code", false, null); longOptions.addOption("i", "interactive", false, null); longOptions.addOption("c", "typecheck", false, null); longOptions.addOption("S", "start-with", true, null); longOptions.addOption("T", "test", true, null); longOptions.addOption("T", "test-with", true, null); longOptions.addOption("B", "builtin-test", true, null); }
public void addParameterInfo() { /* use Object parameter of Options class to store parameter information */ parameter.addOption( OptionBuilder.withArgName("input VCF file") .hasArg() .withDescription("Input vcf file containing variation info") .create(INPUT_VCF)); parameter.addOption( OptionBuilder.withArgName("input tabular file") .hasArg() .withDescription("Input tabular file containing variation info") .create(INPUT_TAB)); parameter.addOption( OptionBuilder.withArgName("output file") .hasArg() .withDescription("Output alleles p value") .create(OUTPUT_LINE)); parameter.addOption( OptionBuilder.withArgName("Columns for Alleles") .hasArg() .withDescription("columns where allele info is set") .create(COLUMN)); parameter.addOption( OptionBuilder.withArgName("Cache data") .hasArg(false) .withDescription("weather to cache data in memory or not, default no") .create(CACHE)); parameter.addOption( OptionBuilder.withArgName("re-partition num") .hasArg() .withDescription( "even the load of each task, 1 partition for a task or 4 partitions for a task is recommended. Default, not re-partition") .create(PARTITIONS)); parameter.addOption( OptionBuilder.hasArg(false).withDescription("show version information").create(VERSION)); parameter.addOption( OptionBuilder.hasArg(false) .withDescription("print and show this information") .create(HELP)); parameter.addOption(OptionBuilder.hasArg(false).withDescription("").create(HELP2)); }
private void parseArgs(final String[] args) throws ParseException { final Options options = new Options(); options.addOption("c", "claim", false, "Use Try/Claim"); options.addOption("", "pubChannel", true, "Primary publishing channel"); options.addOption("", "reflectChannel", true, "Reflection channel"); final CommandLineParser parser = new GnuParser(); final CommandLine command = parser.parse(options, args); if (command.hasOption("pubChannel")) { pubChannel = command.getOptionValue("pubChannel", "udp://localhost:44444"); } if (command.hasOption("reflectChannel")) { reflectChannel = command.getOptionValue("reflectChannel", "udp://localhost:55555"); } }
public void test15648() throws Exception { CommandLineParser parser = new PosixParser(); final String[] args = new String[] {"-m", "\"Two Words\""}; Option m = OptionBuilder.hasArgs().create("m"); Options options = new Options(); options.addOption(m); CommandLine line = parser.parse(options, args); assertEquals("Two Words", line.getOptionValue("m")); }
// TODO add exception for invalid options private void loadCLO(String[] args) { Options options = new Options(); String[][] clolist = { // {"variable/optionname", "description"}, {"genConfig", "general configuration file location"}, {"inWeightsLoc", "input weights configuration file location"}, {"inDBLoc", "input database file location"}, {"outWeightsLoc", "output weights configuration file location"}, {"outDBLoc", "output database file location"}, {"p3pLocation", "adding to DB: single policy file location"}, {"p3pDirLocation", "adding to DB: multiple policy directory location"}, {"newDB", "create new database in place of old one (doesn't check for existence of old one"}, {"newPolicyLoc", "the policy object to process"}, {"userResponse", "response to specified policy"}, {"userIO", "user interface"}, {"userInit", "initialization via user interface"}, {"policyDB", "PolicyDatabase backend"}, {"cbrV", "CBR to use"}, {"blanketAccept", "automatically accept the user suggestion"}, {"loglevel", "level of things save to the log- see java logging details"}, {"policyDB", "PolicyDatabase backend"}, {"NetworkRType", "Network Resource type"}, {"NetworkROptions", "Network Resource options"}, {"confidenceLevel", "Confidence threshold for consulting a networked resource"}, {"useNet", "use networking options"}, {"loglocation", "where to save the log file"}, {"loglevel", "the java logging level to use. See online documentation for enums."} }; for (String[] i : clolist) { options.addOption(i[0], true, i[1]); } CommandLineParser parser = new PosixParser(); CommandLine cmd = null; try { cmd = parser.parse(options, args); } catch (ParseException e) { System.err.println("Error parsing commandline arguments."); e.printStackTrace(); System.exit(3); } /* for(String i : args) { System.err.println(i); } */ for (String[] i : clolist) { if (cmd.hasOption(i[0])) { System.err.println("found option i: " + i); genProps.setProperty(i[0], cmd.getOptionValue(i[0])); } } System.err.println(genProps); }
static Options options() { Options options = new Options(); options.addOption(LIST, false, "List current monitors"); options.addOption(ALARMS, false, "Show alarms"); options.addOption(PERIOD, true, "Period to cover when showing alarms"); options.addOption(THRESHOLD, true, "Minimum duration when showing alarms"); options.addOption(DELETE, true, "Delete monitor by ID"); options.addOption(START, false, "Start monitors (use with 'wait' and 'timeout')"); options.addOption(WAIT, true, "Wait duration in milliseconds between each poll cycle"); options.addOption(TIMEOUT, true, "Timeout duration in milliseconds for a poll"); return options; }
protected CommandLine getCommand(String[] args) throws ParseException { Options options = new Options(); Option opt = new Option("maxMaps", true, "max number of maps to use for this copy"); opt.setRequired(true); options.addOption(opt); opt = new Option("sourcePaths", true, "comma separtated list of source paths to be copied"); opt.setRequired(true); options.addOption(opt); opt = new Option("targetPath", true, "target path"); opt.setRequired(true); options.addOption(opt); opt = new Option("falconFeedStorageType", true, "feed storage type"); opt.setRequired(true); options.addOption(opt); return new GnuParser().parse(options, args); }
public void test19383() { Options options = new Options(); options.addOption(new Option("a", "aaa", false, "aaaaaaa")); options.addOption(new Option(null, "bbb", false, "bbbbbbb")); options.addOption(new Option("c", null, false, "ccccccc")); HelpFormatter formatter = new HelpFormatter(); String SEP = System.getProperty("line.separator"); StringWriter out = new StringWriter(); formatter.printHelp(new PrintWriter(out), 80, "foobar", "", options, 2, 2, "", true); assertEquals( "usage: foobar [-a] [--bbb] [-c]" + SEP + " -a,--aaa aaaaaaa" + SEP + " --bbb bbbbbbb" + SEP + " -c ccccccc" + SEP, out.toString()); }
public void test11680() { Options options = new Options(); options.addOption("f", true, "foobar"); options.addOption("m", true, "missing"); String[] args = new String[] {"-f", "foo"}; CommandLineParser parser = new PosixParser(); try { CommandLine cmd = parser.parse(options, args); try { cmd.getOptionValue("f", "default f"); cmd.getOptionValue("m", "default m"); } catch (NullPointerException exp) { fail("NullPointer caught: " + exp.getMessage()); } } catch (ParseException exp) { fail("Unexpected Exception: " + exp.getMessage()); } }
public static void main(String[] args) { String formatstr = "ws [--in][--out][--dd][--sw][-h]"; Options opt = new Options(); // opt.addOption(OptionBuilder.withArgName("in").hasArg().withDescription("search for buildfile // towards the root of the filesystem and use it").create("O")); opt.addOption( OptionBuilder.withLongOpt("in") .withDescription("file path of those files need to be processed") .withValueSeparator('=') .hasArg() .create()); opt.addOption( OptionBuilder.withLongOpt("out") .withDescription("file path to store result") .withValueSeparator('=') .hasArg() .create()); opt.addOption( OptionBuilder.withLongOpt("dd") .withDescription("file path of dictionary") .withValueSeparator('=') .hasArg() .create()); opt.addOption( OptionBuilder.withLongOpt("sw") .withDescription("file path of stop words") .withValueSeparator('=') .hasArg() .create()); opt.addOption("h", "help", false, "print help for the command."); if (args.length == 0) { HelpFormatter hf = new HelpFormatter(); hf.printHelp(formatstr, "", opt, ""); return; } else { parse_args(args, formatstr, opt); } }
public void test14786() throws Exception { Option o = OptionBuilder.isRequired().withDescription("test").create("test"); Options opts = new Options(); opts.addOption(o); opts.addOption(o); CommandLineParser parser = new GnuParser(); String[] args = new String[] {"-test"}; CommandLine line = parser.parse(opts, args); assertTrue(line.hasOption("test")); }
private static Options buildOptions() { Options options = new Options(); Option tokenService = OptionBuilder.withArgName("service") .hasArg() .withDescription("set the name of calling service") .isRequired() .create("service"); options.addOption(tokenService); return options; }
public static void main(String[] args) { Options options = new Options(); options.addOption("v", true, "Input Vector folder"); // yearly vector data options.addOption("p", true, "Points folder"); // yearly mds (rotate) output options.addOption("d", true, "Destination folder"); options.addOption("o", true, "Original stock file"); // global 10 year stock file options.addOption( "s", true, "Sector file"); // If Histogram true then set this as the folder to histogram output options.addOption("h", false, "Gen from histogram"); options.addOption("e", true, "Extra classes file"); // a file containing fixed classes options.addOption("ci", true, "Cluster input file"); options.addOption("co", true, "Cluster output file"); CommandLineParser commandLineParser = new BasicParser(); try { CommandLine cmd = commandLineParser.parse(options, args); String vectorFile = cmd.getOptionValue("v"); String pointsFolder = cmd.getOptionValue("p"); String distFolder = cmd.getOptionValue("d"); String originalStocks = cmd.getOptionValue("o"); String sectorFile = cmd.getOptionValue("s"); boolean histogram = cmd.hasOption("h"); String fixedClasses = cmd.getOptionValue("e"); String clusterInputFile = cmd.getOptionValue("ci"); String clusterOutputFile = cmd.getOptionValue("co"); LabelApply program = new LabelApply( vectorFile, pointsFolder, distFolder, originalStocks, sectorFile, histogram, fixedClasses, clusterInputFile, clusterOutputFile); program.process(); } catch (ParseException e) { e.printStackTrace(); } }
public static void main(String[] args) throws TransformationException, IOException, AnalysisException, ParseException, CloneNotSupportedException { Options options = new Options(); options.addOption("input", true, "input path"); options.addOption("output", true, "output path"); CommandLineParser parser = new GnuParser(); CommandLine line = parser.parse(options, args); String inDir = line.getOptionValue("input"); String outDir = line.getOptionValue("output"); File dir = new File(inDir); for (File f : FileUtils.listFiles(dir, new String[] {"xml"}, true)) { TrueVizToBxDocumentReader tvReader = new TrueVizToBxDocumentReader(); List<BxPage> pages = tvReader.read(new FileReader(f)); BxDocument doc = new BxDocument().setPages(pages); doc.setFilename(f.getName()); int all = 0; int good = 0; for (BxZone z : doc.asZones()) { all++; if (!z.getLabel().equals(BxZoneLabel.OTH_UNKNOWN)) { good++; } } int intcov = 0; if (all > 0) { intcov = good * 100 / all; } System.out.println(doc.getFilename() + " " + intcov); File f2 = new File(outDir + doc.getFilename() + "." + intcov); FileUtils.copyFile(f, f2); } }