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(); }
@Override public Statement deferred(final MetaClass type, final MetaClass marshaller) { return Stmt.newObject(parameterizedAs(DeferredMarshallerCreationCallback.class, typeParametersOf(type))) .extend() .publicOverridesMethod("create", Parameter.of(Class.class, "type")) .append( Stmt.nestedCall( Stmt.newObject(QualifyingMarshallerWrapper.class, Stmt.castTo(Marshaller.class, Stmt.invokeStatic(GWT.class, "create", marshaller)), type)) .returnValue()) .finish() .finish(); } }
private Collection<MetaClass> findRelevantClasses(final IOCProcessingContext processingContext) { final Collection<MetaClass> allMetaClasses = new HashSet<>(); allMetaClasses.addAll(MetaClassFactory.getAllCachedClasses()); allMetaClasses.remove(MetaClassFactory.get(Object.class)); return allMetaClasses; }
@Override public MethodCommentBuilder<T> privateMethod(final Class<?> returnType, final String name, final Class<?>... parms) { return privateMethod(MetaClassFactory.get(returnType), name, MetaClassFactory.fromClassArray(parms)); }
@Override public MethodCommentBuilder<T> packageMethod(final Class<?> returnType, final String name, final Class<?>... parms) { return packageMethod(MetaClassFactory.get(returnType), name, MetaClassFactory.fromClassArray(parms)); }
public static boolean hasAnyChanges() { return !getAllNewOrUpdatedClasses().isEmpty() || !getAllDeletedClasses().isEmpty(); } }
.append(Stmt.declareVariable("commandType", String.class, Stmt.loadVariable("message").invoke("getCommandType"))) .append(Stmt.declareVariable("methodParms", List.class, Stmt.loadVariable("message").invoke("get", List.class, Stmt.loadLiteral("MethodParms")))); final MetaClass mc = MetaClassFactory.get(intf); for (final MetaMethod method : mc.getMethods()) { if (ProxyUtil.isMethodInInterface(mc, method) && ProxyUtil.shouldProxyMethod(method)) { final MetaClass[] parameterTypes = Arrays.stream(method.getParameters()).map(p -> p.getType()).toArray(MetaClass[]::new); final Statement[] objects = new Statement[parameterTypes.length]; final BlockBuilder<ElseBlockBuilder> blockBuilder = If .cond(Stmt.loadLiteral(ProxyUtil.createCallSignature(method)).invoke("equals", Stmt.loadVariable("commandType"))); blockBuilder.append(Stmt.declareFinalVariable("instance", intf, controller.contextGetInstanceStmt())); objects[i] = Stmt.castTo(parameterType, Stmt.loadVariable("methodParms").invoke("get", i)); final boolean hasReturnType = !method.getReturnType().isVoid(); final Statement methodInvocation = Stmt.nestedCall(Stmt.loadVariable("instance")).invoke(method.getName(), (Object[]) objects); final Statement invocation = (hasReturnType) ? Stmt.declareFinalVariable("ret", method.getReturnType(), methodInvocation) : methodInvocation; final Statement maybeDestroy = (decorable.isEnclosingTypeDependent()) ? Stmt.loadVariable("context").invoke("destroyInstance", Refs.get("instance")) : EmptyStatement.INSTANCE; final Statement sendResponse = (hasReturnType) ? Stmt.invokeStatic(MessageBuilder.class, "createConversation", Stmt.loadVariable("message")) .invoke("subjectProvided").invoke("with", "MethodReply", Refs.get("ret")) .invoke("noErrorHandling").invoke("sendNowWith", Stmt.invokeStatic(ErraiBus.class, "get")) : EmptyStatement.INSTANCE;
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(); "Cannot specify more than one @EventHandler method when @SyncNative is used for data-field [" + name + "] in class [" + declaringClass.getFullyQualifiedName() + "]."); 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)); elementStmt = Stmt.loadVariable(dataFieldElementsVarName).invoke("get", name);
.define("Dynamic" + fullyQualifiedClassNameToCamelCase(validator.getFullyQualifiedName()), validator) .publicScope() .implementsInterface(parameterizedAs(GeneratedDynamicValidator.class, typeParametersOf(valueType))) .body(); .publicMethod(parameterizedAs(Set.class, typeParametersOf(ConstraintViolation.class)), "validate", finalOf(parameterizedAs(Map.class, typeParametersOf(String.class, Object.class)), "parameters"), finalOf(valueType, "value")) .body(); return loadVariable("dynamicValidator").invoke("addValidator", loadLiteral(annoType.getFullyQualifiedName()), loadLiteral(valueType.getFullyQualifiedName()), newObject(generatedValidatorBuilder.getClassDefinition()));
private BlockBuilder<AnonymousClassStructureBuilder> getJsTypeSubscriptionCallback(final Decorable decorable, final FactoryController controller) { final MetaParameter parm = decorable.getAsParameter(); final MetaClass eventType = parm.getType().asBoxed(); final String parmClassName = eventType.getFullyQualifiedName(); final MetaClass callBackType = parameterizedAs(JsTypeEventObserver.class, typeParametersOf(eventType)); final AnonymousClassStructureBuilder callBack = Stmt.newObject(callBackType).extend(); BlockBuilder<AnonymousClassStructureBuilder> callBackBlock; final List<Statement> fireEventStmts = new ArrayList<>(); if (!decorable.isEnclosingTypeDependent()) { fireEventStmts.add(Stmt.declareFinalVariable("instance", decorable.getEnclosingInjectable().getInjectedType(), Stmt.invokeStatic(Factory.class, "maybeUnwrapProxy", controller.contextGetInstanceStmt()))); } fireEventStmts.add(decorable.call(Refs.get("event"))); callBackBlock = callBack.publicOverridesMethod("onEvent", Parameter.finalOf(eventType, "event")) .appendAll(fireEventStmts) .finish() .publicOverridesMethod("toString") ._(Stmt.load("JsTypeObserver: " + parmClassName).returnValue()); return callBackBlock; } }
private static void bindHandlingMethod(final Decorable decorable, final FactoryController controller, final MetaParameter parameter) { final Statement elementAccessor; if (MetaClassFactory.get(Element.class).isAssignableFrom(parameter.getType())) { elementAccessor = Refs.get("element"); else if (MetaClassFactory.get(Style.class).isAssignableFrom(parameter.getType())) { elementAccessor = Stmt.loadVariable("element").invoke("getStyle"); final boolean enclosingTypeIsDependent = decorable.isEnclosingTypeDependent(); if (!enclosingTypeIsDependent) { bindExecStmts.add(declareFinalVariable("instance", decorable.getEnclosingInjectable().getInjectedType(), castTo(decorable.getEnclosingInjectable().getInjectedType(), invokeStatic(Factory.class, "maybeUnwrapProxy", controller.contextGetInstanceStmt())))); .extend() .publicOverridesMethod("invokeBinding", Parameter.of(Element.class, "element")) .appendAll(bindExecStmts) .finish() .finish(); initStmts.add(declareFinalVariable(hanldeVarName, parameterizedAs(RefHolder.class, typeParametersOf(BindingRegistrationHandle.class)), newObject(RefHolder.class))); initStmts.add(loadVariable(hanldeVarName).invoke("set", invokeStatic(StyleBindingsRegistry.class, "get") .invoke("addStyleBinding", decorable.getAnnotation().annotationType(), bindExec)));
public ClassStructureBuilder<?> generate() { final String safeProxyClassName = bindable.getFullyQualifiedName().replace('.', '_') + "Proxy"; final ClassStructureBuilder<?> classBuilder = ClassBuilder.define(safeProxyClassName, bindable) .packageScope() .implementsInterface(BindableProxy.class) .privateField(agentField, parameterizedAs(BindableProxyAgent.class, typeParametersOf(bindable))) .finish() .privateField(targetField, bindable) .finish() .publicConstructor() .callThis(Stmt.newObject(bindable)) .finish() .publicConstructor(Parameter.of(bindable, "targetVal")) .append(Stmt.loadVariable(agentField).assignValue( Stmt.newObject(parameterizedAs(BindableProxyAgent.class, typeParametersOf(bindable)), Variable.get("this"), Variable.get("targetVal")))) .append(Stmt.loadVariable(targetField).assignValue(Variable.get("targetVal"))) .append(generatePropertiesMap()) .append(agent().invoke("copyValues")) .publicMethod(BindableProxyAgent.class, "getBindableProxyAgent") .append(agent().returnValue()) .append(agent().invoke("updateWidgetsAndFireEvents")) .append( If.instanceOf(Variable.get("obj"), classBuilder.getClassDefinition()) .append(Stmt.loadVariable("obj").assignValue(
static BuildMetaClass generateArrayMarshaller(final MetaClass arrayType, final String marshallerClassName, final boolean gwtTarget) { final MetaClass toMap = arrayType.getOuterComponentType(); ClassBuilder.define(marshallerClassName).publicScope(). implementsInterface(parameterizedAs(Marshaller.class, typeParametersOf(arrayType))).body(); final MetaClass arrayOfArrayType = arrayType.asArrayOf(1); .append(Stmt.load(null).returnValue()) .finish(); bBuilder.append( If.isNull(loadVariable("a0")) .append(Stmt.load(null).returnValue()) .finish() .else_() .append(Stmt.nestedCall(Stmt.loadVariable("this")).invoke("_demarshall" + dimensions, Stmt.loadVariable("a0").invoke("isArray"), loadVariable("a1")).returnValue()) .finish()); bBuilder.finish(); Parameter.of(toMap.asArrayOf(dimensions), "a0"), Parameter.of(MarshallingSession.class, "a1")); marshallMethodBlock.append(
private Statement generateComparatorFor(final MetaClass MC_annotationClass, final Collection<MetaMethod> methods) { final MetaClass MC_annoComparator = parameterizedAs(AnnotationComparator.class, typeParametersOf(MC_annotationClass)); if (method.getReturnType().isPrimitive()) { isEqualBuilder._( If.notEquals(Stmt.loadVariable("a1").invoke(method), Stmt.loadVariable("a2").invoke(method)) ._(Stmt.load(false).returnValue()) .finish() ); else if (method.getReturnType().isArray()) { isEqualBuilder._( If.not(Stmt.invokeStatic(Arrays.class, "equals", Stmt.loadVariable("a1").invoke(method), Stmt.loadVariable("a2").invoke(method)) ._(Stmt.load(false).returnValue()) .finish() ); If.not(Stmt.loadVariable("a1").invoke(method).invoke("equals", Stmt.loadVariable("a2").invoke(method))) ._(Stmt.load(false).returnValue()) .finish()
protected void maybeImplementCreateProxy(final ClassStructureBuilder<?> bodyBlockBuilder, final Injectable injectable) { final MetaClass proxyImpl = maybeCreateProxyImplementation(injectable, bodyBlockBuilder); if (proxyImpl != null) { final BlockBuilder<?> createProxyBody = bodyBlockBuilder .publicMethod(parameterizedAs(Proxy.class, typeParametersOf(injectable.getInjectedType())), "createProxy", finalOf(Context.class, "context")) .body(); final Object proxyInstanceStmt; if (injectable.getInjectedType().isInterface() || getAccessibleNoArgConstructor(injectable.getInjectedType()) != null) { proxyInstanceStmt = newObject(proxyImpl); } else { bodyBlockBuilder .privateMethod(parameterizedAs(Proxy.class, typeParametersOf(injectable.getInjectedType())), "createProxyWithErrorMessage") .body() .append(try_().append(load(newObject(proxyImpl)).returnValue()).finish() .catch_(Throwable.class, "t").append(throw_(RuntimeException.class, loadLiteral(injectableConstructorErrorMessage(injectable)), loadVariable("t"))) .finish()) .finish(); proxyInstanceStmt = loadVariable("this").invoke("createProxyWithErrorMessage"); } createProxyBody .append(declareFinalVariable("proxyImpl", parameterizedAs(Proxy.class, typeParametersOf(injectable.getInjectedType())), proxyInstanceStmt)) .append(loadVariable("proxyImpl").invoke("setProxyContext", loadVariable("context"))) .append(loadVariable("proxyImpl").returnValue()).finish(); } }
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)));
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();
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; 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; .publicMethod(returnType, methodName, parms) .append(callOnTarget) .append(agent().invoke("updateWidgetsAndFireEvents")) .append(returnValue) .finish();
private Statement createJsTypeProviderFor(final Injectable injectable) { final MetaClass type = injectable.getInjectedType(); final AnonymousClassStructureBuilder jsTypeProvider = newInstanceOf(parameterizedAs(JsTypeProvider.class, typeParametersOf(type))).extend(); jsTypeProvider .publicOverridesMethod("getInstance") .append(Stmt.castTo(type, loadVariable("contextManager").invoke("getInstance", injectable.getFactoryName())) .returnValue()).finish() .publicOverridesMethod("getName") .append(Stmt.loadLiteral(getBeanName(injectable)).returnValue()) .finish() .publicOverridesMethod("getFactoryName") .append(Stmt.loadLiteral(injectable.getFactoryName()).returnValue()) .finish() .publicOverridesMethod("getQualifiers") .append(Stmt.nestedCall(Stmt.newObject(parameterizedAs(JsArray.class, typeParametersOf(String.class)), Stmt.loadLiteral(AnnotationSerializer.serialize(injectable.getQualifier().iterator())))).returnValue()) .finish(); return jsTypeProvider.finish(); }
public static void ensureMarshallerFieldCreated(final ClassStructureBuilder<?> classStructureBuilder, final MetaClass marshallerForType, final MetaClass type, final BlockBuilder<?> initMethod, final Statement marshallerCreationCallback) { final String fieldName = MarshallingGenUtil.getVarName(type); if (classStructureBuilder.getClassDefinition().getField(fieldName) == null) { final Statement marshallerLookup = createMarshallerLookup(marshallerForType, type, marshallerCreationCallback); if (initMethod == null) { classStructureBuilder.privateField(fieldName, parameterizedAs(Marshaller.class, typeParametersOf(type.getErased().asBoxed()))) .initializesWith(marshallerLookup).finish(); } else { classStructureBuilder.privateField(fieldName, parameterizedAs(Marshaller.class, typeParametersOf(type.getErased().asBoxed()))) .initializesWith(Stmt.load(null)).finish(); initMethod.append( If.isNull(Stmt.loadVariable(fieldName)).append( Stmt.loadVariable(fieldName).assignValue(marshallerLookup)).finish()); } } }