Java ArgumentParser.handleError方法代码示例

import net.sourceforge.argparse4j.inf.ArgumentParser; //导入方法依赖的package包/类
/**
 * Reads a configuration file from the passed CLI args
 *
 * @return Path to config file, or exception
 * @throws ConfigParseException if arguments were incorrectly specified, or nothing was passed (in which case it will print "usage" details)
 */
public static String loadFromCLI(String programName, String... args) throws ConfigParseException {
    ArgumentParser parser = ArgumentParsers.newArgumentParser("java -jar " + programName + "-[VERSION].jar").defaultHelp(true);
    parser.addArgument("--config").metavar("/path/to/app-config.json").required(true).help("Path to configuration file");

    try {
        // parse CLI args and return config file
        Namespace cli = parser.parseArgs(args);
        return cli.getString("config");

    } catch (ArgumentParserException e) {
        // show help message and stop execution
        parser.handleError(e);
        throw new ConfigParseException(e);
    }
}
 

import net.sourceforge.argparse4j.inf.ArgumentParser; //导入方法依赖的package包/类
public static void main(String[] args) {
    ArgumentParser parser = argParser();
    if (args.length == 0) {
        parser.printHelp();
        Exit.exit(0);
    }

    try {
        final VerifiableConsumer consumer = createFromArgs(parser, args);
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                consumer.close();
            }
        });

        consumer.run();
    } catch (ArgumentParserException e) {
        parser.handleError(e);
        Exit.exit(1);
    }
}
 

import net.sourceforge.argparse4j.inf.ArgumentParser; //导入方法依赖的package包/类
public static void main(String[] args) {
    ArgumentParser parser = ArgumentParsers.newArgumentParser("AngusMe");
    parser.description("Angus SDK configurator");

    parser.addArgument("-s", "--show").action(Arguments.storeTrue())
            .help("display current configuration if exists");

    parser.addArgument("-d", "--delete").action(Arguments.storeTrue())
            .help("remove current configuration if exists");

    try {
        Namespace res = parser.parseArgs(args);
        if (res.getBoolean("show")) {
            show();
        } else if (res.getBoolean("delete")) {
            delete();
        } else {
            update();
        }
    } catch (ArgumentParserException e) {
        parser.handleError(e);
    }
}
 

import net.sourceforge.argparse4j.inf.ArgumentParser; //导入方法依赖的package包/类
public static void main(String... args) {
  WSFRealtimeMain m = new WSFRealtimeMain();

  ArgumentParser parser = ArgumentParsers.newArgumentParser("wsf-gtfsrealtime");
  parser.description("Produces a GTFS-realtime feed from the Washington State Ferries API");
  parser.addArgument("--" + ARG_CONFIG_FILE).type(File.class).help("configuration file path");
  Namespace parsedArgs;

  try {
    parsedArgs = parser.parseArgs(args);
    File configFile = parsedArgs.get(ARG_CONFIG_FILE);
    m.run(configFile);
  } catch (CreationException | ConfigurationException | ProvisionException e) {
    _log.error("Error in startup:", e);
    System.exit(-1);
  } catch (ArgumentParserException ex) {
    parser.handleError(ex);
  }
}
 

import net.sourceforge.argparse4j.inf.ArgumentParser; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
    
	ArgumentParser parser = ArgumentParsers.newArgumentParser("ImpressionsToInfluxDb")
            .defaultHelp(true)
            .description("Read Seldon impressions and send stats to influx db");
	parser.addArgument("-t", "--topic").setDefault("impressions").help("Kafka topic to read from");
	parser.addArgument("-k", "--kafka").setDefault("localhost:9092").help("Kafka server and port");
	parser.addArgument("-z", "--zookeeper").setDefault("localhost:2181").help("Zookeeper server and port");
	parser.addArgument("-i", "--influxdb").setDefault("localhost:8086").help("Influxdb server and port");
	parser.addArgument("-u", "--influx-user").setDefault("root").help("Influxdb user");
	parser.addArgument("-p", "--influx-password").setDefault("root").help("Influxdb password");
	parser.addArgument("-d", "--influx-database").setDefault("seldon").help("Influxdb database");
	parser.addArgument("--influx-measurement-impressions").setDefault("impressions").help("Influxdb impressions measurement");
	parser.addArgument("--influx-measurement-requests").setDefault("requests").help("Influxdb requests measurement");
    
    Namespace ns = null;
    try {
        ns = parser.parseArgs(args);
        ImpressionsToInfluxDb.process(ns);
    } catch (ArgumentParserException e) {
        parser.handleError(e);
        System.exit(1);
    }
}
 

