public static void main(String[] args) {
options = createOptions();
CommandLineParser parser = new GnuParser();
try {
CommandLine line = parser.parse(options, args);
String complexFile = line.getOptionValue("complex");
String pointsFile = line.getOptionValue("points");
String outputFile = null;
if (line.hasOption("destination")) {
outputFile = line.getOptionValue("destination");
} else {
outputFile = FileManager.generateUniqueFileName() + ".pov";
}
renderFromFiles(complexFile, pointsFile, outputFile);
} catch (ParseException exp) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp("plex-viewer", options);
} catch (IOException e) {
e.printStackTrace();
}
}
private void processCommandLine(String[] args) throws ParseException {
Option certificateFilenameOption;
Options commandLineOptions;
CommandLineParser clp;
CommandLine cl;
certificateFilenameOption = null;
commandLineOptions = null;
clp = null;
cl = null;
certificateFilenameOption =
new Option("f", "file", true, "file name containing certificate to be imported");
certificateFilenameOption.setRequired(true);
certificateFilenameOption.setArgs(1);
certificateFilenameOption.setOptionalArg(false);
certificateFilenameOption.setArgName("filename");
commandLineOptions = new Options();
commandLineOptions.addOption(certificateFilenameOption);
clp = new PosixParser();
try {
cl = clp.parse(commandLineOptions, args);
setCertificateFilename(IMPORT_AREA_DIRECTORY + "/" + cl.getOptionValue('f'));
} catch (ParseException pe) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp(APPLICATION_NAME, commandLineOptions, true);
throw pe;
}
}
public static final void main(String[] args) {
String accessKey = null;
String secretKey = null;
Options options = createCommandLineOption();
CommandLineParser parser = new GnuParser();
try {
// parse the command line arguments
CommandLine line = parser.parse(options, args);
if (!line.hasOption("ak")) {
throw new ParseException("AWS Accress Key is missing.");
}
if (!line.hasOption("sk")) {
throw new ParseException("AWS Secret Key is missing.");
}
accessKey = line.getOptionValue("ak");
secretKey = line.getOptionValue("sk");
} catch (ParseException exp) {
System.err.println("Parsing failed. Reason: " + exp.getMessage());
System.exit(1);
}
TargetURLGenerator generator = new TargetURLGenerator();
generator.setAccessKey(accessKey);
generator.setSecretKey(secretKey);
generator.run();
}
/**
* Parse extra arguments.
*
* @param args Extra arguments array
* @throws ParseException
*/
void parseExtraArgs(String[] args) throws ParseException {
// No-op when no extra arguments are present
if (args == null || args.length == 0) {
return;
}
// We do not need extended abilities of SqoopParser, so we're using
// Gnu parser instead.
CommandLineParser parser = new GnuParser();
CommandLine cmdLine = parser.parse(getExtraOptions(), args, true);
// Apply extra options
if (cmdLine.hasOption(SCHEMA)) {
String schemaName = cmdLine.getOptionValue(SCHEMA);
LOG.info("We will use schema " + schemaName);
this.schema = schemaName;
}
// Apply table hints
if (cmdLine.hasOption(TABLE_HINTS)) {
String hints = cmdLine.getOptionValue(TABLE_HINTS);
LOG.info("Sqoop will use following table hints for data transfer: " + hints);
this.tableHints = hints;
}
identityInserts = cmdLine.hasOption(IDENTITY_INSERT);
}
@Test
public void testDynamicProperties() throws IOException {
Map<String, String> map = new HashMap<String, String>(System.getenv());
File tmpFolder = tmp.newFolder();
File fakeConf = new File(tmpFolder, "flink-conf.yaml");
fakeConf.createNewFile();
map.put(ConfigConstants.ENV_FLINK_CONF_DIR, tmpFolder.getAbsolutePath());
TestBaseUtils.setEnv(map);
FlinkYarnSessionCli cli = new FlinkYarnSessionCli("", "", false);
Options options = new Options();
cli.addGeneralOptions(options);
cli.addRunOptions(options);
CommandLineParser parser = new DefaultParser();
CommandLine cmd = null;
try {
cmd =
parser.parse(
options,
new String[] {"run", "-j", "fake.jar", "-n", "15", "-D", "akka.ask.timeout=5 min"});
} catch (Exception e) {
e.printStackTrace();
Assert.fail("Parsing failed with " + e.getMessage());
}
AbstractYarnClusterDescriptor flinkYarnDescriptor = cli.createDescriptor(null, cmd);
Assert.assertNotNull(flinkYarnDescriptor);
Map<String, String> dynProperties =
FlinkYarnSessionCli.getDynamicProperties(flinkYarnDescriptor.getDynamicPropertiesEncoded());
Assert.assertEquals(1, dynProperties.size());
Assert.assertEquals("5 min", dynProperties.get("akka.ask.timeout"));
}
public static void main(String[] args) {
String propertyFile;
// create the command line parser
CommandLineParser parser = new PosixParser();
Options options = new Options();
options.addOption(
"f",
"file",
true,
"A property file containing values to override auto-detected field values (optional)");
CommandLine line;
Properties properties = new Properties();
try {
line = parser.parse(options, args);
if (line.hasOption('f')) {
propertyFile = line.getOptionValue('f');
properties.load(new FileReader(propertyFile));
}
} catch (Exception e) {
log.error(e.getMessage() + "\n Start aborted!");
System.exit(1);
}
WSNGui gui = new WSNGui(properties);
gui.frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
gui.frame.setVisible(true);
}
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 parseCli(String[] argv) {
Options opts = new Options();
opts.addOption("m", "mib", true, "Pathname or URL of MIB file to scan for traps");
opts.addOption("b", "ueibase", true, "Base UEI for resulting events");
opts.addOption(
"c",
"compat",
false,
"Turn on compatibility mode to create output as similar to mib2opennms as possible");
CommandLineParser parser = new GnuParser();
try {
CommandLine cmd = parser.parse(opts, argv);
if (cmd.hasOption('m')) {
m_mibLocation = cmd.getOptionValue('m');
} else {
printHelp("You must specify a MIB file pathname or URL");
System.exit(1);
}
if (cmd.hasOption("b")) {
m_ueiBase = cmd.getOptionValue('b');
}
if (cmd.hasOption("c")) {
m_compat = true;
}
} catch (ParseException e) {
printHelp("Failed to parse command line options");
System.exit(1);
}
}
public static void main(String args[]) {
File f = new File("resources/archive_hub_dump.nt");
String name = f.getName();
CommandLineParser parser = new BasicParser();
CommandLine cmd;
try {
cmd = parser.parse(getCLIOptions(), args);
if (cmd.hasOption("file")) {
f = new File(cmd.getOptionValue("file"));
if (!f.exists()) {
System.err.println("File/Directory to compress not found.");
System.exit(0);
}
}
if (cmd.hasOption("name")) {
name = cmd.getOptionValue("name");
}
} catch (ParseException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
HDTEvaluation hdtEval = new HDTEvaluation(name, f);
try {
hdtEval.run();
} catch (IOException e) {
e.printStackTrace();
} catch (ParserException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws ConfigurationException, ParseException {
Configuration config = new PropertiesConfiguration("application.properties");
// Options
Options options = setUpOptions();
CommandLineParser parser = new DefaultParser();
CommandLine cmd = parser.parse(options, args);
// TODO Anatoli: it makes sense to add strict validation
for (Option option : cmd.getOptions()) {
if (StringUtils.isNotBlank(option.getValue())) {
config.addProperty(option.getLongOpt(), option.getValue());
}
}
if (cmd.hasOption('h')) {
HelpFormatter formatter = new HelpFormatter();
formatter.setWidth(120);
formatter.printHelp(
"java -Dlogback.configurationFile=logback.xml -jar whatIsOilPriceNow.jar [options]",
options);
return;
}
RockNRoller roller = new RockNRoller(config);
roller.startMainLoop();
}
/**
* Cirrus main entry point.
*
* @param args the command line arguments.
*/
public static void main(final String[] args) {
if (args.length < 1) {
LOG.error(MessageCatalog.WRONG_ARGS_SIZE);
System.exit(1);
}
final Command command = COMMAND_REGISTRY.get(args[0]);
if (command == null) {
LOG.error(MessageCatalog._00001__UNKNOWN_COMMAND, args[0]);
System.exit(1);
}
final CommandLineParser parser = new BasicParser();
try {
final CommandLine commandLine = parser.parse(command.getOptions(), args);
command.execute(commandLine);
} catch (final MissingOptionException exception) {
command._log.error(MessageCatalog._00028_CL_PARSER_FAILURE, exception.getMessage());
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp("cirrus <command> <options>", command.getOptions());
System.exit(1);
} catch (final ParseException exception) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp("cirrus <command> <options>", command.getOptions());
System.exit(1);
}
}
public static void main(String args[]) throws Exception {
Util util = new Util();
String observationLimit;
String dataFile;
String processSummaryStatics;
CommandLineParser parser = new BasicParser();
try {
CommandLine cmd = parser.parse(util.getOptions(), args);
dataFile = cmd.getOptionValue("f");
processSummaryStatics = cmd.getOptionValue("s");
observationLimit = cmd.getOptionValue("l");
} catch (Exception e) {
e.printStackTrace();
return;
}
if (StringUtils.isEmpty(dataFile)) {
util.help();
}
// Default Values;
Boolean summaryStats = true;
Long obsLimit = -1l;
Util.fileCheck(dataFile);
summaryStats = Util.processSummaryStatisticsCheck(processSummaryStatics);
;
obsLimit = Util.observationLimitCheck(observationLimit);
;
GenerateDDI generateDDI = new GenerateDDI();
generateDDI.generateDDI(dataFile, summaryStats, obsLimit);
System.out.println("Finished. Exiting.");
}
@Test
public void testParseConf() throws Exception {
String[] args =
new String[] {
"--conf",
"tajo.cli.print.pause=false",
"--conf",
"tajo.executor.join.inner.in-memory-table-num=256"
};
CommandLineParser parser = new PosixParser();
CommandLine cmd = parser.parse(TajoCli.options, args);
String[] confValues = cmd.getOptionValues("conf");
assertNotNull(confValues);
assertEquals(2, confValues.length);
assertEquals("tajo.cli.print.pause=false", confValues[0]);
assertEquals("tajo.executor.join.inner.in-memory-table-num=256", confValues[1]);
TajoConf tajoConf = TpchTestBase.getInstance().getTestingCluster().getConfiguration();
TajoCli testCli = new TajoCli(tajoConf, args, System.in, System.out);
try {
assertEquals("false", testCli.getContext().get(SessionVars.CLI_PAGING_ENABLED));
assertEquals(
"256",
testCli.getContext().getConf().get("tajo.executor.join.inner.in-memory-table-num"));
} finally {
testCli.close();
}
}
@SuppressWarnings("deprecation")
public static void main(String[] args) throws ParseException {
// TODO Auto-generated method stub
// Create a Parser
String sourceImage = null;
String subImage = null;
CommandLine commandLine = null;
CommandLineParser parser = new BasicParser();
Options options = new Options();
options.addOption("h", "help", false, "help message");
options.addOption("s", "source", true, "source image");
options.addOption("t", "template", true, "sub image");
// Parse the program arguments
try {
commandLine = parser.parse(options, args);
} catch (Exception e) {
// TODO: handle exception
printUsage();
}
// Set the appropriate variables based on supplied options
if (commandLine.hasOption('h')) {
printUsage();
System.exit(0);
}
if (commandLine.hasOption('s')) {
sourceImage = commandLine.getOptionValue('s');
}
if (commandLine.hasOption('t')) {
subImage = commandLine.getOptionValue('t');
}
verifyImage(sourceImage, subImage);
}
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);
}
/**
* The main CLI processor
*
* @param args command line argument
*/
public static void main(String[] args) {
checkJavaVersion();
String logConfig = System.getProperty("log4j.configuration");
if (logConfig != null && logConfig.length() > 0) {
File lc = new File(logConfig);
if (lc.exists()) {
PropertyConfigurator.configure(logConfig);
Properties defaults = loadDefaults();
try {
Options o = getOptions();
CommandLineParser parser = new GnuParser();
CommandLine cmdline = parser.parse(o, args);
GdcNotification gdi = new GdcNotification(cmdline, defaults);
if (!gdi.finishedSucessfuly) {
System.exit(1);
}
} catch (org.apache.commons.cli.ParseException e) {
l.error("Error parsing command line parameters: " + e.getMessage());
l.debug("Error parsing command line parameters", e);
}
} else {
l.error(
"Can't find the logging config. Please configure the logging via the log4j.configuration.");
}
} else {
l.error(
"Can't find the logging config. Please configure the logging via the log4j.configuration.");
}
}
public static void main(String[] args) throws Exception {
Options options = new Options();
// Add the option -kms or --kms_ws_uri followed by an argument
// example: -kms "ws://192.168.1.119:8888/kurento"
options.addOption(
Option.builder("kms")
.longOpt("kms_ws_uri")
.hasArg()
.desc("Changes the default kurento media server ip")
.argName("kms")
.build());
CommandLineParser parser = new DefaultParser();
// Parse the command line for defined arguments
CommandLine line = parser.parse(options, args);
// Set the kurento media server uri to either the parsed argument or just localhost
KMS_WS_URI =
line.getOptionValue("kms") != null
? line.getOptionValue("kms")
: "ws://localhost:8888/kurento";
// Create the application
new SpringApplication(CinderApp.class).run(args);
}
@SuppressWarnings("static-access")
private CommandLine parseArgs(String[] args) throws Exception {
options = new Options();
options.addOption(
OptionBuilder.withDescription("path to output of pwsim algorithm")
.withArgName("path")
.hasArg()
.isRequired()
.create(PWSIM_OPTION));
options.addOption(
OptionBuilder.withDescription("path to output")
.withArgName("path")
.hasArg()
.isRequired()
.create(OUTPUT_PATH_OPTION));
options.addOption(
OptionBuilder.withDescription("source-side raw collection path")
.withArgName("path")
.hasArg()
.isRequired()
.create(FCOLLECTION_OPTION));
options.addOption(
OptionBuilder.withDescription("target-side raw collection path")
.withArgName("path")
.hasArg()
.isRequired()
.create(ECOLLECTION_OPTION));
options.addOption(
OptionBuilder.withDescription("two-letter code for f-language")
.withArgName("en|de|tr|cs|zh|ar|es")
.hasArg()
.isRequired()
.create(FLANG_OPTION));
options.addOption(
OptionBuilder.withDescription("two-letter code for e-language")
.withArgName("en|de|tr|cs|zh|ar|es")
.hasArg()
.isRequired()
.create(ELANG_OPTION));
options.addOption(
OptionBuilder.withDescription("only keep pairs that match these docnos")
.withArgName("path to sample docnos file")
.hasArg()
.create(SAMPLEDOCNOS_OPTION));
options.addOption(
OptionBuilder.withDescription("Hadoop option to load external jars")
.withArgName("jar packages")
.hasArg()
.create(LIBJARS_OPTION));
CommandLine cmdline;
CommandLineParser parser = new GnuParser();
try {
cmdline = parser.parse(options, args);
} catch (ParseException exp) {
System.err.println("Error parsing command line: " + exp.getMessage());
return null;
}
return cmdline;
}
public static void main(String[] rawArgs)
throws FileNotFoundException, UnsupportedEncodingException {
CommandLineParser parser = new BasicParser();
Options options = new Options();
options.addOption("p", "parser", true, "Which parser to use. (stanford | malt)");
CommandLine line = null;
try {
line = parser.parse(options, rawArgs);
} catch (ParseException exp) {
System.err.println(exp.getMessage());
System.exit(1);
}
String[] args = line.getArgs();
String parserName = line.getOptionValue("parser", "stanford");
System.out.println("Using " + parserName + " parser");
File evaluationFile = new File(args[0]);
File outputFile = new File(args[1]);
BenchmarkBinary evaluation = new BenchmarkBinary(evaluationFile, outputFile, parserName);
// read evaluation file with sentences annotated with golden statements
// and run Exemplar over them.
evaluation.runAndTime();
}
public static Options parseArgs(String cmdArgs[]) {
CommandLineParser parser = new GnuParser();
CmdLineOptions options = getCmdLineOptions();
try {
CommandLine cmd = parser.parse(options, cmdArgs, false);
if (cmd.hasOption(HELP_OPTION)) {
printUsage(options);
System.exit(0);
}
String[] args = cmd.getArgs();
if (args.length == 0) {
System.err.println("No sstables to split");
printUsage(options);
System.exit(1);
}
Options opts = new Options(Arrays.asList(args));
opts.debug = cmd.hasOption(DEBUG_OPTION);
opts.verbose = cmd.hasOption(VERBOSE_OPTION);
opts.snapshot = !cmd.hasOption(NO_SNAPSHOT_OPTION);
opts.sizeInMB = DEFAULT_SSTABLE_SIZE;
if (cmd.hasOption(SIZE_OPTION))
opts.sizeInMB = Integer.valueOf(cmd.getOptionValue(SIZE_OPTION));
return opts;
} catch (ParseException e) {
errorMsg(e.getMessage(), options);
return null;
}
}
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 boolean parseArgs(String[] args) {
CommandLineParser parser = new BasicParser();
CommandLine cmd;
try {
cmd = parser.parse(options, args);
if (cmd.hasOption("tbn") && cmd.hasOption("tbp")) {
tbUsername = cmd.getOptionValue("tbn");
tbPassword = cmd.getOptionValue("tbp");
} else {
System.out.println("Please enter your Topbot username and password");
return false;
}
if (cmd.hasOption("n")) {
numAccounts = Integer.parseInt(cmd.getOptionValue("n"));
if (numAccounts >= 9)
System.out.println("WARNING: The number of accounts exceeds the number of f2p worlds!");
} else numAccounts = DEFAULT_ACCOUNT_NUM;
if (cmd.hasOption("bp")) botPassword = cmd.getOptionValue("bp");
else botPassword = DEFAULT_PW;
if (cmd.hasOption("s")) script = cmd.getOptionValue("s");
else script = DEFAULT_SCRIPT;
return true;
} catch (Exception e) {
System.out.println("Couldn't parse arguments");
return false;
}
}
public static int perform(String... args) throws Exception {
Options options = new Options();
options.addOption("a", "artifacts", true, "Artifacts");
options.addOption("x", "exitcode", false, "Status in exit code");
CommandLineParser parser = new DefaultParser();
final CommandLine cmd = parser.parse(options, args);
List<Path> testFolders =
new ArrayList<Path>() {
{
for (String arg : cmd.getArgs()) add(Paths.get(arg));
}
};
String artifacts = cmd.getOptionValue("a", "https://vefa.difi.no/validator/repo/");
List<Validation> validations;
if (artifacts.startsWith("http"))
validations = Tester.perform(URI.create(artifacts), testFolders);
else validations = Tester.perform(Paths.get(artifacts), testFolders);
int result = 0;
if (cmd.hasOption("x"))
for (Validation validation : validations)
if (validation.getReport().getFlag().compareTo(FlagType.EXPECTED) > 0)
result = Math.max(result, validation.getReport().getFlag().compareTo(FlagType.EXPECTED));
return result;
}
/**
* Parse arguments
*
* @param args
*/
private void commandLineParser(String[] args) throws ParseException {
options = new Options();
options.addOption("help", false, "print this message");
options.addOption(
OPTION_CARBON_PORT,
true,
"specify port for graphite/carbon events - (" + DEFAULT_PORT_CARBON + " by default)");
options.addOption(
OPTION_STATSD_PORT,
true,
"specify port for statsD events - (" + DEFAULT_PORT_STATSD + " by default)");
options.addOption(
OPTION_WEBSERVER_PORT,
true,
"specify port for http server - (" + DEFAULT_PORT_WEBSERVER + " by default)");
options.addOption(
OPTION_CARBON_ONLY, false, "start TCP socket only for graphite/carbon events");
options.addOption(OPTION_STATSD_ONLY, false, "start UDP socket only for statsd events");
options.addOption(OPTION_NO_WEBSERVER, false, "don't start webserver");
options.addOption(OPTION_HAWTIO, false, "start hawtio in webserver");
options.addOption(OPTION_BACKEND, true, "backend implementation available : " + getBackends());
options.addOption(OPTION_WEBSERVER_WEBROOT, true, "HTTP base resource (must be a path)");
CommandLineParser parser = new PosixParser();
cmd = parser.parse(options, args);
if (cmd.hasOption("help")) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp("java -jar bigloupe-chart.jar [options]", options);
System.exit(0);
}
}
public void init(String[] args) throws UserError {
Context.reset();
CommandLineParser globalParser = new GnuParser();
List<String> globalArgs = new ArrayList<String>();
boolean inGlobal = true;
for (String arg : args) {
if (inGlobal) {
if (arg.startsWith("--")) {
globalArgs.add(arg);
} else {
this.command = arg;
inGlobal = false;
}
} else {
commandArgs.add(arg);
}
}
try {
this.globalArguments =
globalParser.parse(globalOptions, globalArgs.toArray(new String[globalArgs.size()]));
} catch (ParseException e) {
throw new UserError("Error parsing global command line argument: " + e.getMessage());
}
}
/**
* Creates a parser for command line parsing.
*
* @param args
* @throws ParseException
*/
private void retrieveParser(String[] args) throws ParseException {
// Creates parser.
CommandLineParser parser = new BasicParser();
// Execute the parsing.
commandLine = parser.parse(options, args);
}
/**
* Parse the command line.
*
* @param args command-line arguments
* @return line parsed command line
* @exception ParametersException on error in parameters
*/
public CommandLine parse(final String args[]) throws ParametersException {
log.fine("Command line parsing started");
final CommandLineParser parser = new DefaultParser();
CommandLine line;
try {
line = parser.parse(options, args);
} catch (final ParseException exception) {
throw new ParametersException(
"Failed to parse the command line, exception: " + exception.getMessage());
}
fileNames = line.getArgs();
outputFileNameFlag = line.hasOption("o");
if (outputFileNameFlag) {
outputFileName = line.getOptionValue("o");
}
crcFileNameFlag = line.hasOption("c");
if (crcFileNameFlag) {
crcFileName = line.getOptionValue("c");
}
if (line.hasOption("s")) {
literalStrings = line.getOptionValues("s");
}
listCrcFlag = line.hasOption("l");
hexMode = line.hasOption("x");
log.fine("Command line parsing completed");
return line;
}
/** Check command line arguments. */
public void checkComanLineArgs() {
options.addOption(COMMANDS_MANAGER_U, COMMANDS_MANAGER_USER, true, USER_DESCRIPTION);
options.addOption(COMMANDS_MANAGER_P, COMMANDS_MANAGER_PASSWORD, true, PASSWORD_DESCRIPTION);
options.addOption(
COMMANDS_MANAGER_FETCH_F, COMMANDS_MANAGER_FETCH_FILE, false, FETCH_FILE_DESCRIPTION);
options.addOption(COMMANDS_MANAGER_H, COMMANDS_MANAGER_HELP, false, HELP_DESCRIPTION);
CommandLineParser parser = new PosixParser();
CommandLine cmd;
try {
cmd = parser.parse(options, args);
if (cmd.hasOption(COMMANDS_MANAGER_U) && cmd.hasOption(COMMANDS_MANAGER_P)
|| cmd.hasOption(COMMANDS_MANAGER_USER) && cmd.hasOption(COMMANDS_MANAGER_PASSWORD)) {
setName(cmd.getOptionValue(COMMANDS_MANAGER_U));
setPass(cmd.getOptionValue(COMMANDS_MANAGER_P));
} else if (cmd.hasOption(COMMANDS_MANAGER_FETCH_F)) {
isGetLink = false;
} else if (cmd.hasOption(COMMANDS_MANAGER_H)) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp(COMMANDS_MANAGER_H, options);
System.exit(0);
}
} catch (ParseException e) {
// e.printStackTrace();
LOGGER.error(e);
}
}
public static void main(String[] args) throws Exception {
Options options = new Options();
options.addOption("i", "input-file", true, "input data file.");
options.addOption("o", "output-file", true, "output file.");
options.addOption("h", "help", false, "display help document");
CommandLineParser parser = new PosixParser();
CommandLine cmd = parser.parse(options, args);
String inputFile = null;
String outputFile = null;
if (cmd.hasOption("i")) {
inputFile = cmd.getOptionValue("i");
}
if (cmd.hasOption("o")) {
outputFile = cmd.getOptionValue("o");
}
boolean help = false;
if (inputFile == null || outputFile == null) {
help = true;
}
if (cmd.hasOption("h") || help) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp("docsim stat", options);
return;
}
// DocSimStatTest test = new DocSimStatTest("");
// test.notestSummary();
DocSimLatticeStatistics stat = BasicStatisticsFormatter.getStatFromFile(inputFile);
BasicStatisticsFormatter.avgCalcBySize2File(stat, outputFile);
}
/**
* @param args commandline arguments
* @throws ParseException if parser error
* @throws SAXException if XML parse error
* @throws IOException if IO error
* @throws SQLException if database error
* @throws RegistryExportException if export error
*/
public static void main(String[] args)
throws ParseException, SQLException, IOException, SAXException, RegistryExportException {
// create an options object and populate it
CommandLineParser parser = new PosixParser();
Options options = new Options();
options.addOption("f", "file", true, "output xml file for registry");
options.addOption("s", "schema", true, "the name of the schema to export");
CommandLine line = parser.parse(options, args);
String file = null;
String schema = null;
if (line.hasOption('f')) {
file = line.getOptionValue('f');
} else {
usage();
System.exit(0);
}
if (line.hasOption('s')) {
schema = line.getOptionValue('s');
}
saveRegistry(file, schema);
}
