private static boolean isValidExactMethod(Class[] arguments, CachedClass[] pt) { // lets check the parameter types match int size = pt.length; for (int i = 0; i < size; i++) { if (!pt[i].isAssignableFrom(arguments[i])) { return false; } } return true; }
public boolean isValidExactMethod(Object[] args) { // lets check the parameter types match getParametersTypes0(); int size = args.length; if (size != parameterTypes.length) return false; for (int i = 0; i < size; i++) { if (args[i] != null && !parameterTypes[i].isAssignableFrom(args[i].getClass())) { return false; } } return true; }
public boolean isValidExactMethod(Class[] args) { // lets check the parameter types match getParametersTypes0(); int size = args.length; if (size != parameterTypes.length) return false; for (int i = 0; i < size; i++) { if (args[i] != null && !parameterTypes[i].isAssignableFrom(args[i])) { return false; } } return true; }
private static boolean isValidVarargsMethod(Class[] arguments, int size, CachedClass[] pt, int paramMinus1) { // first check normal number of parameters for (int i = 0; i < paramMinus1; i++) { if (pt[i].isAssignableFrom(arguments[i])) continue; return false; } // check direct match CachedClass varg = pt[paramMinus1]; Class clazz = varg.getTheClass().getComponentType(); if (size == pt.length && (varg.isAssignableFrom(arguments[paramMinus1]) || testComponentAssignable(clazz, arguments[paramMinus1]))) { return true; } // check varged for (int i = paramMinus1; i < size; i++) { if (MetaClassHelper.isAssignableFrom(clazz, arguments[i])) continue; return false; } return true; }
if (paramTypes[i].isAssignableFrom(getArgClass(arguments[i]))) continue; return false; Class clazz = varg.getTheClass().getComponentType(); if (size == paramTypes.length && (varg.isAssignableFrom(getArgClass(arguments[paramMinus1])) || testComponentAssignable(clazz, getArgClass(arguments[paramMinus1])))) { return true; if (paramTypes[i].isAssignableFrom(getArgClass(arguments[i]))) continue; return false;
private static void staticMethod(final MetaClass self, List<MetaMethod> arr, final CachedMethod method) { CachedClass[] paramTypes = method.getParameterTypes(); if (paramTypes.length == 0) return; NewInstanceMetaMethod metaMethod; if (paramTypes[0].isAssignableFrom(self.getTheClass())) { if (paramTypes[0].getTheClass() == self.getTheClass()) metaMethod = new NewInstanceMetaMethod(method); else metaMethod = new NewInstanceMetaMethod(method) { public CachedClass getDeclaringClass() { return ReflectionCache.getCachedClass(self.getTheClass()); } }; arr.add(metaMethod); } else { if (self.getTheClass().isAssignableFrom(paramTypes[0].getTheClass())) { metaMethod = new NewInstanceMetaMethod(method); arr.add(metaMethod); } } }
if (!parameters[noVargsLength].isAssignableFrom(arguments[noVargsLength])) {
if (metaMethod.getDeclaringClass().isAssignableFrom(selfClass)) mc.registerInstanceMethod(metaMethod); else {
return method; } else if (!methodC.isAssignableFrom(matchC.getTheClass())) { return method; list.set(found, method); } else if (!methodC.isAssignableFrom(matchC.getTheClass())) { list.set(found, method);
private boolean isValidExactMethod(Class[] arguments, int size, CachedClass[] pt) { // lets check the parameter types match for (int i = 0; i < size; i++) { if (pt[i].isAssignableFrom(arguments[i])) continue; return false; } return true; }
private boolean isValidExactMethod(Class[] arguments, CachedClass[] pt) { // lets check the parameter types match int size = pt.length; for (int i = 0; i < size; i++) { if (!pt[i].isAssignableFrom(arguments[i])) { return false; } } return true; }
private boolean isValidExactMethod(Class[] arguments, CachedClass[] pt) { // lets check the parameter types match int size = pt.length; for (int i = 0; i < size; i++) { if (!pt[i].isAssignableFrom(arguments[i])) { return false; } } return true; }
private boolean isValidExactMethod(Class[] arguments, CachedClass[] pt) { // lets check the parameter types match int size = pt.length; for (int i = 0; i < size; i++) { if (!pt[i].isAssignableFrom(arguments[i])) { return false; } } return true; }
public boolean isValidExactMethod(Object [] args) { // lets check the parameter types match getParametersTypes0(); int size = args.length; if (size != parameterTypes.length) return false; for (int i = 0; i < size; i++) { if (args[i] != null && !parameterTypes[i].isAssignableFrom(args[i].getClass())) { return false; } } return true; }
public boolean isValidExactMethod(Object [] args) { // lets check the parameter types match getParametersTypes0(); int size = args.length; if (size != parameterTypes.length) return false; for (int i = 0; i < size; i++) { if (args[i] != null && !parameterTypes[i].isAssignableFrom(args[i].getClass())) { return false; } } return true; }
public boolean isValidExactMethod(Class [] args) { // lets check the parameter types match getParametersTypes0(); int size = args.length; if (size != parameterTypes.length) return false; for (int i = 0; i < size; i++) { if (args[i] != null && !parameterTypes[i].isAssignableFrom(args[i])) { return false; } } return true; }
public boolean isValidExactMethod(Object [] args) { // lets check the parameter types match getParametersTypes0(); int size = args.length; if (size != parameterTypes.length) return false; for (int i = 0; i < size; i++) { if (args[i] != null && !parameterTypes[i].isAssignableFrom(args[i].getClass())) { return false; } } return true; }
public boolean isValidExactMethod(Class [] args) { // lets check the parameter types match getParametersTypes0(); int size = args.length; if (size != parameterTypes.length) return false; for (int i = 0; i < size; i++) { if (args[i] != null && !parameterTypes[i].isAssignableFrom(args[i])) { return false; } } return true; }
public boolean isValidExactMethod(Class [] args) { // lets check the parameter types match getParametersTypes0(); int size = args.length; if (size != parameterTypes.length) return false; for (int i = 0; i < size; i++) { if (args[i] != null && !parameterTypes[i].isAssignableFrom(args[i])) { return false; } } return true; }
/** * Are we trying to invoke a method defined on Closure or its super type? * (If so, we'll need to chase down which method we are actually invoking.) * * <p> * Used for invokeMethod/getProperty/setProperty. * * <p> * If the receiver overrides this method, return false since we don't know how such methods behave. */ private static boolean isInvokingMethodOnClosure(Object receiver, String method, Object... args) { if (receiver instanceof Closure) { MetaMethod m = getMetaClass(receiver).pickMethod(method, convertToTypeArray(args)); if (m!=null && m.getDeclaringClass().isAssignableFrom(Closure.class)) return true; } return false; }