/** * 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); } }
private ObjectBuilder createAnonymousImpl(final MetaClass type) { final AnonymousClassStructureBuilder builder = newObject(type).extend(); stream(type.getMethods()) .filter(m -> m.isPublic() && m.isAbstract()) .forEach(m -> { builder .publicOverridesMethod(m.getName(), of(m.getParameters())) .append(Stmt.throw_(RuntimeException.class)) .finish(); }); return builder.finish(); }
public String hashString() { if (_hashString != null) return _hashString; return _hashString = MetaMethod.class + ":" + getDeclaringClass().getFullyQualifiedName() + "." + getName() + "(" + Arrays.toString(getParameters()) + ")"; }
@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; } }
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(); }
final MetaClass handlerType = MetaClassFactory.get(EventListener.class); final BlockBuilder<AnonymousClassStructureBuilder> listenerBuilder = ObjectBuilder.newInstanceOf(handlerType) .extend() .publicOverridesMethod(handlerType.getMethods()[0].getName(), Parameter.of(eventType, "event")); listenerBuilder.append(InjectUtil.invokePublicOrPrivateMethod(controller, method, Stmt.loadVariable("event"))); final ObjectBuilder listenerInstance = listenerBuilder.finish().finish(); if (method.isAnnotationPresent(SinkNative.class)) { eventsToSink = method.getAnnotation(SinkNative.class).value(); if (dataFieldTypes.containsKey(name)) { final MetaClass dataFieldType = dataFieldTypes.get(name); final boolean gwtUserElement = dataFieldType.isAssignableTo(Element.class); final boolean nativeJsType = RebindUtil.isNativeJsType(dataFieldType); if (gwtUserElement || nativeJsType) { if (dataFieldType.isAssignableTo(HasValue.class)) { final MetaClass valueType = dataFieldType.getMethod("getValue", new Class[0]).getReturnType(); elementStmt = Stmt.castTo(ElementWrapperWidget.class, Stmt.nestedCall(fieldsMap).invoke("get", name, loadLiteral(valueType))); elementStmt = Stmt.castTo(ElementWrapperWidget.class, Stmt.nestedCall(fieldsMap).invoke("get", name)); throw new GenerationException("@DataField [" + name + "] of type [" + dataFieldType.getName() + "] in class [" + declaringClass.getFullyQualifiedName() + "] is not assignable to [" + Element.class.getName() + "] specified by @EventHandler method " + method.getName() + "(" + eventType.getName() + ")]\n");
for (final MetaMethod method : bindable.getMethods()) { final String methodName = method.getName(); && method.isPublic() && !method.isFinal() && !method.isStatic()) { parmVars.add(Stmt.loadVariable(parms[i].getName())); final MetaClass type = getTypeOrFirstUpperBound(method.getGenericParameterTypes()[i], method); if (type == null) return; parms[i] = Parameter.of(type, parms[i].getName()); final String returnValName = ensureSafeLocalVariableName("returnValue", method); final MetaClass returnType = getTypeOrFirstUpperBound(method.getGenericReturnType(), method); if (returnType == null) return; if (!returnType.equals(MetaClassFactory.get(void.class))) { callOnTarget = Stmt.declareFinalVariable(returnValName, returnType, target().invoke(method, parmVars.toArray())); returnValue = Stmt.nestedCall(Refs.get(returnValName)).returnValue(); callOnTarget = target().invoke(method, parmVars.toArray()); returnValue = EmptyStatement.INSTANCE;
if (!method.isStatic()) { wrapperDefParms.add(Parameter.of(method.getDeclaringClass().getErased(), "instance")); = classBuilder.publicMethod(method.getReturnType(), PrivateAccessUtil.getPrivateMethodName(method)) .parameters(DefParameters.fromParameters(wrapperDefParms)) .body(); final BlockBuilder<CatchBlockBuilder> tryBuilder = Stmt.try_(); final ContextualStatementBuilder statementBuilder = Stmt.loadVariable(cachedMethod) .invoke("invoke", method.isStatic() ? null : Refs.get("instance"), args); if (method.getReturnType().isVoid()) { tryBuilder._(statementBuilder); tryBuilder._(Stmt.castTo(method.getReturnType().asBoxed(), statementBuilder).returnValue()); body._(tryBuilder .finish() .catch_(Throwable.class, "e") ._(Stmt.loadVariable("e").invoke("printStackTrace")) ._(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish())
final MetaClass methodReturnType = resourceMethod.getMethod().getReturnType(); final Statement result; if (methodReturnType.equals(MetaClassFactory.get(void.class))) { result = load(null).returnValue(); else if (methodReturnType.isAssignableTo(javax.ws.rs.core.Response.class)) { result = loadVariable("response").returnValue(); loadVariable("response").invoke("getText"), resourceMethod.getAcceptHeader()); result = if_(Bool.equals(loadVariable("response").invoke("getStatusCode"), 204)) .append(load(null).returnValue()) .finish() .else_() .append(nestedCall(demarshalStmt).returnValue()) .finish();
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; } }
Attribute<?, ?> attr = (Attribute<?, ?>) sourceObject; String entityInstanceParam = method.getParameters()[0].getName(); String newValueParam = method.getParameters()[1].getName(); If.instanceOf(Stmt.loadVariable(entityInstanceParam), WrappedPortable.class) .append( Stmt.loadVariable(entityInstanceParam).assignValue( Stmt.castTo(WrappedPortable.class, Stmt.loadVariable(entityInstanceParam)).invoke("unwrap"))) .finish()); MetaField field = MetaClassFactory.get((Field) getJavaMember(attr)); Stmt.loadVariable("this") .invoke(PrivateAccessUtil.getPrivateFieldAccessorName(field), Stmt.castTo(et.getJavaType(), Stmt.loadVariable(entityInstanceParam)), Stmt.castTo(MetaClassFactory.get(attr.getJavaType()).asBoxed(), Stmt.loadVariable(newValueParam)))); return Stmt.castTo(et.getJavaType(), Stmt.loadVariable(entityInstanceParam)) .invoke(setterMethodName, Stmt.castTo(MetaClassFactory.get(attr.getJavaType()).asBoxed(), Stmt.loadVariable(newValueParam)));
private Collection<Statement> registerDeclarativeHandlers(final MetaClass bindable) { final List<MetaMethod> handlerMethods = bindable.getMethodsAnnotatedWith(org.jboss.errai.ui.shared.api.annotations.PropertyChangeHandler.class); if ( handlerMethods.isEmpty() ) return Collections.emptyList(); final List<Statement> retVal = new ArrayList<>(); for (final MetaMethod method : handlerMethods) { if (method.getParameters().length == 1 && method.getParameters()[0].getType().getFullyQualifiedName().equals(PropertyChangeEvent.class.getName())) { final String property = method.getAnnotation(org.jboss.errai.ui.shared.api.annotations.PropertyChangeHandler.class).value(); if (!property.isEmpty()) validateProperty(bindable, property); final Object handler = createHandlerForMethod(method); final ContextualStatementBuilder subStmt = (property.isEmpty() ? loadVariable("agent").invoke("addPropertyChangeHandler", handler): loadVariable("agent").invoke("addPropertyChangeHandler", property, handler)); retVal.add(subStmt); } else { throw new RuntimeException( String.format("The @ChangeHandler method [%s] must have exactly one argument of type %s.", method.getName(), PropertyChangeEvent.class.getSimpleName())); } } return retVal; }
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(); }
public static String methodAccess(final MetaMethod method) { final StringBuilder buf = new StringBuilder(50); if (!method.getReturnType().isVoid()) { buf.append("return "); } if (!method.isStatic()) { buf.append("instance."); } buf.append('@').append(method.getDeclaringClass().getFullyQualifiedName().replace('$', '.')) .append("::").append(method instanceof MetaConstructor ? "new" : method.getName()).append('('); for (final MetaParameter parm : method.getParameters()) { buf.append(parm.getType().getInternalName()); } buf.append(")("); final int length = method.getParameters().length; for (int i = 0; i < length; i++) { buf.append("a").append(i); if (i + 1 < length) buf.append(","); } buf.append(")"); return buf.toString(); } }
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 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 Statement coverterStatement(final Bound bound, final MetaClass boundType, final MetaClass propertyType) { if (bound.converter().equals(Bound.NO_CONVERTER.class)) { final Optional<MetaClass> valueType; if (boundType.isAssignableTo(TakesValue.class)) { valueType = Optional.ofNullable(boundType.getMethod("getValue", new Class[0]).getReturnType()); } else if (boundType.isAssignableTo(BindableListChangeHandler.class)) { valueType = Optional.ofNullable(MetaClassFactory.get(List.class)); } else { valueType = Optional.empty(); } return valueType .map(type -> invokeStatic(Convert.class, "getConverter", loadLiteral(propertyType), loadLiteral(type))) .orElse(loadLiteral(null)); } else { return Stmt.newObject(bound.converter()); } }
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(); }
@Override public void generateDecorator(final Decorable decorable, final FactoryController controller) { MetaMethod method = decorable.getAsMethod(); MetaParameter[] params = method.getParameters(); if (params.length != 1 || !params[0].getType().getErased().equals(MetaClassFactory.get(SyncResponses.class))) { throw new GenerationException("Methods annotated with @" + Sync.class.getName() + " need to have exactly one parameter of type: " + SyncResponses.class.getName() + ". Check method: " + GenUtil.getMethodString(method) + " in class " + method.getDeclaringClass().getFullyQualifiedName()); } Sync syncAnnotation = (Sync) decorable.getAnnotation(); controller.addInitializationStatements(createInitStatements(decorable.getDecorableDeclaringType(), "obj", syncAnnotation, decorable, controller)); final Statement syncWorker = controller.getReferenceStmt("syncWorker", ClientSyncWorker.class); final Statement destruction = Stmt.nestedCall(syncWorker).invoke("stop"); controller.addDestructionStatements(Collections.singletonList(destruction)); }
private void appendPageShowingMethod(AnonymousClassStructureBuilder pageImplBuilder, MetaClass pageClass) { BlockBuilder<?> method = pageImplBuilder.publicMethod(void.class, createMethodNameFromAnnotation(PageShowing.class), Parameter.of(pageClass, "widget"), Parameter.of(HistoryToken.class, "state"), Parameter.of(NavigationControl.class, "control")) .body(); MetaMethod pageShowMethod = appendPageShowMethod(method, pageImplBuilder, pageClass, PageShowing.class, true, Parameter.of(HistoryToken.class, "state"), Parameter.of(NavigationControl.class, "control")); /* * If the user did not provide a control parameter, we must proceed for them after the method is invoked. */ if (pageShowMethod == null || pageShowMethod.getParameters().length != 2) { method.append(Stmt.loadVariable("control").invoke("proceed")); } method.finish(); }