Java ArgumentGroup类代码示例

import net.sourceforge.argparse4j.inf.ArgumentGroup; //导入依赖的package包/类
/**
 * Setup {@link ArgumentParser}
 * 
 * @param subParsers
 *            {@link Subparsers} to setup
 */
public static void setupParser(Subparsers subParsers) {
	BiFunction<String[], Namespace, DatabaseListCommand> handler = (argv, args) -> {
		try {
			return new DatabaseListCommand(argv, args);
		} catch (CommandLineParsingException e) {
			throw new UncheckedJannovarException("Could not parse command line", e);
		}
	};

	Subparser subParser = subParsers.addParser("db-list", true).help("list databases available for download")
			.setDefault("cmd", handler);
	subParser.description("List databases available for download");

	ArgumentGroup optionalGroup = subParser.addArgumentGroup("Optional Arguments");
	optionalGroup.addArgument("-s", "--data-source-list").help("INI file with data source list")
			.setDefault(Lists.newArrayList("bundle:///default_sources.ini")).action(Arguments.append());

	JannovarBaseOptions.setupParser(subParser);
}
 

import net.sourceforge.argparse4j.inf.ArgumentGroup; //导入依赖的package包/类
/**
 * Setup {@link ArgumentParser}
 * 
 * @param subParsers
 *            {@link Subparsers} to setup
 */
public static void setupParser(Subparsers subParsers) {
	BiFunction<String[], Namespace, DownloadCommand> handler = (argv, args) -> {
		try {
			return new DownloadCommand(argv, args);
		} catch (CommandLineParsingException e) {
			throw new UncheckedJannovarException("Could not parse command line", e);
		}
	};
	
	Subparser subParser = subParsers.addParser("download", true).help("download transcript databases")
			.setDefault("cmd", handler);
	subParser.description("Download transcript database");
	
	ArgumentGroup requiredGroup = subParser.addArgumentGroup("Required arguments");
	requiredGroup.addArgument("-d", "--database").help("Name of database to download, can be given multiple times")
			.setDefault(new ArrayList<String>()).action(Arguments.append()).required(true);

	ArgumentGroup optionalGroup = subParser.addArgumentGroup("Optional Arguments");
	optionalGroup.addArgument("-s", "--data-source-list").help("INI file with data source list")
			.setDefault(Lists.newArrayList("bundle:///default_sources.ini")).action(Arguments.append());
	optionalGroup.addArgument("--download-dir").help("Path to download directory").setDefault("data");

	JannovarBaseOptions.setupParser(subParser);
}
 

import net.sourceforge.argparse4j.inf.ArgumentGroup; //导入依赖的package包/类
/**
 * Setup {@link ArgumentParser}
 * 
 * @param subParsers
 *            {@link Subparsers} to setup
 */
public static void setupParser(Subparsers subParsers) {
	BiFunction<String[], Namespace, AnnotatePositionCommand> handler = (argv, args) -> {
		try {
			return new AnnotatePositionCommand(argv, args);
		} catch (CommandLineParsingException e) {
			throw new UncheckedJannovarException("Could not parse command line", e);
		}
	};

	Subparser subParser = subParsers.addParser("annotate-pos", true)
			.help("annotate genomic changes given on the command line").setDefault("cmd", handler);
	subParser.description("Perform annotation of genomic changes given on the command line");
	ArgumentGroup requiredGroup = subParser.addArgumentGroup("Required arguments");
	requiredGroup.addArgument("-d", "--database").help("Path to database .ser file").required(true);
	requiredGroup.addArgument("-c", "--genomic-change").help("Genomic change to annotate, you can give multiple ones")
			.action(Arguments.append()).required(true);

	subParser.epilog("Example: java -jar Jannovar.jar annotate-pos -d hg19_refseq.ser -c 'chr1:12345C>A'");

	JannovarAnnotationOptions.setupParser(subParser);
}
 

import net.sourceforge.argparse4j.inf.ArgumentGroup; //导入依赖的package包/类
/**
 * Setup global {@link ArgumentParser}
 * 
 * @param parser
 *            {@link ArgumentParser} to setup
 */
