import net.sourceforge.argparse4j.inf.MutuallyExclusiveGroup; //导入依赖的package包/类
public static void configureArgsParser(final Subparsers subparsers) {
    final Subparser eval = subparsers.addParser("eval").help("evaluates namespace, experiment, or code snippet");
    Planout4jTool.addBackendArgs(eval, false);
    final MutuallyExclusiveGroup nameOrScript = eval.addMutuallyExclusiveGroup("evaluation object");
    nameOrScript.addArgument("-n", "--name").help("namespace name");
    final MutuallyExclusiveGroup experimentOrDefinition = eval.addMutuallyExclusiveGroup("additional selectors within namespace");
    experimentOrDefinition.addArgument("--exp").help("experiment name (requires --name NAME)");
    experimentOrDefinition.addArgument("--definition").help("experiment definition key (requires --name NAME)");
    experimentOrDefinition.addArgument("--default").action(Arguments.storeTrue()).help("default experiment (requires --name NAME)");
    nameOrScript.addArgument("--script").help("planout DSL script");
    eval.addArgument("input").nargs("+").help("input parameters in the form of KEY=VALUE");
}
 

import net.sourceforge.argparse4j.inf.MutuallyExclusiveGroup; //导入依赖的package包/类
/**
 * Creates and returns the ArgumentParser object for parsing command line
 * arguments.
 *
 * @return the ArgumentParser object consisting of command line args.
 */
private static ArgumentParser argParser() {
	ArgumentParser parser = ArgumentParsers.newArgumentParser("KafkaBalancer").defaultHelp(true)
			.description("This tool is used to re-balance the kafka cluster.");

	parser.addArgument("--topic").action(store()).type(String.class).metavar("TOPIC").dest(TOPIC)
			.help("Topic on which the operation is to be performed.");

	parser.addArgument("--zookeeper").action(store()).required(true).type(String.class).dest(ZOOKEEPER)
			.help("zookeeper server URL.");

	MutuallyExclusiveGroup task = parser
			.addMutuallyExclusiveGroup()
			.required(true)
			.description(
					"--balance-partitions or --balance-leaders or --balance-followers or --reassign-under-replicated-partitions or --set-replication-factor must be specified");

	task.addArgument("--balance-partitions").setConst(BALANCE_PARTITIONS).action(storeConst()).dest(TASK)
			.required(false).type(String.class)
			.help("Rebalance cluster when there are no under-replicated partitions.");

	task.addArgument("--balance-leaders").setConst(BALANCE_LEADERS).action(storeConst()).dest(TASK).required(false)
			.type(String.class).help("Rebalance cluster but balance only leaders. Followers should be untouched");

	task.addArgument("--balance-followers").setConst(BALANCE_FOLLOWERS).action(storeConst()).dest(TASK)
			.required(false).type(String.class)
			.help("Rebalance cluster but balance only followers. Leaders should be untouched");

	task.addArgument("--reassign-under-replicated-partitions").setConst(REASSIGN_UNDER_REPLICATED_PARTITIONS)
			.action(storeConst()).dest(TASK).required(false).type(String.class)
			.help("Reassign under replicated partitions to online nodes.");

	task.addArgument("--set-replication-factor").action(store()).dest(SET_REPLICATION_FACTOR).required(false)
			.type(Integer.class).help("Set the number of replicas for a topic").setDefault(-1);

	MutuallyExclusiveGroup operation = parser.addMutuallyExclusiveGroup().required(true)
			.description("either --generate or --execute must be specified but not both.");

	operation.addArgument("--generate").setConst(GENERATE).action(storeConst()).dest(OPERATION).required(false)
			.type(String.class).help("Generate plan.");

	operation.addArgument("--execute").setConst(EXECUTE).action(storeConst()).dest(OPERATION).required(false)
			.type(String.class).help("Generate and execute plan.");

	parser.addArgument("--rack-aware").setConst(true).action(storeConst()).type(boolean.class).setDefault(false)
			.required(false).dest(RACK_AWARE).help("Consider racks while generating reassignment plan.");

	return parser;
}
 

import net.sourceforge.argparse4j.inf.MutuallyExclusiveGroup; //导入依赖的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.MutuallyExclusiveGroup; //导入依赖的package包/类
private static Namespace parse(String[] args) {
	ArgumentParser parser = ArgumentParsers.newArgumentParser("lancoder")
			.defaultHelp(false)
			.version("${prog} " + LANCODER_VERSION);
	parser.addArgument("--version", "-V")
			.action(Arguments.version())
			.help("show the current version and exit");
	parser.addArgument("--verbose", "-v")
			.action(Arguments.count())
			.help("Increase verbosity. Default is level 3. '-vvvvvv' will be the most verbose,"
					+ " '-v' will be the less verbose.");

	MutuallyExclusiveGroup group = parser.addMutuallyExclusiveGroup()
			.required(true)
			.description("Run a master or worker instance");
	group.addArgument("--worker", "-w")
			.action(Arguments.storeTrue())
			.help("run the worker");
	group.addArgument("--master", "-m")
			.action(Arguments.storeTrue())
			.help("run the master");

	MutuallyExclusiveGroup group2 = parser.addMutuallyExclusiveGroup();
	group2.addArgument("--init-prompt", "-i")
			.action(Arguments.storeTrue())
			.help("intialize configuration and prompt user");
	group2.addArgument("--init-default", "-I")
			.action(Arguments.storeTrue())
			.help("initialize default config and exit");

	parser.addArgument("--debug", "-d")
			.action(Arguments.storeTrue())
			.help("Run lancoder in debug mode. Does not delete parts files after remuxing.");
	parser.addArgument("--config", "-c")
			.help("specify the config file");
	parser.addArgument("--overwrite", "-o")
			.action(Arguments.storeTrue())
			.help("if flag is set, overwrite old config");

	return parser.parseArgsOrFail(args);
}