public static void main(String[] args) throws ParseException { Options options = new Options(); Option nameOption = new Option("n", true, "Name to resolve"); nameOption.setRequired(true); options.addOption(nameOption); CommandLineParser parser = new BasicParser(); CommandLine cmd = parser.parse(options, args); BasicConfigurator.configure(); Logger.getRootLogger().setLevel(Level.DEBUG); PodCIDRToNodeMapping plugin = new PodCIDRToNodeMapping(); Configuration conf = new Configuration(); plugin.setConf(conf); String nameToResolve = cmd.getOptionValue(nameOption.getOpt()); List<String> networkPathDirs = plugin.resolve(Lists.newArrayList(nameToResolve)); log.info("Resolved " + nameToResolve + " to " + networkPathDirs); }
public void parse() { CommandLineParser parser = new BasicParser(); CommandLine cmd = null; try { cmd = parser.parse(options, args, true); if (cmd.hasOption("h")) { help(); } else if (cmd.hasOption("o")) { open(); } else if (!cmd.hasOption("g")) { log.log(Level.SEVERE, "Missing g option"); help(); } } catch (ParseException e) { help(); } }
private static boolean parseArguments(String[] args) { CommandLineParser parser = new BasicParser(); try { CommandLine commandLine = parser.parse(OPTIONS, args); inputPath = commandLine.getOptionValue(INPUT_PATH.getOpt()); outputPath = new Path(commandLine.getOptionValue(OUTPUT_PATH.getOpt())); pattern = Pattern.compile(commandLine.getOptionValue(PATTERN.getOpt())); if (commandLine.hasOption(SAMPLE_FRACTION.getOpt())) { sampleFraction = Double.valueOf(commandLine.getOptionValue(SAMPLE_FRACTION.getOpt())); } if (sampleFraction < 0 || sampleFraction > 1) { return false; } return true; } catch (ParseException | IllegalArgumentException e) { return false; } }
public static void main(String[] args) throws Exception { Options options = createCommandLineOptions(); CommandLineParser parser = new BasicParser(); CommandLine cmdLine = null; try { cmdLine = parser.parse(options, args); } catch (ParseException e) { throw new KeywordOptimizerException("Error parsing command line parameters", e); } int port = Integer.parseInt(cmdLine.getOptionValue("port", DEFAULT_PORT + "")); String contextPath = cmdLine.getOptionValue("context-path", DEFAULT_CONTEXT_PATH); ApiServer server = new ApiServer(port, contextPath, cmdLine.getOptionValue("kp", ""), cmdLine.getOptionValue("ap", "")); server.start(); }
/** * Parses the arguments passed into the program. * * @param args * an array of String that contains all values passed into the * program * @throws ParseException * if there is an error parsing arguments */ private void parseArgs(String[] args) throws ParseException { final Options options = getCmdLineOptions(); final CommandLineParser parser = new BasicParser(); CommandLine cmd = null; /* * Parse the args according to the options definition. Will throw * MissingOptionException when a required option is not specified or the * more generic ParseException if there is any other error parsing the * arguments. */ cmd = parser.parse(options, args); if (cmd.hasOption("b")) { setBaselinePath(cmd.getOptionValue("b")); } }
public static void main(String [ ] args) throws Exception { CommandLineParser parser = new BasicParser(); Options options = getCommonRequiredOptions(); Option ingestFileOpt = OptionBuilder.withArgName(INGEST_FILE) .hasArg() .isRequired() .withDescription("ingest tsv file on hdfs") .create(INGEST_FILE); options.addOption(ingestFileOpt); CommandLine cmd = parser.parse( options, args); Map<String, String> dsConf = getAccumuloDataStoreConf(cmd); String featureName = cmd.getOptionValue(FEATURE_NAME); SimpleFeatureType featureType = buildGDELTFeatureType(featureName); DataStore ds = DataStoreFinder.getDataStore(dsConf); ds.createSchema(featureType); runMapReduceJob(featureName, dsConf, new Path(cmd.getOptionValue(INGEST_FILE))); }
/** * Parse the given command line arguments and return the parsed representation. * * @param args * @return * @throws ParseException */ public static CommandLine parse(String... args) throws ParseException { Options options = new Options(); Option help = new Option("help", "print this message"); options.addOption(help); Option resetAdminPassword = new Option(RESET_ADMIN_PASSWORD, true, "Reset the admin password"); options.addOption(resetAdminPassword); Option initCluster = new Option(INIT_CLUSTER, false, "Flag which can be used to initialise the first instance of a cluster."); options.addOption(initCluster); Option nodeName = new Option(NODE_NAME, true, "Node instance name"); options.addOption(nodeName); Option clusterName = new Option(CLUSTER_NAME, true, "Cluster name"); options.addOption(clusterName); Option httpPort = new Option(HTTP_PORT, true, "Server HTTP port"); options.addOption(httpPort); CommandLineParser parser = new BasicParser(); CommandLine cmd = parser.parse(options, args); return cmd; }
private void run() { try { logger.info("Running distributedlog server : args = {}", Arrays.toString(args)); BasicParser parser = new BasicParser(); CommandLine cmdline = parser.parse(options, args); runCmd(cmdline); } catch (ParseException pe) { logger.error("Argument error : {}", pe.getMessage()); printUsage(); Runtime.getRuntime().exit(-1); } catch (IllegalArgumentException iae) { logger.error("Argument error : {}", iae.getMessage()); printUsage(); Runtime.getRuntime().exit(-1); } catch (ConfigurationException ce) { logger.error("Configuration error : {}", ce.getMessage()); printUsage(); Runtime.getRuntime().exit(-1); } catch (IOException ie) { logger.error("Failed to start distributedlog server : ", ie); Runtime.getRuntime().exit(-1); } }
public static void main(String... args) throws Exception { Options options = new Options(); options.addOption("i", "input", true, "The file with training data."); options.addOption("o", "output", true, "Name of trained model file."); options.addOption("e", "epoch", true, "Number of times to go over whole training set."); CommandLine cmd = new BasicParser().parse(options, args); if (cmd.hasOption("i") && cmd.hasOption("o") && cmd.hasOption("e")) { train(cmd); log.info("Training finished."); } else { log.error("Invalid arguments."); new HelpFormatter().printHelp("Train", options); } }
protected static CommandLine parseCommandLine(final String[] args, final Options options, final String command) throws SyncDatabaseException, ParseException { if (args == null || options == null || command == null) { throw new SyncDatabaseException("error.argument"); } final CommandLineParser parser = new BasicParser(); final CommandLine commandLine = parser.parse(options, args); if (!command.equals("help") && (commandLine.getArgs().length != 1 || !command .equals(commandLine.getArgs()[0]))) { throw new SyncDatabaseException("error.option"); } return commandLine; }
private static void parseArguments(String[] args, Properties props) { // read command line arguments HelpFormatter helpFormater = new HelpFormatter(); helpFormater.setWidth(Integer.MAX_VALUE); CommandLineParser cmdParser = new BasicParser(); cmdOptions = new Options(); setupArgumentOptions(); // parse arguments try { cmd = cmdParser.parse(cmdOptions, args); if (cmd.hasOption('h')) { helpFormater.printHelp("OSM GPX MAP MATCHER", cmdOptions, true); System.exit(0); } assignArguments(props); } catch (ParseException parseException) { LOGGER.info(parseException.getMessage()); helpFormater.printHelp("OSM GPX MAP MATCHER", cmdOptions); System.exit(1); } }
private static void parseArguments(String[] args, Properties props) { // read command line arguments HelpFormatter helpFormater = new HelpFormatter(); helpFormater.setWidth(Integer.MAX_VALUE); CommandLineParser cmdParser = new BasicParser(); cmdOptions = new Options(); setupArgumentOptions(); // parse arguments try { cmd = cmdParser.parse(cmdOptions, args); if (cmd.hasOption('h')) { helpFormater.printHelp("OSM GPX INCLINE CALCULATOR", cmdOptions, true); System.exit(0); } assignArguments(props); } catch (ParseException parseException) { LOGGER.info(parseException.getMessage()); helpFormater.printHelp("OSM GPX INCLINE CALCULATOR", cmdOptions); System.exit(1); } }
private static void parseArguments(String[] args, Properties props) { // read command line arguments HelpFormatter helpFormater = new HelpFormatter(); helpFormater.setWidth(Integer.MAX_VALUE); CommandLineParser cmdParser = new BasicParser(); cmdOptions = new Options(); setupArgumentOptions(); // parse arguments try { cmd = cmdParser.parse(cmdOptions, args); if (cmd.hasOption('h')) { helpFormater.printHelp("OSM GPX Preprocessor", cmdOptions, true); System.exit(0); } assignArguments(props); } catch (ParseException parseException) { LOGGER.info(parseException.getMessage()); helpFormater.printHelp("OSM GPX MAP MATCHER", cmdOptions); System.exit(1); } }
private void ReadCmd(String[] args) throws ParseException { Options options = new Options(); // Add Possible Options options.addOption("I", "Input File", true, "The absolue file path of the input file."); options.addOption("O", "Output File", true, "The absolue file path of the output file."); CommandLineParser parser = new BasicParser(); CommandLine line = parser.parse(options, args); if (line.hasOption("I")) { inFile = line.getOptionValue("I"); } if (line.hasOption("O")) { outFile = line.getOptionValue("O"); } }
public void ReadCmd(String[] args) throws ParseException { Options options = new Options(); // Add Possible Options options.addOption("I", "Input Path", true, "The absolue path of the input file or directory."); options.addOption("O", "Output Path", true, "The absolue path of the output file or directory."); CommandLineParser parser = new BasicParser(); CommandLine line = parser.parse(options, args); if (line.hasOption("I")) { inPath = line.getOptionValue("I"); } if (line.hasOption("O")) { outPath = line.getOptionValue("O"); } }
public static void main(String[] args) throws Exception { System.setProperty("log4j.defaultInitOverride", "true"); LogManager.resetConfiguration(); ConsoleAppender ca = new ConsoleAppender(new PatternLayout("%-5p - %m%n")); ca.setName("edits"); LogManager.getRootLogger().addAppender(ca); Options ops = new Options(); ops.addOption("optimize", false, ""); ops.addOption("balance", false, ""); ops.addOption("rules", false, ""); ops.addOption("debug", false, ""); ops.addOption("wordnet", true, ""); CommandLine commandLine = new BasicParser().parse(ops, args); if (!commandLine.hasOption("debug")) ca.setThreshold(Level.INFO); RunExperiment res = new RunExperiment(commandLine.getArgs()[0], commandLine.hasOption("balance"), commandLine.hasOption("optimize"), commandLine.hasOption("rules")); if (commandLine.hasOption("wordnet")) res.setRulesSource(new WordnetRulesSource(commandLine.getOptionValue("wordnet"))); res.train(commandLine.getArgs()[1]); }
private static void parseArguments(String[] args) { // read command line arguments HelpFormatter helpFormater = new HelpFormatter(); helpFormater.setWidth(Integer.MAX_VALUE); CommandLineParser cmdParser = new BasicParser(); cmdOptions = new Options(); setupArgumentOptions(); // parse arguments try { cmd = cmdParser.parse(cmdOptions, args); if (cmd.hasOption('h')) { helpFormater.printHelp("GPX Filter", cmdOptions, true); System.exit(0); } assignArguments(cmd); } catch (ParseException parseException) { LOGGER.info(parseException.getMessage()); helpFormater.printHelp("GPX Filter", cmdOptions); System.exit(1); } }
public static CommandLine parse(String args[], Options options, String commandName) { CommandLineParser parser = new BasicParser(); CommandLine cl = null; try { /** * PARSE THE COMMAND LINE ARGUMENTS * */ cl = parser.parse(options, args); if (cl == null || cl.getOptions().length == 0 || cl.hasOption("help")) { HelpFormatter hf = new HelpFormatter(); hf.printHelp(commandName, options); return null; } } catch (Exception e) { logger.error("Error occured while parsing arguments!", e); return cl; } return cl; }
public static CommandLine parse(String args[], Options options, String commandName) { CommandLineParser parser = new BasicParser(); CommandLine cl = null; try { cl = parser.parse(options, args); if (cl == null || cl.getOptions().length == 0 || cl.hasOption("help")) { HelpFormatter hf = new HelpFormatter(); hf.printHelp(commandName, options); return null; } } catch (Exception e) { return cl; } return cl; }
public static CommandLine parse(String args[], Options options, String commandName) { CommandLineParser parser = new BasicParser(); CommandLine cl = null; try { /** * PARSE THE COMMAND LINE ARGUMENTS * */ cl = parser.parse(options, args); if (cl == null || cl.getOptions().length == 0 || cl.hasOption("help")) { HelpFormatter hf = new HelpFormatter(); hf.printHelp(commandName, options); return null; } } catch (Exception e) { LOG.error("Error occured while parsing arguments!", e); return cl; } return cl; }
public static ServerConfig parseArgs(String[] args) { Options options = CLIOptionsProcessor.process(ServerConfig.class); try { CommandLine cli = new BasicParser().parse(options, args); if (cli.hasOption('h'))//show help throw new Exception(); String strPort = cli.getOptionValue('p'); ServerConfig server = new ServerConfig(strPort == null ? Const.DEFAULT_SERVER_PORT : Integer.parseInt(strPort), new File(cli.getOptionValue('d')), cli.getOptionValue('k')); if (server.checkConfig()) return server; } catch (Exception e) { new HelpFormatter().printHelp("java -jar jfiler.jar S[erver] [OPTIONS]", options, false); System.exit(0); } return null; }
public static ClientConfig parseArgs(String[] args) { Options options = CLIOptionsProcessor.process(ClientConfig.class); try { CommandLine cli = new BasicParser().parse(options, args); if (cli.hasOption('h'))//show help throw new Exception(); String[] hostOption = cli.getOptionValues('H'); return new ClientConfig(hostOption[0], hostOption.length > 1 ? Integer.parseInt(hostOption[1]) : Const.DEFAULT_SERVER_PORT, cli.getOptionValue('k')); } catch (Exception e) { new HelpFormatter().printHelp("java -jar jfiler.jar C[lient] [OPTIONS]", options, false); System.exit(0); } return null; }
public static void main(String[] args) throws Exception { Options options = new Options(); options.addOption("o", true, "output file (default: target/classes/META-INF/mapping.xml)"); CommandLine cl = new BasicParser().parse(options, args); if (cl.hasOption("h") || args.length == 0) { new HelpFormatter().printHelp( "java " + MappingGeneratorTool.class.getName() + " [packages]", options); } else { String output = cl.getOptionValue("o", "target/classes/META-INF/mapping.xml"); FileOutputStream out = ConventionUtils.createFile(output); try { new MappingGeneratorTool(cl.getArgs()).generate(out); } finally { ConventionUtils.closeIfNotNull(out); } } }
private void run(String[] args) { Options options = this.createOptions(); String subCommand = null; if (args.length < 1) { this.printHelp(options); } CommandLineParser commandParser = new BasicParser(); CommandLine commandLine = null; try { String[] opts = new String[args.length - 1]; /* array shift */ System.arraycopy(args, 1, opts, 0, args.length - 1); commandLine = commandParser.parse(options, opts, false); } catch (ParseException e) { log.error(e.getMessage()); this.printHelp(options); } subCommand = args[0]; this.dispatchCommand(options, commandLine, subCommand); }
public static void main(String[] args) throws Exception { Options options = new Options(); options.addOption(ARG_COLLECTION, true, "File name of the POSTMAN collection."); options.addOption(ARG_ENVIRONMENT, true, "File name of the POSTMAN environment variables."); options.addOption(ARG_FOLDER, true, "(Optional) POSTMAN collection folder (group) to execute i.e. \"My Use Cases\""); options.addOption(ARG_HALTONERROR, false, "(Optional) Stop on first error in POSTMAN folder."); CommandLineParser parser = new BasicParser(); CommandLine cmd = parser.parse(options, args); String colFilename = cmd.getOptionValue(ARG_COLLECTION); String envFilename = cmd.getOptionValue(ARG_ENVIRONMENT); String folderName = cmd.getOptionValue(ARG_FOLDER); boolean haltOnError = cmd.hasOption(ARG_HALTONERROR); if (colFilename == null || colFilename.isEmpty() || envFilename == null || envFilename.isEmpty()) { // automatically generate the help statement HelpFormatter formatter = new HelpFormatter(); formatter.printHelp("postman-runner", options); return; } PostmanCollectionRunner pcr = new PostmanCollectionRunner(); pcr.runCollection(colFilename, envFilename, folderName, haltOnError); }
/** * Adds the possible arguments. Sets global args and executes the parsing of the given arguments. * * @param args * @throws ParseException * if there are any problems encountered while parsing the command line tokens. */ public CommandLineParser(String[] args) { options = new Options(); options.addOption("h", "help", false, "prints information about passing arguments."); options.addOption("c", "catalog", true, "determines location of catalog file"); options.getOption("c").setArgName("string"); options.addOption("g", "graph", false, "only the graph is drawed"); options.addOption("s", "start", true, "set commands to start with, separated by only comma"); options.getOption("s").setArgName("string"); options.addOption("e", "end", true, "set commands to end with, separated only by comma"); options.getOption("e").setArgName("string"); commandLineParser = new BasicParser(); commandLine = null; helpFormatter = new HelpFormatter(); this.args = args; parseArguments(); }
private static void run(String[] args) { Options options = createParameters(); try { CommandLine commandLine = new BasicParser().parse(options, args); if (commandLine.hasOption("version")) { showVersion(); } if (shouldManipulateContainer(commandLine)) { execute(commandLine); } if (!commandLine.hasOption("version") && !shouldManipulateContainer(commandLine)) { showUsage(options); } } catch (ParseException e) { logger.error(e.getMessage()); showUsage(options); } }
private static CommandLine parseArguments(final String[] args, final Options options, final HelpFormatter formatter) { final CommandLineParser parser = new BasicParser(); CommandLine cmd = null; try { cmd = parser.parse(options, args); } catch (final ParseException e) { LOG.error("Failed to parse command line options.", e); printHelp(options, formatter); System.exit(1); } return cmd; }
private static void defineOptions() { options.addOption("bh", "broker_host", true, "Druid broker node hostname/Ip"); options.addOption("bp", "broker_port", true, "Druid broker node port"); options.addOption("ch", "coordinator_host", true, "Druid coordinator node hostname/Ip"); options.addOption("cp", "coordinator_port", true, "Druid coordinator node port"); options.addOption("oh", "overlord_host", true, "Druid overlord node hostname/Ip"); options.addOption("op", "overlord_port", true, "Druid overlord node port"); options.addOption("mh", "mysql_host", true, "Druid MySql hostname/Ip"); options.addOption("mp", "mysql_port", true, "Druid MySql node port"); options.addOption("mid", "mysql_id", true, "Druid MySql user Id"); options.addOption("mpw", "mysql_passwd", true, "Druid MySql password"); options.addOption("mdb", "mysql_dbname", true, "Druid MySql db name"); options.addOption("pp", "proxy_port", true, "Druid proxy node port"); options.addOption("i", "history", true, "Number of commands in history"); options.addOption("hh", "http_headers", true, "Http Headers if any to pass"); parser = new BasicParser(); }
public void getConfigFile(String[] args) { Options opt = new Options(); Option op = new Option("config", true, "Full path to config file: /opt/cantilever/cantilever.config"); op.setRequired(true); opt.addOption(op); CommandLineParser parser = new BasicParser(); CommandLine cmd; try { cmd = parser.parse(opt, args); ConfigurationSingleton.instance.readConfigFile(cmd .getOptionValue("config")); } catch (ParseException pe) { usage(opt); } }
@Override protected ServerOptions parse(String[] args) throws ParseException { final CommandLine cmd = new BasicParser().parse(createOptions(), expandArgs(args)); validate(cmd); final int port = parsePort(cmd); final String target = cmd.getOptionValue('t'); final File mockDir = parseMockDir(cmd); final String ramlUri = cmd.getOptionValue('r'); final String baseUri = parseBaseUri(cmd.getOptionValue('b')); final boolean ignoreXheaders = cmd.hasOption('i'); final File saveDir = parseSaveDir(cmd.getOptionValue('s')); final ReportFormat fileFormat = parseReportFormat(cmd.getOptionValue('f')); final boolean asyncMode = cmd.hasOption('a'); final int[] delay = parseDelay(cmd.getOptionValue('d')); final ValidatorConfigurator validatorConfigurator = parseValidator(cmd.hasOption('v'), cmd.getOptionValue('v')); return new ServerOptions(port, target, mockDir, ramlUri, baseUri, saveDir, fileFormat, ignoreXheaders, asyncMode, delay[0], delay[1], validatorConfigurator); }
/** * Builds the configuration for udidb from the command line parameters * * @param args the command line arguments * * @return the configuration * * @throws ParseException if the configuration cannot be created due to invalid parameters * @throws HelpMessageRequested when the user requests the help message */ public Config build(String[] args) throws ParseException, HelpMessageRequested { CommandLineParser parser = new BasicParser(); CommandLine commandLine = parser.parse(options, args); if ( commandLine.hasOption(helpOption.getOpt()) ) { HelpFormatter formatter = new HelpFormatter(); formatter.printHelp("udidb", options, true); throw new HelpMessageRequested(); } // TODO convert options to config return new CommandLineConfigImpl(); }
/** * Called to validate the parameters. * * @param args * @throws ParseException */ private static void buildParametersFromArgs(String[] args) throws ParseException { CommandLineParser cliParser = new BasicParser(); Options options = buildOptions(); CommandLine cli = cliParser.parse(options, args); if (cli.getArgs().length < 1 || cli.hasOption('h')) { printUsage(options); } tableDirectory = new File(cli.getArgs()[0] + String.format("/%s/%s/", KEYSPACE_NAME, COLUMN_FAMILY_NAME)); tableDirectory.mkdirs(); numberOfStudents = Integer.parseInt(cli.getOptionValue('s', String.valueOf(DEFAULT_NUM_STUDENTS))); eventsPerStudent = Integer.parseInt(cli.getOptionValue('e', String.valueOf(DEFAULT_NUM_EVENTS_PER_STUDENT))); }
public static void main(String[] args) { try { parser = new BasicParser(); // create the command line parser options = new Options(); // create the Options addExperimentOptions(); cmd = parser.parse(options, args); if (cmd.hasOption("help")) { CLIUtils.printHelp(getHelpString(RegressionBenchmark.class.getName()), options); return; } verbose = cmd.hasOption("v"); debug = cmd.hasOption("d"); runExperiment(); System.out.println("End time: " + getCompletedTime()); } catch (Exception e) { e.printStackTrace(); } }
public static void run(String[] args) { try { parser = new BasicParser(); // create the command line parser options = new Options(); // create the Options addOptions(); cmd = parser.parse(options, args); if (cmd.hasOption("help")) { CLIUtils.printHelp(getHelpString(), options); return; } if (cmd.hasOption("cv-folder")) { runCrossValidation(); } else { runModel(); } } catch (Exception e) { e.printStackTrace(); throw new RuntimeException("Use option -help for all options."); } }
public static void run(String[] args) { try { parser = new BasicParser(); // create the command line parser options = new Options(); // create the Options addOptions(); cmd = parser.parse(options, args); if (cmd.hasOption("help")) { CLIUtils.printHelp(getHelpString(), options); return; } runModel(); } catch (Exception e) { e.printStackTrace(); throw new RuntimeException("Use option -help for all options."); } }
public void run(String[] args) throws I5Exception { CommandLineParser parser = new BasicParser(); CommandLine cmd; try { cmd = parser.parse(options, args); } catch (ParseException e) { throw new I5Exception(e); } String xmlFolder = cmd.getOptionValue("x"); String type = cmd.getOptionValue("t"); String dumpFilename = cmd.getOptionValue("w"); String outputFile = cmd.getOptionValue("o"); String encoding = cmd.getOptionValue("e"); String inflectives = cmd.getOptionValue("inf"); String index = cmd.getOptionValue("i"); convert(xmlFolder, type, dumpFilename, inflectives, encoding, outputFile, index); }
private static HotpGenArguments parseCommandLine(String[] args) { Options options = new Options(); options.addOption("k", "key", true, "the key (provide once - it is encrypted in properties file)"); options.addOption("p", "password", true, "optional password for stronger encryption in the properties file"); HotpGenArguments commandLineArgs = new HotpGenArguments(); try { CommandLine cmd = new BasicParser().parse(options, args); if (cmd.getArgs().length != 0) { throw new ParseException("Unrecognized argument: " + cmd.getArgs()[0]); } commandLineArgs.key = cmd.getOptionValue("k"); commandLineArgs.password = cmd.getOptionValue("p"); } catch (ParseException e) { System.out.println("Parsing command line failed - " + e.getMessage() ); new HelpFormatter().printHelp("hotpgen", options); } return commandLineArgs; }
public CLIParserImpl(Logger logger, ApplicationConfigurationSource applicationBeanSource, Validator validator, CLIValidator cliValidator, String commandName, BridgeCLIOptionProvider bridgeCLIOptionProvider, Collection<CLIOption> _options) { this.logger = logger; this.validator = validator; this.cliValidator = cliValidator; this.applicationConfigurationSource = applicationBeanSource; this.commandName = commandName; this.bridgeCLIOptionProvider = bridgeCLIOptionProvider; this.formatter = new HelpFormatter(); this.pw = new PrintWriter(System.out); this.parser = new BasicParser(); validateAndMerge(_options); }