public static void setupParser(ArgumentParser parser) {
	parser.version(Jannovar.getVersion());
	parser.addArgument("--version").help("Show Jannovar version").action(Arguments.version());

	ArgumentGroup verboseGroup = parser.addArgumentGroup("Verbosity Options");
	verboseGroup.addArgument("--report-no-progress").help("Disable progress report, more quiet mode")
			.dest("report_progress").setDefault(true).action(Arguments.storeFalse());
	verboseGroup.addArgument("-v", "--verbose").help("Enable verbose mode").dest("verbose").setDefault(false)
			.action(Arguments.storeTrue());
	verboseGroup.addArgument("-vv", "--very-verbose").help("Enable very verbose mode").dest("very_verbose")
			.setDefault(false).action(Arguments.storeTrue());

	ArgumentGroup proxyGroup = parser.addArgumentGroup("Proxy Options");
	proxyGroup.description("Configuration related to Proxy, note that environment variables *_proxy "
			+ "and *_PROXY are also interpreted");
	proxyGroup.addArgument("--http-proxy").help("Set HTTP proxy to use, if any");
	proxyGroup.addArgument("--https-proxy").help("Set HTTPS proxy to use, if any");
	proxyGroup.addArgument("--ftp-proxy").help("Set FTP proxy to use, if any");
}
 

import net.sourceforge.argparse4j.inf.ArgumentGroup; //导入依赖的package包/类
/**
 * Setup {@link ArgumentParser}
 * 
 * @param subParsers
 *            {@link Subparsers} to setup
 */
public static void setupParser(Subparsers subParsers) {
	BiFunction<String[], Namespace, GatherStatisticsCommand> handler = (argv, args) -> {
		try {
			return new GatherStatisticsCommand(argv, args);
		} catch (CommandLineParsingException e) {
			throw new UncheckedJannovarException("Could not parse command line", e);
		}
	};

	Subparser subParser = subParsers.addParser("statistics", true).help("compute statistics about VCF file")
			.setDefault("cmd", handler);
	subParser.description("Compute statistics about variants in VCF file");

	ArgumentGroup requiredGroup = subParser.addArgumentGroup("Required arguments");
	requiredGroup.addArgument("-i", "--input-vcf").help("Path to input VCF file").required(true);
	requiredGroup.addArgument("-o", "--output-report").help("Path to output report TXT file").required(true);
	requiredGroup.addArgument("-d", "--database").help("Path to database .ser file").required(true);

	JannovarBaseOptions.setupParser(subParser);
}
 

import net.sourceforge.argparse4j.inf.ArgumentGroup; //导入依赖的package包/类
@Override
public void configure(Subparser subparser) {
    super.configure(subparser);

    subparser.addArgument("id")
            .required(true)
            .help("IDs for the report (IDs can be reused to continue a partially completed report)");

    subparser.addArgument("--placements")
            .dest("placements")
            .metavar("PLACEMENT")
            .nargs("+")
            .help("Limit report to the provided placements (by default all placements are included)");

    ArgumentGroup continuation = subparser.addArgumentGroup("continue")
            .description("Continue report from a specific shard and table");

    continuation.addArgument("--shard")
            .dest("shard")
            .type(Integer.class)
            .help("The shard ID to continue from (by default the report starts at the first shard)");

    continuation.addArgument("--table")
            .dest("table")
            .help("The UUID of the table to continue from (by default the report starts at the " +
                    "first table in the initial shard");

    subparser.addArgument("--readOnly")
            .action(new StoreTrueArgumentAction())
            .dest("readOnly")
            .help("Do not modify any data, such as fixing invalid compaction records");
}
 

import net.sourceforge.argparse4j.inf.ArgumentGroup; //导入依赖的package包/类
public static void addConnectionArgumentsTo(ArgumentParser parser) {
	// get environment variables
	String url = System.getenv("IFMAP_URL");
	String user = System.getenv("IFMAP_USER");
	String pass = System.getenv("IFMAP_PASS");
	String keystorePath = System.getenv("IFMAP_TRUSTSTORE_PATH");
	String keystorePass = System.getenv("IFMAP_TRUSTSTORE_PASS");

	// set them if they were defined
	if (url == null)
		url = DefaultConfig.DEFAULT_URL;
	if (user == null)
		user = DefaultConfig.DEFAULT_USER;
	if (pass == null)
		pass = DefaultConfig.DEFAULT_PASS;
	if (keystorePath == null)
		keystorePath = DefaultConfig.DEFAULT_KEYSTORE_PATH;
	if (keystorePass == null)
		keystorePass = DefaultConfig.DEFAULT_KEYSTORE_PASS;

	ArgumentGroup group = parser.addArgumentGroup("IF-MAP parameters");
	group.addArgument("--url").type(String.class).dest(URL).setDefault(url)
			.help("the MAP server URL");
	group.addArgument("--user").type(String.class).dest(USER)
			.setDefault(user).help("IF-MAP basic auth user");
	group.addArgument("--pass").type(String.class).dest(PASS)
			.setDefault(pass).help("user password");
	group.addArgument("--keystore-path").type(String.class)
			.dest(KEYSTORE_PATH).setDefault(keystorePath)
			.help("the keystore file");
	group.addArgument("--keystore-pass").type(String.class)
			.dest(KEYSTORE_PASS).setDefault(keystorePass)
			.help("password for the keystore");
}
 