import net.sourceforge.argparse4j.inf.ArgumentParser; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
    
	ArgumentParser parser = ArgumentParsers.newArgumentParser("PredictionsToInfluxDb")
            .defaultHelp(true)
            .description("Read Seldon predictions and send stats to influx db");
	parser.addArgument("-t", "--topic").setDefault("Predictions").help("Kafka topic to read from");
	parser.addArgument("-k", "--kafka").setDefault("localhost:9092").help("Kafka server and port");
	parser.addArgument("-z", "--zookeeper").setDefault("localhost:2181").help("Zookeeper server and port");
	parser.addArgument("-i", "--influxdb").setDefault("localhost:8086").help("Influxdb server and port");
	parser.addArgument("-u", "--influx-user").setDefault("root").help("Influxdb user");
	parser.addArgument("-p", "--influx-password").setDefault("root").help("Influxdb password");
	parser.addArgument("-d", "--influx-database").setDefault("seldon").help("Influxdb database");
	parser.addArgument("--influx-measurement").setDefault("predictions").help("Influxdb Predictions measurement");
    
    Namespace ns = null;
    try {
        ns = parser.parseArgs(args);
        PredictionsToInfluxDb.process(ns);
    } catch (ArgumentParserException e) {
        parser.handleError(e);
        System.exit(1);
    }
}
 

import net.sourceforge.argparse4j.inf.ArgumentParser; //导入方法依赖的package包/类
public static void main(String[] args) {
    ArgumentParser parser = ArgumentParsers.newArgumentParser("AdlChecker")
            .defaultHelp(true)
            .description("Checks the syntax of ADL files");

    parser.addArgument("file").nargs("*")
            .help("File to calculate checksum");

    Namespace ns = null;
    try {
        ns = parser.parseArgs(args);
    } catch (ArgumentParserException e) {
        parser.handleError(e);
        System.exit(1);
    }

    if(ns.getList("file").isEmpty()) {
        parser.printUsage();
        parser.printHelp();
    }

    validateArchetypes(ns.getList("file"));
}
 

import net.sourceforge.argparse4j.inf.ArgumentParser; //导入方法依赖的package包/类
public Option handleArguments(String argv[]) {
    ArgumentParser parser = ArgumentParsers.newArgumentParser("Detector")
            .defaultHelp(true)
            .description("Convert Zawgyi <-> Unicode encodings.");

    parser.addArgument("-t", "--to")
            .choices("zawgyi", "unicode")
            .required(true)
            .help("Specify hash function to use");

    parser.addArgument("files").nargs("*")
            .help("Files to convert");

    try {
        parser.parseArgs(argv, this);
    } catch (ArgumentParserException e) {
        parser.handleError(e);
        System.exit(1);
    }

    return this;
}
 

import net.sourceforge.argparse4j.inf.ArgumentParser; //导入方法依赖的package包/类
private static Namespace parseArgs(String[] args) {
	ArgumentParser parser =
	        ArgumentParsers.newArgumentParser("moco", false).description("The Monty compiler.").epilog(
	                "Without -S or -c the program is compiled and directly executed.");

	parser.addArgument("--help").action(Arguments.help()).help("Print this help and exit.");
	parser.addArgument("-S", "--emit-assembly").action(Arguments.storeTrue()).dest("emitAssembly").help(
	        "Emit the LLVM assembly and stop.");
	parser.addArgument("-c", "--compile-only").action(Arguments.storeTrue()).dest("compileOnly").help(
	        "Only compile the executable without running it.");
	parser.addArgument("-e", "--stop-on-first-error").action(Arguments.storeTrue()).dest("stopOnFirstError").help(
	        "Stop the compilation on the first encountered error.");
	parser.addArgument("-p", "--print-ast").action(Arguments.storeTrue()).dest("printAST").help("Print the AST.");
	parser.addArgument("-d", "--debug-parsetree").action(Arguments.storeTrue()).dest("debugParseTree").help(
	        "Debug the parsetree without running anything.");
	parser.addArgument("-o").metavar("<file>").dest("outputFile").help("Write output to <file>.");
	parser.addArgument("file").nargs("?").help("Monty file to run.");

	Namespace ns = null;
	try {
		ns = parser.parseArgs(args);
	} catch (ArgumentParserException ape) {
		parser.handleError(ape);
	}
	return ns;
}
 

