Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package se.ranzdo.bukkit.methodcommand;
  
  import java.util.HashMap;
  import java.util.List;
 import java.util.Map;
 import  org.bukkit.ChatColor;
 import  org.bukkit.command.CommandSender;
 
 
 public class RegisteredCommand {
 	private String label;
 	private String description;
 	private String[] permissions;
 	private boolean onlyPlayers;
 	private Method method;
 	private Object methodInstance;
 	
 	private boolean set = false;
 	
 	private ArrayList<Flagflags = new ArrayList<Flag>();
 	private Map<StringFlagflagsByName = new LinkedHashMap<StringFlag>();
 	
 	RegisteredCommand(String labelCommandHandler handlerRegisteredCommand parent) {
 		this. = label;
 		this. = handler;
 		this. = parent;
 	}
 	
 	void addSuffixCommand(String suffixRegisteredCommand command) {
 		.put(suffix.toLowerCase(), command);
 		.add(command);
 	}
 	
 	boolean doesSuffixCommandExist(String suffix) {
 		return .get(suffix) != null;
 	}
 	
 	void execute(CommandSender senderString[] args) {
 		if(!testPermission(sender)) {
 			sender.sendMessage(ChatColor.RED+"You do not have permission to do this!");
 			return;
 		}
 		
 		if(args.length > 0) {
 			String suffixLabel = args[0].toLowerCase();
 			if(suffixLabel.equals(.getHelpSuffix())) {
 				sendHelpMessage(sender);
 				return;
 			}
 			
 			RegisteredCommand command = .get(suffixLabel);
 			if(command == null) {
 				executeMethod(senderargs);
 			}
 			else {
 				String[] nargs = new String[args.length-1];
 				System.arraycopy(args, 1, nargs, 0, args.length-1);
 				command.execute(sendernargs);
 			}
 		}
 		else
 			executeMethod(senderargs);
 
 	}
 	
 	private void executeMethod(CommandSender senderString[] args) {
 		if(!) {
 			sendHelpMessage(sender);
 			return;
 		}
 		
 		ArrayList<ObjectresultArgs = new ArrayList<Object>();
 		resultArgs.add(sender);
 		
 		Arguments arguments;
 		try {
 			arguments = new Arguments(args);
 		} catch (CommandError e) {
 			sender.sendMessage(e.getColorizedMessage());
 			return;
 		}
 		
 		for(ExecutableArgument ea : this.) {
 			try {
 				resultArgs.add(ea.execute(senderarguments));
 			} catch (CommandError e) {
 				sender.sendMessage(e.getColorizedMessage());
				if(e.showUsage())
					sender.sendMessage(getUsage());
				return;
			}
		}
		try {
			try {
			}
				if(e.getCause() instanceof CommandError) {
					sender.sendMessage(ce.getColorizedMessage());
					if(ce.showUsage())
						sender.sendMessage(getUsage());
				}
				else
					throw e;
			}
catch (Exception e) {
			sender.sendMessage(ChatColor.RED+"An internal error occurred while attempting to perform this command.");
		}
	}
	private ArgumentHandler<?> getArgumenHandler(Class<?> argumentClass) {
		ArgumentHandler<?> argumentHandler = .getArgumentHandler(argumentClass);
		if(argumentHandler == null)
			throw new RegisterCommandMethodException("Could not find a ArgumentHandler for ("+argumentClass.getName()+")");
		return argumentHandler;
	}
		return ;
	}
	public String getDescription() {
		return ;
	}
	public List<FlaggetFlags() {
		return ;
	}
	public String[] getHelpMessage() {
	}
	public String getLabel() {
		return ;
	}
		return ;
	}
	public String[] getPermissions() {
		return ;
	}
		return .get(suffix);
	}
		return ;
	}
	public String getUsage() {
	}
		return ;
	}
	public boolean isOnlyPlayers() {
		return ;
	}
	public boolean isSet() {
		return ;
	}
	public boolean onlyPlayers() {
		return ;
	}
	public void sendHelpMessage(CommandSender sender) {
		sender.sendMessage(getHelpMessage());
	}
	void set(Object methodInstanceMethod method) {
		this. = methodInstance;
		this. = method;
		method.setAccessible(true);
		Command command = method.getAnnotation(Command.class);
		Flags flagsAnnotation = method.getAnnotation(Flags.class);
		this. = command.description();
		this. = command.permissions();
		this. = command.onlyPlayers();
		Class<?>[] methodParameters = method.getParameterTypes();
		if(methodParameters.length == 0 ? true : !CommandSender.class.isAssignableFrom(methodParameters[0]))
			throw new RegisterCommandMethodException(method"The first parameter in the command method must be assignable to the CommandSender interface.");
		if(flagsAnnotation != null) {
			String[] flags = flagsAnnotation.identifier();
			String[] flagdescriptions = flagsAnnotation.description();
			for(int i = 0; i < flags.lengthi++) {
				Flag flag = new Flag(flags[i], i < flagdescriptions.length ? flagdescriptions[i] : "");
				this..put(flags[i], flag);
				this..add(flag);
			}
		}
		Annotation[][] parameterAnnotations = method.getParameterAnnotations();
		for(int i = 1; i < methodParameters.length;i++) {
			//Find the CommandArgument annotation
			Arg commandArgAnnotation = null;
			for(Annotation annotation : parameterAnnotations[i]) {
				if(annotation.annotationType() == Arg.class)  {
					commandArgAnnotation = (Argannotation;
				}
			}
			//Find the FlagArg annotation
			FlagArg flagArgAnnotation = null;
			for(Annotation annotation : parameterAnnotations[i]) {
				if(annotation.annotationType() == FlagArg.class)  {
					flagArgAnnotation = (FlagArgannotation;
				}
			}
			//If neither does not exist throw
			if(commandArgAnnotation == null && flagArgAnnotation == null)
				throw new RegisterCommandMethodException(method"The command annonation is present on a method, however one of the parameters is not annotated.");
			Flag flag = null;
			if(flagArgAnnotation != null) {
				flag = this..get(flagArgAnnotation.value());
				if(flag == null)
					throw new RegisterCommandMethodException(method"The flag annonation is present on a parameter, however the flag is not defined in the flags annonation.");
			}
			Class<?> argumentClass = methodParameters[i];
			if(commandArgAnnotation == null) {
				if(argumentClass != boolean.class && argumentClass != Boolean.class)
					throw new RegisterCommandMethodException(method"The flag annonation is present on a parameter without the arg annonation, however the parameter type is not an boolean.");
				continue;
			}
			if(flagArgAnnotation == null) {
				CommandArgument argument;
				if(i == methodParameters.length-1) {
					//Find the Wildcard annotation
					Wildcard wildcard = null;
					for(Annotation annotation : parameterAnnotations[i]) {
						if(annotation.annotationType() == Wildcard.class)  {
							wildcard = (Wildcardannotation;
						}
					}
					if(wildcard != null) {
						boolean join = wildcard.join();
						if(!join) {
							argumentClass = argumentClass.getComponentType();
							if(argumentClass == null)
								throw new RegisterCommandMethodException(method"The wildcard argument needs to be an array if join is false.");
						}
						this. = new WildcardArgument(commandArgAnnotationargumentClassgetArgumenHandler(argumentClass), join);
						argument = this.;
					}
					else {
						argument = new CommandArgument(commandArgAnnotationargumentClassgetArgumenHandler(argumentClass));
						.add(argument);
					}
				}
				else {
					argument = new CommandArgument(commandArgAnnotationargumentClassgetArgumenHandler(argumentClass));
					.add(argument);
				}
			}
			else {
				FlagArgument argument = new FlagArgument(commandArgAnnotationargumentClassgetArgumenHandler(argumentClass), flag);
				flag.addArgument(argument);
			}
		}
		this. = true;
	}
	public boolean testPermission(CommandSender sender) {
		if(!)
			return true;
	}
New to GrepCode? Check out our FAQ X