import net.sourceforge.argparse4j.inf.ArgumentGroup; //导入依赖的package包/类
/**
 * Setup {@link ArgumentParser}
 * 
 * @param subParsers
 *            {@link Subparsers} to setup
 */
public static void setupParser(Subparsers subParsers) {
	BiFunction<String[], Namespace, ProjectTranscriptToChromosome> handler = (argv, args) -> {
		try {
			return new ProjectTranscriptToChromosome(args);
		} catch (CommandLineParsingException e) {
			throw new UncheckedJannovarException("Could not parse command line", e);
		}
	};

	Subparser subParser = subParsers.addParser("hgvs-to-vcf", true)
			.help("project transcript-level to chromosome-level changes").setDefault("cmd", handler);
	subParser.description("Project transcript-level changes to chromosome level ones");
	ArgumentGroup requiredGroup = subParser.addArgumentGroup("Required arguments");
	requiredGroup.addArgument("-r", "--reference-fasta").help("Path to reference FASTA file").required(true);
	requiredGroup.addArgument("-d", "--database").help("Path to database .ser file").required(true);
	requiredGroup.addArgument("-i", "--input-txt").help("Input file with HGVS transcript-level changes, line-by-line")
			.required(true);
	requiredGroup.addArgument("-o", "--output-vcf").help("Output VCF file with chromosome-level changes")
			.required(true);

	ArgumentGroup optionalGroup = subParser.addArgumentGroup("Optional Arguments");
	optionalGroup.addArgument("--show-all").help("Show all effects").setDefault(false);
	optionalGroup.addArgument("--no-3-prime-shifting").help("Disable shifting towards 3' of transcript")
			.dest("3_prime_shifting").setDefault(true).action(Arguments.storeFalse());
	optionalGroup.addArgument("--3-letter-amino-acids").help("Enable usage of 3 letter amino acid codes")
			.setDefault(false).action(Arguments.storeTrue());

	subParser.epilog("Example: java -jar Jannovar.jar tx-to-chrom -i in.txt -o out.vcf");

	JannovarBaseOptions.setupParser(subParser);
}
 

import net.sourceforge.argparse4j.inf.ArgumentGroup; //导入依赖的package包/类
/**
 * Setup {@link ArgumentParser}
 * 
 * @param subParsers
 *            {@link Subparsers} to setup
 */
public static void setupParser(ArgumentParser subParser) {
	ArgumentGroup optionalGroup = subParser.addArgumentGroup("Optional Arguments");
	optionalGroup.addArgument("--show-all").help("Show all effects").setDefault(false).action(Arguments.storeTrue());
	optionalGroup.addArgument("--no-3-prime-shifting").help("Disable shifting towards 3' of transcript")
			.dest("3_prime_shifting").setDefault(true).action(Arguments.storeFalse());
	optionalGroup.addArgument("--3-letter-amino-acids").help("Enable usage of 3 letter amino acid codes")
			.setDefault(false).action(Arguments.storeTrue());
	
	JannovarBaseOptions.setupParser(subParser);
}
 

import net.sourceforge.argparse4j.inf.ArgumentGroup; //导入依赖的package包/类
/**
 * Setup {@link ArgumentParser}
 * 
 * @param subParsers
 *            {@link Subparsers} to setup
 */
public static void setupParser(Subparsers subParsers) {
	BiFunction<String[], Namespace, AnnotateCSVCommand> handler = (argv, args) -> {
		try {
			return new AnnotateCSVCommand(args);
		} catch (CommandLineParsingException e) {
			throw new UncheckedJannovarException("Could not parse command line", e);
		}
	};

	Subparser subParser = subParsers.addParser("annotate-csv", true).help("Annotate a csv file").setDefault("cmd",
			handler);
	subParser.description("Perform annotation of genomic changes given on the command line");
	ArgumentGroup requiredGroup = subParser.addArgumentGroup("Required arguments");
	requiredGroup.addArgument("-d", "--database").help("Path to database .ser file").required(true);
	requiredGroup.addArgument("-i", "--input").help("CSV file").required(true);
	requiredGroup.addArgument("-c", "--chr").type(Integer.class).help("Column of chr (1 based)").required(true);
	requiredGroup.addArgument("-p", "--pos").type(Integer.class).help("Column of pos (1 based)").required(true);
	requiredGroup.addArgument("-r", "--ref").type(Integer.class).help("Column of ref (1 based)").required(true);
	requiredGroup.addArgument("-a", "--alt").type(Integer.class).help("Column of alt (1 based)").required(true);
	ArgumentGroup optionalGroup = subParser.addArgumentGroup("Additional CSV arguments (optional)");
	optionalGroup.addArgument("-t", "--type").type(CSVFormat.Predefined.class)
			.choices(CSVFormat.Predefined.Default, CSVFormat.Predefined.TDF, CSVFormat.Predefined.RFC4180,
					CSVFormat.Predefined.Excel, CSVFormat.Predefined.MySQL)
			.help("Type of csv file. ").setDefault(CSVFormat.Predefined.Default);
	optionalGroup.addArgument("--header").help("Set if the file contains a header. ").setDefault(false)
			.action(Arguments.storeTrue());

	subParser.epilog(
			"Example: java -jar Jannovar.jar annotate-csv -d hg19_refseq.ser -c 1 -p 2 -r 3 -r 4 -t TDF --header -i input.csv");

	JannovarAnnotationOptions.setupParser(subParser);
}
 

