Java JCommander.addCommand方法代码示例

import com.beust.jcommander.JCommander; //导入方法依赖的package包/类
public Commander(Plugin plugin) {
  template = new CommandTemplate();
  jcommander = new JCommander(template);
  jcommander.setProgramName("spellcastr");
  bind = new CommandBind();
  jcommander.addCommand("bind", bind);
  create = new CommandCreate();
  jcommander.addCommand("create", create);
  setLore = new CommandSetLore();
  jcommander.addCommand("lore", setLore);
  setItem = new CommandSetItem();
  jcommander.addCommand("item", setItem);
  craft = new CommandCraft();
  jcommander.addCommand("craft", craft);
  setType = new CommandSetType();
  jcommander.addCommand("type", setType);
  setOption = new CommandSetOption();
  jcommander.addCommand("option", setOption);
  help = new CommandHelp();
  jcommander.addCommand("help", help);

  this.plugin = plugin;
}
 

import com.beust.jcommander.JCommander; //导入方法依赖的package包/类
/**
 * Initializes JCommander and a {@link TestJCommandConfiguration} and adds it to the commands
 * JCommander listens to.
 */
@Before
public void setupJCommanderTest() {
   jCommander = new JCommander();
   sampleCommandConfiguration = new TestJCommandConfiguration();
   jCommander.addCommand(COMMAND_SET_ALGORITHMS, sampleCommandConfiguration);
}
 

import com.beust.jcommander.JCommander; //导入方法依赖的package包/类
/**
 * Initializes the JCommander and a  TestJCommandConfiguration object and adds it to the commands
 * JCommander listens to.
 */
@Before
public void setupJCommanderTest() {
   jCommander = new JCommander();
   evaluateAlgorithmsCommandConfiguration = new EvaluateAlgorithmsCommandConfiguration();
   jCommander.addCommand(EVALUATE_ALGORITHM_COMMAND_LINE, evaluateAlgorithmsCommandConfiguration);
}
 

import com.beust.jcommander.JCommander; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {

    ConversationUtility conversationCmd = new ConversationUtility();
    JCommander jCommander = new JCommander(conversationCmd);

    jCommander.setProgramName("Watson Conversation Globalization");
    jCommander.addCommand("help", new HelpCmd());

    jCommander.addCommand("WCS_To_GP", new WCS_To_GP(), "wcs_to_gp");
    jCommander.addCommand("GP_To_WCS", new GP_To_WCS(), "gp_to_wcs");

    try {
      jCommander.parse(args);
      String parsedCommand = jCommander.getParsedCommand();
      System.out.println(parsedCommand);
      if (parsedCommand == null || parsedCommand.equalsIgnoreCase("help")) {
        jCommander.usage();
      } else {
        BaseUtility parsedCmd = (BaseUtility) jCommander.getCommands().get(parsedCommand).getObjects().get(0);
        parsedCmd.execute();
      }
    } catch (ParameterException e) {
      System.err.println(e.getMessage());
      jCommander.usage();
      System.exit(1);
    }
  }
 

import com.beust.jcommander.JCommander; //导入方法依赖的package包/类
public static void main(final String[] args) throws Exception {
    final Map<String, IWalleCommand> subCommandList = new HashMap<String, IWalleCommand>();
    subCommandList.put("show", new ShowCommand());
    subCommandList.put("rm", new RemoveCommand());
    subCommandList.put("put", new PutCommand());
    subCommandList.put("batch", new BatchCommand());
    subCommandList.put("batch2", new Batch2Command());

    final WalleCommandLine walleCommandLine = new WalleCommandLine();
    final JCommander commander = new JCommander(walleCommandLine);

    for (Map.Entry<String, IWalleCommand> commandEntry : subCommandList.entrySet()) {
        commander.addCommand(commandEntry.getKey(), commandEntry.getValue());
    }
    try {
        commander.parse(args);
    } catch (ParameterException e) {
        System.out.println(e.getMessage());
        commander.usage();
        System.exit(1);
        return;
    }

    walleCommandLine.parse(commander);

    final String parseCommand = commander.getParsedCommand();
    if (parseCommand != null) {
        subCommandList.get(parseCommand).parse();
    }
}
 

