/**
* Invokes the underlying method represented by this {@code Method} object, on the specified
* object with the specified parameters. Individual parameters are automatically unwrapped to
* match primitive formal parameters, and both primitive and reference parameters are subject to
* method invocation conversions as necessary.
*
* <p>If the underlying method is static, then the specified {@code obj} argument is ignored. It
* may be null.
*
* <p>If the number of formal parameters required by the underlying method is 0, the supplied
* {@code args} array may be of length 0 or null.
*
* <p>If the underlying method is an instance method, it is invoked using dynamic method lookup as
* documented in The Java Language Specification, Second Edition, section 15.12.4.4; in
* particular, overriding based on the runtime type of the target object will occur.
*
* <p>If the underlying method is static, the class that declared the method is initialized if it
* has not already been initialized.
*
* <p>If the method completes normally, the value it returns is returned to the caller of invoke;
* if the value has a primitive type, it is first appropriately wrapped in an object. However, if
* the value has the type of an array of a primitive type, the elements of the array are
* <i>not</i> wrapped in objects; in other words, an array of primitive type is returned. If the
* underlying method return type is void, the invocation returns null.
*
* @param obj the object the underlying method is invoked from
* @param args the arguments used for the method call
* @return the result of dispatching the method represented by this object on {@code obj} with
* parameters {@code args}
* @exception IllegalAccessException if this {@code Method} object is enforcing Java language
* access control and the underlying method is inaccessible.
* @exception IllegalArgumentException if the method is an instance method and the specified
* object argument is not an instance of the class or interface declaring the underlying
* method (or of a subclass or implementor thereof); if the number of actual and formal
* parameters differ; if an unwrapping conversion for primitive arguments fails; or if, after
* possible unwrapping, a parameter value cannot be converted to the corresponding formal
* parameter type by a method invocation conversion.
* @exception InvocationTargetException if the underlying method throws an exception.
* @exception NullPointerException if the specified object is null and the method is an instance
* method.
* @exception ExceptionInInitializerError if the initialization provoked by this method fails.
*/
public Object invoke(Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class<?> caller = Reflection.getCallerClass(1);
checkAccess(caller, clazz, obj, modifiers);
}
}
MethodAccessor ma = methodAccessor; // read volatile
if (ma == null) {
ma = acquireMethodAccessor();
}
return ma.invoke(obj, args);
}
private static void executeCommand(SkypeMessage chat, CommandData data, Matcher m) {
if (data.getCommand().admin()) {
try {
if (!Arrays.asList(Resource.GROUP_ADMINS).contains(chat.getSender().getUsername())) {
Resource.sendMessage(chat, "Access Denied!");
return;
}
} catch (Exception ignored) {
return;
}
}
try {
if (data.getCommand().cooldown() > 0
&& !Arrays.asList(Resource.GROUP_ADMINS).contains(chat.getSender().getUsername())) {
if (!SkypeBot.getInstance().getCooldownHandler().canUse(data.getCommand())) {
return;
}
}
long difference = System.currentTimeMillis() - lastCommand;
if (difference <= 5000L) {
return;
}
} catch (Exception e) {
e.printStackTrace();
}
List<Object> a = new ArrayList<>();
a.add(chat);
if (m.groupCount() > 0) {
for (int i = 1; i <= m.groupCount(); i++) {
String g = m.group(i);
if (g.contains(".") && Utils.isDouble(g)) {
a.add(Double.parseDouble(g));
} else if (Utils.isInteger(g)) {
a.add(Integer.parseInt(g));
} else {
a.add(g);
}
}
}
if (a.size() < data.getMethod().getParameterCount()) {
for (int i = a.size(); i < data.getMethod().getParameterCount(); i++) {
if (data.getMethod().getParameters()[i].getType().equals(String.class)) {
a.add(null);
} else {
a.add(0);
}
}
}
MethodAccessor methodAccessor = null;
try {
Field methodAccessorField = Method.class.getDeclaredField("methodAccessor");
methodAccessorField.setAccessible(true);
methodAccessor = (MethodAccessor) methodAccessorField.get(data.getMethod());
if (methodAccessor == null) {
Method acquireMethodAccessorMethod =
Method.class.getDeclaredMethod("acquireMethodAccessor", null);
acquireMethodAccessorMethod.setAccessible(true);
methodAccessor =
(MethodAccessor) acquireMethodAccessorMethod.invoke(data.getMethod(), null);
lastCommand = System.currentTimeMillis();
}
} catch (NoSuchFieldException
| InvocationTargetException
| IllegalAccessException
| NoSuchMethodException e) {
Resource.sendMessage(chat, "Failed... (" + ExceptionUtils.getStackTrace(e) + ")");
}
try {
methodAccessor.invoke(null, a.toArray());
} catch (Exception e) {
Resource.sendMessage(
chat, "Failed... (" + Utils.upload(ExceptionUtils.getStackTrace(e)) + ")");
}
}