import net.sourceforge.argparse4j.inf.ArgumentGroup; //导入依赖的package包/类
public static void main(final String[] args) {
    final ArgumentParser parser = ArgumentParsers.newArgumentParser(CLTool.class.getSimpleName())
        .description("Tool to pseudonymize certain DNS packets packets in PCAP or PCAPNG files.")
        .version("0.0.1");

    final ArgumentGroup requiredGroup = parser.addArgumentGroup("required arguments");

    requiredGroup.addArgument("-i", "--infile")
        .required(true)
        .metavar("infile")
        .type(String.class)
        .action(new FileCheckAction())
        .help("the input file to process (either PCAP or PCAPNG)");
    requiredGroup.addArgument("-o", "--outfile")
        .required(true)
        .metavar("outfile")
        .type(String.class)
        .help("the output file to create and write to");
    parser.addArgument("-v", "--version")
        .action(Arguments.version())
        .help("show the program version");
    parser.addArgument("-4", "--pseudo4")
        .nargs(2)
        .metavar("key", "mask")
        .action(new Pseudo4CheckAction())
        .help("pseudonymize the masked part of IPv4 addresses using FPE, with given key");
    parser.addArgument("-6", "--pseudo6")
        .nargs(2)
        .metavar("key", "mask")
        .action(new Pseudo6CheckAction())
        .help("pseudonymize the masked part of IPv6 addresses using FPE, with given key");
    parser.addArgument("-c", "--checksum")
        .nargs(1)
        .metavar("[ipv4,udp,icmp] or all")
        .action(new ChecksumCheckAction())
        .help("recalculate checksums of given protocols (given as comma separated list or 'all')");
    parser.addArgument("-m", "--multithread")
        .metavar("numthreads")
        .type(Integer.class)
        .choices(Arguments.range(1, 127)) // TODO: range as [1, maxDetectedCores]?
        .help("use multithreading with specified number of threads, in range of [1, 127]");

    try {
        final Namespace cmdResult = parser.parseArgs(args);
        runTool(cmdResult);
    }
    catch (final HelpScreenException hse) {
        // this is the normal behaviour, throwing exception when asking for help
        // in this case, do nothing
    }
    catch (final ArgumentParserException ape) {
        System.err.println(parser.formatUsage() + CLTool.class.getSimpleName() + ": error: " + ape.getMessage());
    }
}
 

import net.sourceforge.argparse4j.inf.ArgumentGroup; //导入依赖的package包/类
@Override
protected void addArguments(ArgumentParser parser) {
    ArgumentGroup schemaGroup = parser.addArgumentGroup("schemas");
    schemaGroup.description("Schemas generated by this script");

    schemaGroup.addArgument("--emoSchema")
            .dest("emoSchema")
            .metavar("NAME")
            .nargs("?")
            .help("Name of the schema where \"emodb\" located tables are generated");

    schemaGroup.addArgument("--stashSchema")
            .dest("stashSchema")
            .metavar("NAME")
            .nargs("?")
            .help("Name of the schema where \"emostash\" located tables are generated");

    parser.addArgument("--location")
            .dest("location")
            .metavar("EMOURL")
            .nargs("?")
            .required(true)
            .help("URI location of the EmoDB server, such as \"emodb://ci.us\"");

    parser.addArgument("--apiKey")
            .dest("apiKey")
            .metavar("KEY")
            .nargs("?")
            .required(true)
            .help("API key for connecting to EmoDB");

    parser.addArgument("--compatibility")
            .dest("compatibility")
            .nargs("?")
            .choices("hive", "general")
            .setDefault("hive")
            .help("hive = Use custom SerDe and InputFormat to provide efficiency and rich column names (default).  " +
                    "general = No custom SerDe or InputFormat so is more compatible with Hive alternatives like " +
                    "Presto and Impala but is slightly less efficient and only provides a single JSON column.");

    parser.addArgument("--disableIfNotExists")
            .dest("disableIfNotExists")
            .action(storeTrue())
            .setDefault(false)
            .help("Disables \"IF NOT EXISTS\" from being included in each \"CREATE TABLE\" command");

    parser.addArgument("--recreateTables")
            .dest("recreateTables")
            .action(storeTrue())
            .setDefault(false)
            .help("Drops each table if it exists prior to the \"CREATE TABLE\" command");
}
 