import com.beust.jcommander.JCommander; //导入方法依赖的package包/类
public CommandInterpreter(String[] args) throws IOException{
    Arrays.stream(args).forEach(a->System.out.println(a));
    commander = new JCommander(new CommandInterpreter());
    ExcelToHql eth = new ExcelToHql();
    commander.addCommand("eth", eth);
    Load l = new Load();
    commander.addCommand("load", l);
    RunBusinessLogic b = new RunBusinessLogic();
    commander.addCommand("hive", b);
    CompareActualToExpected c = new CompareActualToExpected();
    commander.addCommand("assert", c);
    Clean cl = new Clean();
    commander.addCommand("clean", cl);
    commander.parse(args);
}
 

import com.beust.jcommander.JCommander; //导入方法依赖的package包/类
/**
 * Used for integration testing
 *
 * @param argv arguments provided match usage in the dockstore script (i.e. tool launch ...)
 */
public static void main(String[] argv) {
    CommandMain commandMain = new CommandMain();

    CommandAdd commandAdd = new CommandAdd();
    CommandPublish commandPublish = new CommandPublish();

    JCommander jc = new JCommander(commandMain);

    jc.addCommand("add", commandAdd);
    jc.addCommand("publish", commandPublish);

    jc.setProgramName("client");
    try {
        jc.parse(argv);
    } catch (MissingCommandException e) {
        LOGGER.warn(e.getMessage());
        jc.usage();
    }
    if (commandMain.help) {
        jc.usage();
    } else {
        String command = jc.getParsedCommand();
        if (command == null) {
            LOGGER.warn("Expecting 'publish' or 'add' command");
            jc.usage();
            return;
        }
        switch (command) {
        case "add":
            if (commandAdd.help) {
                jc.usage("add");
            } else {
                Add add = new Add(commandMain.config);
                add.handleAdd(commandAdd.dockerfile, commandAdd.descriptor, commandAdd.secondaryDescriptor, commandAdd.version);
            }
            break;
        case "publish":
            if (commandPublish.help) {
                jc.usage("publish");
            } else {
                Publish publish = new Publish(commandMain.config);
                publish.handlePublish(commandPublish.tool);
            }
            break;
        default:
            // JCommander should've caught this, this should never execute
            LOGGER.warn("Unknown command");
            jc.usage();
        }
    }
}
 

import com.beust.jcommander.JCommander; //导入方法依赖的package包/类
@Override
public void afterPropertiesSet() throws Exception {
	String[] commandArgs = null;

	// check cli
	int commandPosition = Arrays.asList(args).indexOf(myBatisMigrationsProperties.getCliCommand());

	// found migration cli command?
	if (commandPosition >= 0) {
		// remove migration command from args
		commandArgs = Arrays.copyOfRange(args, commandPosition + 1, args.length);

		// show usage if migration called without arguments
		if (commandArgs.length == 0) {
			commandArgs = new String[]{"--help"};
		}
	}

	// check auto migration if no cli called
	if (commandArgs == null) {
		Collection<String> migrationCommand = myBatisMigrationsProperties.getMigrationCommand();
		commandArgs = migrationCommand.toArray(new String[migrationCommand.size()]);
	}

	if (commandArgs != null && commandArgs.length > 0) {
		Map<String, CommandBase> commands = new LinkedHashMap<>();

		commands.put("status", new CommandStatus(springMyBatisMigrations));
		commands.put("bootstrap", new CommandBootstrap(springMyBatisMigrations));
		commands.put("up", new CommandUp(springMyBatisMigrations));
		commands.put("pending", new CommandPending(springMyBatisMigrations));
		commands.put("version", new CommandVersion(springMyBatisMigrations));
		commands.put("down", new CommandDown(springMyBatisMigrations));

		CommandMain commandMain = new CommandMain();
		JCommander jCommander = new JCommander(commandMain);

		for (Entry<String, CommandBase> command : commands.entrySet()) {
			jCommander.addCommand(command.getKey(), command.getValue());
		}

		jCommander.parse(commandArgs);

		if (commandMain.isHelp()) {
			jCommander.usage();
			if (commandMain.isExit()) {
				exit();
			}
		}

		// action!
		commands.get(jCommander.getParsedCommand()).operate();

		if (commandMain.isExit()) {
			exit();
		}
	}
}