@Override public MetaClass getEnclosingType(final HasAnnotations annotated) { return ((MetaMethod) annotated).getDeclaringClass(); }
private static void filterResultsMethod(final Collection<MetaMethod> result, final Set<String> packages, final String excludeRegEx) { final Pattern excludePattern; if (excludeRegEx != null) { excludePattern = Pattern.compile(excludeRegEx); } else { excludePattern = null; } final Iterator<MetaMethod> filterIterator = result.iterator(); while (filterIterator.hasNext()) { _removeIfNotMatches(filterIterator, filterIterator.next().getDeclaringClass(), packages, excludePattern); } }
private static void filterResultsMethod(final Collection<MetaMethod> result, final Set<String> packages, final String excludeRegEx) { final Pattern excludePattern; if (excludeRegEx != null) { excludePattern = Pattern.compile(excludeRegEx); } else { excludePattern = null; } final Iterator<MetaMethod> filterIterator = result.iterator(); while (filterIterator.hasNext()) { _removeIfNotMatches(filterIterator, filterIterator.next().getDeclaringClass(), packages, excludePattern); } }
public String hashString() { if (_hashString != null) return _hashString; return _hashString = MetaMethod.class + ":" + getDeclaringClass().getFullyQualifiedName() + "." + getName() + "(" + Arrays.toString(getParameters()) + ")"; }
public String hashString() { if (_hashString != null) return _hashString; return _hashString = MetaMethod.class + ":" + getDeclaringClass().getFullyQualifiedName() + "." + getName() + "(" + Arrays.toString(getParameters()) + ")"; }
public static boolean equals(final MetaMethod a, final MetaMethod b) { if (!a.getName().equals(b.getName())) return false; if (a.getParameters().length != b.getParameters().length) return false; if (!a.getDeclaringClass().equals(b.getDeclaringClass())) return false; for (int i = 0; i < a.getParameters().length; i++) { if (!equals(a.getParameters()[i], b.getParameters()[i])) return false; } return true; }
public static boolean equals(final MetaMethod a, final MetaMethod b) { if (!a.getName().equals(b.getName())) return false; if (a.getParameters().length != b.getParameters().length) return false; if (!a.getDeclaringClass().equals(b.getDeclaringClass())) return false; for (int i = 0; i < a.getParameters().length; i++) { if (!equals(a.getParameters()[i], b.getParameters()[i])) return false; } return true; }
private MetaMethod validateExceptionHandlingMethod(final Decorable decorable) { // Ensure that method has exactly one parameter of type Throwable final MetaMethod method = decorable.getAsMethod(); final MetaParameter[] parms = method.getParameters(); if (!(parms.length == 1 && parms[0].getType().equals(MetaClassFactory.get(Throwable.class)))) { throw new GenerationException("Methods annotated with " + UncaughtExceptionHandler.class.getName() + " must have exactly one parameter of type " + Throwable.class.getName() + ". Invalid parameters in method: " + GenUtil.getMethodString(method) + " of type " + method.getDeclaringClass() + "."); } return method; }
private Set<Class<?>> extractValidatableBeans(final Set<MetaClass> beans, final GeneratorContext context) { final Set<Class<?>> allBeans = new HashSet<Class<?>>(); for (final MetaClass bean : beans) { allBeans.add(bean.asClass()); } for (final MetaField field : ClassScanner.getFieldsAnnotatedWith(Valid.class, null, context)) { allBeans.add(field.getDeclaringClass().asClass()); allBeans.add(field.getType().asClass()); } for (final MetaMethod method : ClassScanner.getMethodsAnnotatedWith(Valid.class, null, context)) { allBeans.add(method.getDeclaringClass().asClass()); allBeans.add(method.getReturnType().asClass()); } return allBeans; }
private void addDisposerDependencies(final Injectable producedInjectable, final MetaMethod disposer, final DependencyGraphBuilder builder) { for (final MetaParameter param : disposer.getParameters()) { if (param.isAnnotationPresent(Disposes.class)) { builder.addDisposesMethodDependency(producedInjectable, disposer.getDeclaringClass(), qualFactory.forSink(disposer.getDeclaringClass()), disposer); } else { builder.addDisposesParamDependency(producedInjectable, param.getType(), qualFactory.forSink(param), param.getIndex(), param); } } }
private boolean shouldProxyMethod(final MetaMethod method, final Multimap<String, MetaMethod> proxiedMethodsByName) { return (method.getDeclaringClass() != null && method.getDeclaringClass().isInterface()) || !method.isStatic() && (method.isPublic() || method.isProtected()) && !method.isFinal() && methodIsNotFromObjectUnlessHashCode(method) && typesInSignatureAreVisible(method) && isNotAlreadyProxied(method, proxiedMethodsByName); }
static MetaMethod getOverridenMethod(final MetaMethod specializingMethod) { final MetaClass[] producerParams = GraphUtil.getParameterTypes(specializingMethod); MetaClass enclosingType = specializingMethod.getDeclaringClass(); MetaMethod specializedMethod = null; while (specializedMethod == null && enclosingType.getSuperClass() != null) { enclosingType = enclosingType.getSuperClass(); specializedMethod = enclosingType.getDeclaredMethod(specializingMethod.getName(), producerParams); } return specializedMethod; }
public static String getPrivateMethodName(final MetaMethod method) { final MetaClass declaringClass = method.getDeclaringClass(); String name = declaringClass.getName() + "_" + method.getName(); if (method.getParameters() != null) { for (final MetaParameter p : method.getParameters()) { name += "_" + getTypeName(p.getType()); } } return name; }
public static String getPrivateMethodName(final MetaMethod method) { final MetaClass declaringClass = method.getDeclaringClass(); String name = declaringClass.getName() + "_" + method.getName(); if (method.getParameters() != null) { for (final MetaParameter p : method.getParameters()) { name += "_" + getTypeName(p.getType()); } } return name; }
@Override public ContextualStatementBuilder call(final Statement instance, final HasAnnotations annotated, final BuildMetaClass factory, final Statement... statement) { final MetaMethod method = (MetaMethod) annotated; if (method.isPublic()) { if (method.isStatic()) { return invokeStatic(method.getDeclaringClass(), method.getName(), (Object[]) statement); } else { return nestedCall(instance).invoke(method, (Object[]) statement); } } else { final Object[] params = getParams(method.isStatic(), instance, statement); return invokeStatic(notNull(factory), getPrivateMethodName(method), params); } }
public static String initCachedMethod(final ClassStructureBuilder<?> classBuilder, final MetaMethod m) { createJavaReflectionMethodInitializerUtilMethod(classBuilder); final String fieldName = PrivateAccessUtil.getPrivateMethodName(m) + "_meth"; classBuilder.privateField(fieldName, Method.class).modifiers(Modifier.Static) .initializesWith(Stmt.invokeStatic(classBuilder.getClassDefinition(), JAVA_REFL_METH_UTIL_METH, m.getDeclaringClass(), m.getName(), MetaClassFactory.asClassArray(m.getParameters()))).finish(); return fieldName; }
public static String initCachedMethod(final ClassStructureBuilder<?> classBuilder, final MetaMethod m) { createJavaReflectionMethodInitializerUtilMethod(classBuilder); final String fieldName = PrivateAccessUtil.getPrivateMethodName(m) + "_meth"; classBuilder.privateField(fieldName, Method.class).modifiers(Modifier.Static) .initializesWith(Stmt.invokeStatic(classBuilder.getClassDefinition(), JAVA_REFL_METH_UTIL_METH, m.getDeclaringClass(), m.getName(), MetaClassFactory.asClassArray(m.getParameters()))).finish(); return fieldName; }
private Object createHandlerForMethod(final MetaMethod method) { return ObjectBuilder .newInstanceOf(PropertyChangeHandler.class) .extend() .publicOverridesMethod("onPropertyChange", finalOf(PropertyChangeEvent.class, "event")) .append(castTo(method.getDeclaringClass(), loadVariable("agent").loadField("target")).invoke(method, loadVariable("event"))) .finish() .finish(); }
private Object createHandlerForMethod(final MetaMethod method) { return ObjectBuilder .newInstanceOf(PropertyChangeHandler.class) .extend() .publicOverridesMethod("onPropertyChange", finalOf(PropertyChangeEvent.class, "event")) .append(castTo(method.getDeclaringClass(), loadVariable("agent").loadField("target")).invoke(method, loadVariable("event"))) .finish() .finish(); }
private static ObjectBuilder anonymousAttributeAccessorFor(final MetaMethod attr) { return newInstanceOf(Function.class).extend() .publicOverridesMethod("apply", Parameter.finalOf(Object.class, "anno")) .append(invokeStatic(SharedAnnotationSerializer.class, "stringify", castTo(attr.getDeclaringClass(), loadVariable("anno")).invoke(attr)) .returnValue()) .finish().finish(); }