@Override public Collection<MetaClass> provideTypesToExpose() { final Set<MetaClass> types = new HashSet<MetaClass>(); for (final MetaClass metaClass : ClassScanner.getTypesAnnotatedWith(Remote.class)) { for (final MetaMethod method : metaClass.getDeclaredMethods()) { if (!method.getReturnType().isVoid()) { types.add(method.getReturnType().getErased()); } for (final MetaParameter parameter : method.getParameters()) { final MetaClass type = parameter.getType(); types.add(type.getErased()); final MetaParameterizedType parameterizedType = type.getParameterizedType(); if (parameterizedType != null) { for (final MetaType tp : parameterizedType.getTypeParameters()) { if (tp instanceof MetaClass) { types.add(((MetaClass) tp).getErased()); } } } } } } return types; } }
@Override public MetaClass getType(final HasAnnotations annotated) { return ((MetaMethod) annotated).getReturnType(); }
private void generateMethod(ClassStructureBuilder<?> classBuilder, MetaMethod method) { final List<Class<?>> interceptors = interceptorProvider.getInterceptors(remote, method); final boolean intercepted = !interceptors.isEmpty(); final Parameter[] parms = DefParameters.from(method).getParameters().toArray(new Parameter[0]); final Parameter[] finalParms = new Parameter[parms.length]; final List<Statement> parmVars = new ArrayList<Statement>(); for (int i = 0; i < parms.length; i++) { finalParms[i] = Parameter.of(parms[i].getType().getErased(), parms[i].getName(), true); parmVars.add(Stmt.loadVariable(parms[i].getName())); } final Statement parameters = (intercepted) ? new StringStatement("getParameters()", MetaClassFactory.get(Object[].class)) : Stmt.newArray(Object.class).initialize(parmVars.toArray()); final BlockBuilder<?> methodBlock = classBuilder.publicMethod(method.getReturnType().getErased(), method.getName(), finalParms); if (intercepted) { methodBlock.append(generateInterceptorLogic(classBuilder, method, generateRequest(classBuilder, method, parameters, true), parmVars, interceptors)); } else { methodBlock.append(generateRequest(classBuilder, method, parameters, false)); } final Statement returnStmt = ProxyUtil.generateProxyMethodReturnStatement(method); if (returnStmt != null) { methodBlock.append(returnStmt); } methodBlock.finish(); }
private MetaClass getProducedType(final MetaClassMember member) { if (member instanceof MetaField) { return ((MetaField) member).getType(); } else if (member instanceof MetaMethod) { return ((MetaMethod) member).getReturnType(); } else { throw new RuntimeException("Producer members must be fields or methods, but found " + member); } }
private Statement generateRequest(ClassStructureBuilder<?> classBuilder, MetaMethod method, Statement methodParams, boolean intercepted) { final Statement sendable = Stmt .invokeStatic(MessageBuilder.class, "createCall") .invoke("call", remote.getFullyQualifiedName()) .invoke("endpoint", ProxyUtil.createCallSignature(method), Stmt.loadClassMember("qualifiers"), methodParams) .invoke("respondTo", method.getReturnType().asBoxed(), Stmt.loadVariable("remoteCallback")) .invoke("errorsHandledBy", Stmt.loadVariable("errorCallback")); final BlockStatement requestBlock = new BlockStatement(); requestBlock.addStatement(Stmt.declareVariable("sendable", RemoteCallSendable.class, sendable)); requestBlock.addStatement(Stmt.loadStatic(classBuilder.getClassDefinition(), "this") .invoke("sendRequest", Variable.get("bus"), Variable.get("sendable"))); return requestBlock; } }
@Override public String toString() { final StringBuilder sb = new StringBuilder(); final Annotation[] annos = getAnnotations(); if (annos != null) { for (final Annotation anno : annos) { sb.append(anno.toString()).append(" "); } } sb.append(" ").append(GenUtil.scopeOf(this).getCanonicalName()).append(" ") .append(getReturnType()).append(" ") .append(getName()).append("(").append(Arrays.toString(getParameters())).append(")"); return sb.toString(); } }
@Override public String toString() { final StringBuilder sb = new StringBuilder(); final Annotation[] annos = getAnnotations(); if (annos != null) { for (final Annotation anno : annos) { sb.append(anno.toString()).append(" "); } } sb.append(" ").append(GenUtil.scopeOf(this).getCanonicalName()).append(" ") .append(getReturnType()).append(" ") .append(getName()).append("(").append(Arrays.toString(getParameters())).append(")"); return sb.toString(); } }
private MetaClass getValueType(final MetaClass type) { if (type.isAssignableTo(TakesValue.class)) { return type.getMethod("getValue", new Class[0]).getReturnType(); } else { return null; } }
private MetaClass getValueType(final MetaClass type) { if (type.isAssignableTo(TakesValue.class)) { return type.getMethod("getValue", new Class[0]).getReturnType(); } else { return null; } }
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 boolean typesInSignatureAreVisible(final MetaMethod method) { if (!isVisibleType(method.getReturnType())) { return false; } for (final MetaParameter param : method.getParameters()) { if (!isVisibleType(param.getType())) { return false; } } return true; }
@Override public MetaClass getPropertyType(final String propertyName) { final MetaMethod readMethod = getReadMethodForProperty(propertyName); if (readMethod != null) { return readMethod.getReturnType(); } return getWriteMethodForProperty(propertyName).getParameters()[0].getType(); } };
@Override public MetaClass getPropertyType(final String propertyName) { final MetaMethod readMethod = getReadMethodForProperty(propertyName); if (readMethod != null) { return readMethod.getReturnType(); } return getWriteMethodForProperty(propertyName).getParameters()[0].getType(); } };
private void addContextualProviderInjectable(final Injectable providerInjectable, final DependencyGraphBuilder builder, final boolean enabled) { final MetaClass providerImpl = providerInjectable.getInjectedType(); final MetaMethod providerMethod = providerImpl.getMethod("provide", Class[].class, Annotation[].class); // Do not get generic return type for contextual providers final MetaClass providedType = providerMethod.getReturnType(); final InjectableType injectableType = (enabled ? InjectableType.ContextualProvider : InjectableType.Disabled); final Injectable providedInjectable = builder.addInjectable(providedType, qualFactory.forUniversallyQualified(), EXACT_TYPE, Dependent.class, injectableType, WiringElementType.Provider, WiringElementType.DependentBean); builder.addProducerMemberDependency(providedInjectable, providerImpl, providerInjectable.getQualifier(), providerMethod); }
@Test public void testMethodObjectReturnType() { final MetaClass c = getMetaClass(ClassWithGenericMethods.class); final MetaMethod method = c.getMethod("methodReturningObject", new Class[] {}); assertEquals("java.lang.Object", method.getReturnType().getFullyQualifiedNameWithTypeParms()); assertEquals(getTypeOfMetaClassBeingTested(), method.getReturnType().getClass()); // the generic return type should be the same: plain old Object assertEquals(getMetaClass(Object.class), method.getGenericReturnType()); }
private ObjectBuilder createAnnoImpl(final MetaClass annoType) { final AnonymousClassStructureBuilder builder = ObjectBuilder.newInstanceOf(annoType).extend(); Arrays.stream(annoType.getDeclaredMethods()) .forEach(m -> builder.publicOverridesMethod(m.getName()) .append(castTo(m.getReturnType(), loadVariable("parameters").invoke("get", m.getName())).returnValue()).finish()); builder.publicOverridesMethod("annotationType").append(loadLiteral(annoType).returnValue()).finish(); return builder.finish(); }
/** * Generates a getter method for the provided property plus the corresponding code for the * implementation of {@link HasProperties#get(String)}. */ private void generateGetter(final ClassStructureBuilder<?> classBuilder, final String property, final CaseBlockBuilder switchBlock) { final MetaMethod getterMethod = bindable.getBeanDescriptor().getReadMethodForProperty(property); if (getterMethod != null && !getterMethod.isFinal() && getterMethod.isPublic()) { BlockBuilder<CaseBlockBuilder> caseBlock = switchBlock.case_(property); caseBlock.append(Stmt.loadVariable("this").invoke(getterMethod.getName()).returnValue()).finish(); classBuilder.publicMethod(getterMethod.getReturnType(), getterMethod.getName()) .append(target().invoke(getterMethod.getName()).returnValue()) .finish(); proxiedAccessorMethods.add(getterMethod); } }
@Test public void parameterizedTypeIsAssignableToSameTypeWithWildcard() throws Exception { final MetaClass parameterized = parameterizedAs(Collection.class, typeParametersOf(Integer.class)); final MetaClass wildcard = MetaClassFactory.get(WildcardMethod.class).getMethod("method", new Class[0]).getReturnType(); assertTrue(GraphUtil.hasAssignableTypeParameters(parameterized, wildcard)); }
private static Object createAccessorImpl(final MetaClass type, final String varName) { final MetaClass propertyType = type.getMethod("getValue", new Class[0]).getReturnType(); return ObjectBuilder.newInstanceOf(NativeHasValueAccessors.Accessor.class) .extend() .publicMethod(Object.class, "get") .append(loadVariable(varName).invoke("getValue").returnValue()) .finish() .publicMethod(void.class, "set", finalOf(Object.class, "value")) .append(loadVariable(varName).invoke("setValue", castTo(propertyType, loadVariable("value")))) .finish() .finish(); } }
private static Object createAccessorImpl(final MetaClass type, final String varName) { final MetaClass propertyType = type.getMethod("getValue", new Class[0]).getReturnType(); return ObjectBuilder.newInstanceOf(NativeHasValueAccessors.Accessor.class) .extend() .publicMethod(Object.class, "get") .append(loadVariable(varName).invoke("getValue").returnValue()) .finish() .publicMethod(void.class, "set", finalOf(Object.class, "value")) .append(loadVariable(varName).invoke("setValue", castTo(propertyType, loadVariable("value")))) .finish() .finish(); } }