* Executes commands. The commands have to implement the {@link Command} interface and be in * packages registered using addCommandPackage(). Additionally, default commands are implemented in * the de.ugoe.cs.util.console.defaultcommands package. *
** This class is implemented as a Singleton. *
* * @author Steffen Herbold * @version 1.0 */ public class CommandExecuter { /** ** Handle of the CommandExecuter instance. *
*/ private final static CommandExecuter theInstance = new CommandExecuter(); /** ** Prefix of all command classes. *
*/ private static final String cmdPrefix = "CMD"; /** ** Name of the package for default commands. *
*/ private static final String defaultPackage = "de.ugoe.cs.util.console.defaultcommands"; /** ** List of packages in which commands may be defined. The exec methods trys to load command from * these packages in the order they have been added. *
** The de.ugoe.cs.util.console.defaultcommands package has always lowest priority, unless it is * specifically added. *
*/ private List* the list of available commands (lazy instantiation in the method * {@link #getAvailableCommands()}) *
*/ private Command[] availableCommands; /** *
* Returns the instance of CommandExecuter. If no instances exists yet, a new one is created. *
* * @return the instance of CommandExecuter */ public static synchronized CommandExecuter getInstance() { return theInstance; } /** ** Creates a new CommandExecuter. Private to prevent multiple instances (Singleton). *
*/ private CommandExecuter() { commandPackageList = new ArrayList* Adds a package that will be used by {@link #exec(String)} to load command from. *
* * @param pkg * package where commands are located * @throws IllegalArgumentException * thrown if the package name is null or empty string */ public void addCommandPackage(String pkg, ClassLoader loader) { if ("".equals(pkg) || pkg == null) { throw new IllegalArgumentException("package name must not be null or empty string"); } commandPackageList.add(new CommandPackage(pkg, loader)); availableCommands = null; } /** ** Executes the command defined by string. A command has the following form (mix of EBNF and * natural language): *
*
* <command> := <commandname><whitespace>{<parameter>}
* <commandname> := String without whitespaces. Has to be a valid Java class name
* <parameter> := <string>|<stringarray>
* <string> := <stringwithoutwhitespaces>|<stringwithwhitespaces>
* <stringwithoutwhitespaces> := a string without whitespaces
* <stringwithoutwhitespaces> := a string, that can have whitespaces, but must be in double quotes
* <stringarray> := "["<string>{<whitespace><string>"]"
*
*
* @param command
* the command as a string
*/
public void exec(String command) {
Console.commandNotification(command);
CommandParser parser = new CommandParser();
parser.parse(command);
Command cmd = getCMD(parser.getCommandName());
if (cmd == null) {
Console.println("Unknown command");
}
else {
try {
cmd.run(parser.getParameters());
}
catch (IllegalArgumentException e) {
Console.println("invalid parameter provided: " + e.getMessage());
Console.println("Usage: " + cmd.help());
}
catch (Exception e) {
Console.println("error executing command: " + e);
Console.logException(e);
Console.println("Usage: " + cmd.help());
}
}
}
/**
* * Helper method that loads a class and tries to cast it to {@link Command}. *
* * @param className * qualified name of the class (including package name) * @return if class is available and implement {@link Command} and instance of the class, null * otherwise */ public Command getCMD(String commandName) { for (Command candidate : getAvailableCommands()) { if (candidate.getClass().getSimpleName().equals(cmdPrefix + commandName)) { return candidate; } } return null; } /** ** reads all available commands from the registered command packages and returns a list of their * names *
* * @return an array containing the names of the available commands. */ public Command[] getAvailableCommands() { if (availableCommands == null) { // List* Get a copy of the currently registered command packages. *
* * @return currently registered command packages */ public List* this method method performs an auto completion of the provided String as far as possible * regarding the available commands. It auto completes to the full command name, if only one * command matches the given prefix. It auto completes to the common denominator, if several * commands match the prefix *
* * @param commandPrefix * the prefix to be auto completed * * @return as described */ public String autoCompleteCommand(String commandPrefix) { Command[] commands = getAvailableCommands(); String[] completions = new String[commands.length]; for (int i = 0; i < commands.length; i++) { completions[i] = commands[i].getClass().getSimpleName().substring(3); } return StringTools.autocomplete(commandPrefix, completions); } /** * represents a command package with a package name and the class loader to use */ private class CommandPackage { /** * the name of the represented package */ private String packageName; /** * the class loader to use to load the package */ private ClassLoader classLoader; /** ** instantiate the fields *
*/ public CommandPackage(String packageName, ClassLoader classLoader) { super(); this.packageName = packageName; this.classLoader = classLoader; } /** * @return the packageName */ public String getPackageName() { return packageName; } /** * @return the classLoader */ public ClassLoader getClassLoader() { return classLoader; } } }