import net.sourceforge.argparse4j.inf.ArgumentParser; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
	ArgumentParser parser = argParser();
	Namespace ns = null;
	try {
		ns = parser.parseArgs(args);
	} catch (ArgumentParserException e) {
		parser.handleError(e);
		System.exit(1);
	}

	String topicOrNull = ns.getString(TOPIC);
	String zookeeper = ns.getString(ZOOKEEPER);
	boolean rackAware = ns.getBoolean(RACK_AWARE);

	BrokersTopicsCache.initialize(zookeeper, rackAware);
	String assignmentPlanJsonStr = generateAssignmentPlan(ns, topicOrNull, rackAware);

	switch (ns.getString(OPERATION)) {
	case GENERATE:
		break;
	case EXECUTE:
		if (assignmentPlanJsonStr != null) {
			executePlan(zookeeper, assignmentPlanJsonStr);
		} else {
			log.info("No assignment plan generated to execute, exiting");
		}
		break;
	default:
		throw new ReplicaAssignmentException("Unknown mode: " + ns.getString(OPERATION));
	}
}
 

import net.sourceforge.argparse4j.inf.ArgumentParser; //导入方法依赖的package包/类
/**
 * Main function demonstrating command-line processing via argparse4j.
 *
 * @param arguments Command-line arguments.
 */
public static void main(final String[] arguments)
{
   final ArgumentParser argumentParser =
      ArgumentParsers.newArgumentParser("Main", true);
   argumentParser.addArgument("-f", "--file")
                 .dest("file")
                 .required(true)
                 .help("Path and name of file");
   argumentParser.addArgument("-v", "--verbose")
                 .dest("verbose")
                 .type(Boolean.class)
                 .nargs("?")
                 .setConst(true)
                 .help("Enable verbose output.");

   try
   {
      final Namespace response = argumentParser.parseArgs(arguments);
      final String filePathAndName = response.getString("file");
      final Boolean verbositySet = response.getBoolean("verbose");
      out.println(
           "Path/name of file is '" + filePathAndName
         + "' and verbosity is "
         + (Boolean.TRUE.equals(verbositySet) ? "SET" : "NOT SET")
         + ".");
   }
   catch (ArgumentParserException parserEx)
   {
      argumentParser.handleError(parserEx);
   }
}
 

import net.sourceforge.argparse4j.inf.ArgumentParser; //导入方法依赖的package包/类
/**
 * Parse the input arguments and return the {@link Namespace} object.
 * @param args the input argument list
 * @return the parsed arguments as a {@link Namespace} object
 */
private static Namespace parseArgs(String[] args) {
	ArgumentParser parser = ArgumentParsers.newArgumentParser("Align")
			.defaultHelp(true)
			.description("Calculate the alignment of multiple structures");
	parser.addArgument("-a", "--align")
	.choices(CeCPMain.algorithmName, FatCatRigid.algorithmName, "DUMMY").setDefault(FatCatRigid.algorithmName)
	.help("Specify alignment method");
	parser.addArgument("-s", "--score")
	.choices("TM","RMSD").setDefault("TM")
	.help("Specify scoring method");
	parser.addArgument("-u", "--files").type(Boolean.class)
	.setDefault(false);
	parser.addArgument("-k", "--numclusts")
	.help("The number of clusters").setDefault(2);
	parser.addArgument("-c", "--cluster")
	.choices("PIC").setDefault("PIC")
	.help("Specify clustering method");
	parser.addArgument("pdbId").nargs("*")
	.help("The PDB Ids to consider");
	parser.addArgument("-z", "--sample").type(Double.class)
	.help("The sample of the PDB to take").setDefault(1.00);
	parser.addArgument("-l", "--minlength").type(Double.class)
	.help("The minimum length of each chain").setDefault(60);
	parser.addArgument("-t", "--threshold").type(Double.class)
	.help("The threshold to define an edge").setDefault(0.5);
	parser.addArgument("-f", "--hadoop")
	.help("The hadoop file to read from").setDefault(defaultPath);
	Namespace ns = null;
	try {
		ns = parser.parseArgs(args);
	} catch (ArgumentParserException e) {
		parser.handleError(e);
		System.exit(1);
	}
	return ns;
}
 

