@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 protected boolean isRelevantClass(MetaClass clazz) { for (final Annotation anno : clazz.getAnnotations()) { if (anno.annotationType().equals(Remote.class) || anno.annotationType().equals(FeatureInterceptor.class) || anno.annotationType().equals(InterceptsRemoteCall.class)) { return true; } } return false; }
public ClassStructureBuilder<?> generate() { final String safeProxyClassName = remote.getFullyQualifiedName().replace('.', '_') + "Impl"; final ClassStructureBuilder<?> classBuilder = ClassBuilder.define(safeProxyClassName, AbstractRpcProxy.class) .packageScope() .implementsInterface(remote) .body(); for (final MetaMethod method : remote.getMethods()) { if (ProxyUtil.shouldProxyMethod(method)) { generateMethod(classBuilder, method); } } return classBuilder; }
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[] getErasedParamterTypes(final MetaMethod method) { final MetaClass[] paramTypes = new MetaClass[method.getParameters().length]; for (int i = 0; i < paramTypes.length; i++) { paramTypes[i] = method.getParameters()[i].getType().getErased(); } return paramTypes; }
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; } }
private MetaClass getValueType(final MetaClass type) { if (type.isAssignableTo(TakesValue.class)) { return type.getMethod("getValue", new Class[0]).getReturnType(); } else { return null; } }
@Override public String toString() { return toMap.getFullyQualifiedName() + "#" + field.getName(); } });
public static Class<?>[] asClassArray(final MetaType[] cls) { final Class<?>[] newClasses = new Class<?>[cls.length]; for (int i = 0; i < cls.length; i++) { if (cls[i] instanceof MetaParameterizedType) { newClasses[i] = ((MetaClass) ((MetaParameterizedType) cls[i]).getRawType()).asClass(); } else { newClasses[i] = ((MetaClass) cls[i]).asClass(); } } return newClasses; }
public static Class<?>[] asClassArray(final MetaParameter[] parms) { final MetaType[] type = new MetaType[parms.length]; for (int i = 0; i < parms.length; i++) { type[i] = parms[i].getType(); } return asClassArray(type); }
private MetaConstructor getAccessibleNoArgConstructor(final MetaClass type) { final MetaConstructor noArgConstr = type.getDeclaredConstructor(new MetaClass[0]); if (noArgConstr != null && (noArgConstr.isPublic() || noArgConstr.isProtected())) { return noArgConstr; } else { return null; } }
private static MetaClass createOrGet(final String fullyQualifiedClassName) { if (!getMetaClassCache().isKnownErasedType(fullyQualifiedClassName)) { return createOrGet(fullyQualifiedClassName, false); } return getMetaClassCache().getErased(fullyQualifiedClassName); }
if (remote.isInterface()) {
private boolean isParamOfNonPublicMethod(final HasAnnotations annotated) { if (!(annotated instanceof MetaParameter)) { return false; } final MetaClassMember member = ((MetaParameter) annotated).getDeclaringMember(); return member instanceof MetaMethod && !member.isPublic(); }
private MetaClass[] getErasedParamterTypes(final MetaMethod method) { final MetaClass[] paramTypes = new MetaClass[method.getParameters().length]; for (int i = 0; i < paramTypes.length; i++) { paramTypes[i] = method.getParameters()[i].getType().getErased(); } return paramTypes; }
private MetaClass getValueType(final MetaClass type) { if (type.isAssignableTo(TakesValue.class)) { return type.getMethod("getValue", new Class[0]).getReturnType(); } else { return null; } }
@Override public String toString() { return toMap.getFullyQualifiedName() + "#" + field.getName(); } });
public static Class<?>[] asClassArray(final MetaType[] cls) { final Class<?>[] newClasses = new Class<?>[cls.length]; for (int i = 0; i < cls.length; i++) { if (cls[i] instanceof MetaParameterizedType) { newClasses[i] = ((MetaClass) ((MetaParameterizedType) cls[i]).getRawType()).asClass(); } else { newClasses[i] = ((MetaClass) cls[i]).asClass(); } } return newClasses; }
public static Class<?>[] asClassArray(final MetaParameter[] parms) { final MetaType[] type = new MetaType[parms.length]; for (int i = 0; i < parms.length; i++) { type[i] = parms[i].getType(); } return asClassArray(type); }
private static MetaClass createOrGet(final String fullyQualifiedClassName) { if (!getMetaClassCache().isKnownErasedType(fullyQualifiedClassName)) { return createOrGet(fullyQualifiedClassName, false); } return getMetaClassCache().getErased(fullyQualifiedClassName); }