Java ArgumentParserException类代码示例

import net.sourceforge.argparse4j.inf.ArgumentParserException; //导入依赖的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.ArgumentParserException; //导入依赖的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.ArgumentParserException; //导入依赖的package包/类
@Override
public void run(final ArgumentParser parser, final Argument arg, final Map<String, Object> attrs, final String flag, final Object value) throws ArgumentParserException {
    @SuppressWarnings("unchecked")
    final String paramValues = ((List<String>) value).get(0);
    final Set<String> unique = new HashSet<>(Arrays.asList(paramValues.split(",")));
    final String[] protocols = unique.toArray(new String[unique.size()]);

    if (!(protocols.length == 1 && protocols[0].equals("all"))) {
        for (final String protocol : protocols) {
            if (!(protocol.equals("ipv4") || protocol.equals("udp") || protocol.equals("icmp"))) {
                throw new ArgumentParserException("invalid protocol: " + protocol, parser, arg);
            }
        }
    }

    attrs.put(arg.getDest(), new ArrayList<String>(Arrays.asList(protocols)));
}
 

import net.sourceforge.argparse4j.inf.ArgumentParserException; //导入依赖的package包/类
@Override
public void run(final ArgumentParser parser, final Argument arg,
                final Map<String, Object> attrs, final String flag, final Object value) throws ArgumentParserException {
    @SuppressWarnings("unchecked")
    final List<String> values = (List<String>) value;

    final String key = values.get(0);
    if (key.length() != 32 || !Util.stringNumInRadix(key, 16)) {
        throw new ArgumentParserException("AES key must be a 32 character hexidecimal string (128-bit)", parser, arg);
    }

    final String maskString = values.get(1);
    final String maskValueString = maskString.substring(1);

    if (!maskString.startsWith("/") || !Util.stringNumInRadix(maskValueString, 10)) {
        throw new ArgumentParserException("IPv6 mask must be an integer prefixed with /", parser, arg);
    }

    final int mask = Integer.parseInt(maskValueString);
    if (mask < 0 || mask > 120) {
        throw new ArgumentParserException("IPv6 mask must be in range [0, 120]", parser, arg);
    }

    attrs.put(arg.getDest(), value);
}
 

import net.sourceforge.argparse4j.inf.ArgumentParserException; //导入依赖的package包/类
@Override
public void run(final ArgumentParser parser, final Argument arg,
                final Map<String, Object> attrs, final String flag, final Object value) throws ArgumentParserException {
    @SuppressWarnings("unchecked")
    final List<String> values = (List<String>) value;

    final String key = values.get(0);
    if (key.length() != 32 || !Util.stringNumInRadix(key, 16)) {
        throw new ArgumentParserException("AES key must be a 32 character hexidecimal string (128-bit)", parser, arg);
    }

    final String maskString = values.get(1);
    final String maskValueString = maskString.substring(1);

    if (!maskString.startsWith("/") || !Util.stringNumInRadix(maskValueString, 10)) {
        throw new ArgumentParserException("IPv4 mask must be an integer prefixed with /", parser, arg);
    }

    final int mask = Integer.parseInt(maskValueString);
    if (mask < 0 || mask > 24) {
        throw new ArgumentParserException("IPv4 mask must be in range [0, 24]", parser, arg);
    }

    attrs.put(arg.getDest(), value);
}
 

import net.sourceforge.argparse4j.inf.ArgumentParserException; //导入依赖的package包/类
private void run(String... args) throws Exception {
    Namespace namespace;
    try {
        namespace = argumentParser.parseArgs(args);
    } catch (ArgumentParserException e) {
        argumentParser.handleError(e);
        return;
    }

    List<String> urls = namespace.getList(urlKey);

    try {
        Set<HttpUrl> allUrls = argResolver.getAllUrls(urls);
        if (allUrls.isEmpty())
            LOG.info("No playlists found! Check your args: " + Arrays.toString(args));

        for (HttpUrl url : allUrls)
            getHandler(url).join();
    } catch (Throwable t) {
        LOG.info("Error {}: {}", t.getClass().getSimpleName(), t.getMessage());
        LOG.debug("Detailed error output", t);
    } finally {
        theClosener.close();
    }
}
 

import net.sourceforge.argparse4j.inf.ArgumentParserException; //导入依赖的package包/类
@Override
public void run(ArgumentParser parser, Argument arg,
                Map<String, Object> attrs, String flag, Object value)
    throws ArgumentParserException {
  try {
    attrs.put(arg.getDest(),
              ParameterUtil.parseDateHour(value.toString()));
  } catch (DateTimeParseException dateHourException) {
    try {
      attrs.put(arg.getDest(),
                ParameterUtil.parseDate(value.toString()));
    } catch (Exception dateException) {
      throw new ArgumentParserException(
          String.format(
              "could not parse date/datehour for parameter '%s'; if datehour: [%s], if date: [%s]",
              arg.textualName(), dateHourException.getMessage(), dateException.getMessage()),
          parser);
    }
  }
}
 

import net.sourceforge.argparse4j.inf.ArgumentParserException; //导入依赖的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.ArgumentParserException; //导入依赖的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.ArgumentParserException; //导入依赖的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.ArgumentParserException; //导入依赖的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.ArgumentParserException; //导入依赖的package包/类
private static void verifyZKStructure(Options opts, ArgumentParser parser) throws ArgumentParserException {
  if (opts.zkHost != null) {
    assert opts.collection != null;
    ZooKeeperInspector zki = new ZooKeeperInspector();
    try {
      opts.shardUrls = zki.extractShardUrls(opts.zkHost, opts.collection);
    } catch (Exception e) {
      LOG.debug("Cannot extract SolrCloud shard URLs from ZooKeeper", e);
      throw new ArgumentParserException(e, parser);
    }
    assert opts.shardUrls != null;
    if (opts.shardUrls.size() == 0) {
      throw new ArgumentParserException("--zk-host requires ZooKeeper " + opts.zkHost
        + " to contain at least one SolrCore for collection: " + opts.collection, parser);
    }
    opts.shards = opts.shardUrls.size();
    LOG.debug("Using SolrCloud shard URLs: {}", opts.shardUrls);
  }
}
 

import net.sourceforge.argparse4j.inf.ArgumentParserException; //导入依赖的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.ArgumentParserException; //导入依赖的package包/类
public int parseArguments(final String[] args) {
    try {
        this.ns = this.parser.parseArgs(args);
    }
    catch (ArgumentParserException e) {
        this.parser.handleError(e);
        if (e instanceof HelpScreenException) {
            return 1;
        }
        if (e instanceof UnsupportedTargetException) {
            printTargets();
        }
        return -1;
    }

    this.command = Command.getByName(ns.getString("command"));
    this.assignTarget(ns);
    this.assignGlobalOptions(ns);
    this.assignCommandOptions(ns);

    if (this.debug > 1) {
        System.out.println(ns);
        this.printArgs();
    }
    return 0;
}
 

import net.sourceforge.argparse4j.inf.ArgumentParserException; //导入依赖的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;
}