import net.sourceforge.argparse4j.inf.ArgumentParser; //导入方法依赖的package包/类
public static void main(String[] args) {
    ArgumentParser parser = ArgumentParsers.newArgumentParser("com.flurry.proguard.UploadMapping", true)
            .description("Uploads Proguard/Native Mapping Files for Android");
    parser.addArgument("-k", "--api-key").required(true)
                .help("API Key for your project");
    parser.addArgument("-u", "--uuid").required(true)
                .help("The build UUID");
    parser.addArgument("-p", "--path").required(true)
            .help("Path to ProGuard/Native mapping file for the build");
    parser.addArgument("-t", "--token").required(true)
                .help("A Flurry auth token to use for the upload");
    parser.addArgument("-to", "--timeout").type(Integer.class).setDefault(TEN_MINUTES_IN_MS)
                .help("How long to wait (in ms) for the upload to be processed");
    parser.addArgument("-n", "--ndk").type(Boolean.class).setDefault(false)
                .help("Is it a Native mapping file");

    Namespace res = null;
    try {
        res = parser.parseArgs(args);
    } catch (ArgumentParserException e) {
        parser.handleError(e);
        System.exit(1);
    }

    EXIT_PROCESS_ON_ERROR = true;
    if (res.getBoolean("ndk")) {
        uploadFiles(res.getString("api_key"), res.getString("uuid"),
                new ArrayList<>(Collections.singletonList(res.getString("path"))),
                res.getString("token"), res.getInt("timeout"), AndroidUploadType.ANDROID_NATIVE);
    } else {
        uploadFiles(res.getString("api_key"), res.getString("uuid"),
                new ArrayList<>(Collections.singletonList(res.getString("path"))),
                res.getString("token"), res.getInt("timeout"), AndroidUploadType.ANDROID_JAVA);
    }
}
 

import net.sourceforge.argparse4j.inf.ArgumentParser; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
    
	ArgumentParser parser = ArgumentParsers.newArgumentParser("ImpressionsToInfluxDb")
            .defaultHelp(true)
            .description("Read Seldon impressions and send stats to influx db");
	parser.addArgument("-t", "--topic").setDefault("actions").help("Kafka topic to read from");
	parser.addArgument("-c", "--client").required(true).help("Client to run item similarity");
	parser.addArgument("-o", "--output-topic").required(true).help("Output topic");
	parser.addArgument("-k", "--kafka").setDefault("localhost:9092").help("Kafka server and port");
	parser.addArgument("-z", "--zookeeper").setDefault("localhost:2181").help("Zookeeper server and port");
	parser.addArgument("-w", "--window-secs").type(Integer.class).setDefault(3600*5).help("streaming window size in secs, -1 means ignore");
	parser.addArgument("-u", "--window-processed").type(Integer.class).setDefault(-1).help("streaming window size in processed count, -1 means ignore");
	parser.addArgument("--output-poll-secs").type(Integer.class).setDefault(60).help("output timer polling period in secs");
	parser.addArgument("--hashes").type(Integer.class).setDefault(100).help("number of hashes");
	parser.addArgument("-m", "--min-activity").type(Integer.class).setDefault(200).help("min activity");
	parser.addArgument("-p", "--parse-date-method").choices("json-time","json-utc","system").setDefault("json-time").help("min activity");
    
    Namespace ns = null;
    try {
        ns = parser.parseArgs(args);
        ItemSimilarityProcessor processor = new ItemSimilarityProcessor(ns);
        processor.process(ns);
    } catch (ArgumentParserException e) {
        parser.handleError(e);
        System.exit(1);
    }
}
 

import net.sourceforge.argparse4j.inf.ArgumentParser; //导入方法依赖的package包/类
public static Params parseArgs(final String[] args, final ArgumentParser parser) {
    final Params params = new Params();
    try {
        parser.parseArgs(args, params);
        return params;
    } catch (final ArgumentParserException e) {
        parser.handleError(e);
    }
    System.exit(1);
    return null;
}