import net.sourceforge.argparse4j.inf.ArgumentGroup; //导入依赖的package包/类
private static ArgumentParser setupParser()
{
    ArgumentParser parser = ArgumentParsers.newArgumentParser( "cypher-shell" ).defaultHelp( true ).description(
            format( "A command line shell where you can execute Cypher against an instance of Neo4j. " +
                    "By default the shell is interactive but you can use it for scripting by passing cypher " +
                    "directly on the command line or by piping a file with cypher statements (requires Powershell on Windows)." +
                    "%n%n" +
                    "example of piping a file:%n" +
                    "  cat some-cypher.txt | cypher-shell" ) );

    ArgumentGroup connGroup = parser.addArgumentGroup("connection arguments");
    connGroup.addArgument("-a", "--address")
            .help("address and port to connect to")
            .setDefault("bolt://localhost:7687");
    connGroup.addArgument("-u", "--username")
            .setDefault("")
            .help("username to connect as. Can also be specified using environment variable NEO4J_USERNAME");
    connGroup.addArgument("-p", "--password")
            .setDefault("")
            .help("password to connect with. Can also be specified using environment variable NEO4J_PASSWORD");
    connGroup.addArgument("--encryption")
            .help("whether the connection to Neo4j should be encrypted; must be consistent with Neo4j's " +
                    "configuration")
            .type(new BooleanArgumentType())
            .setDefault(true);

    MutuallyExclusiveGroup failGroup = parser.addMutuallyExclusiveGroup();
    failGroup.addArgument("--fail-fast")
            .help("exit and report failure on first error when reading from file (this is the default behavior)")
            .dest("fail-behavior")
            .setConst(FAIL_FAST)
            .action(new StoreConstArgumentAction());
    failGroup.addArgument("--fail-at-end")
            .help("exit and report failures at end of input when reading from file")
            .dest("fail-behavior")
            .setConst(FAIL_AT_END)
            .action(new StoreConstArgumentAction());
    parser.setDefault("fail-behavior", FAIL_FAST);

    parser.addArgument("--format")
            .help("desired output format, verbose displays results in tabular format and prints statistics, " +
                    "plain displays data with minimal formatting")
            .choices(new CollectionArgumentChoice<>(
                    Format.AUTO.name().toLowerCase(),
                    Format.VERBOSE.name().toLowerCase(),
                    Format.PLAIN.name().toLowerCase()))
            .setDefault(Format.AUTO.name().toLowerCase());

    parser.addArgument("--debug")
            .help("print additional debug information")
            .action(new StoreTrueArgumentAction());

    parser.addArgument("--non-interactive")
            .help("force non-interactive mode, only useful if auto-detection fails (like on Windows)")
            .dest("force-non-interactive")
          .action(new StoreTrueArgumentAction());

    parser.addArgument("-v", "--version")
            .help("print version of cypher-shell and exit")
            .action(new StoreTrueArgumentAction());

    parser.addArgument("cypher")
            .nargs("?")
            .help("an optional string of cypher to execute and then exit");

    return parser;
}
 

import net.sourceforge.argparse4j.inf.ArgumentGroup; //导入依赖的package包/类
private void createCompileArguments(Subparser parser) {
    ArgumentGroup groupOptions = parser.addArgumentGroup("options");
    groupOptions.addArgument("input").metavar("<input>").dest(Dest.INPUT).required(true).help("input file (.jrxml) or directory");
    groupOptions.addArgument("-o").metavar("<output>").dest(Dest.OUTPUT).help("directory or basename of outputfile(s)");
}
 

import net.sourceforge.argparse4j.inf.ArgumentGroup; //导入依赖的package包/类
private void createListParamsArguments(Subparser parser) {
    ArgumentGroup groupOptions = parser.addArgumentGroup("options");
    groupOptions.addArgument("input").metavar("<input>").dest(Dest.INPUT).required(true).help("input file (.jrxml) or (.jasper)");
}