final long time = System.currentTimeMillis(); final MethodBlockBuilder<?> loadProxies = classBuilder.publicMethod(void.class, "loadProxies", Parameter.of(MessageBus.class, "bus", true)); final Statement proxyProvider = ObjectBuilder.newInstanceOf(ProxyProvider.class) .extend() .publicOverridesMethod("getProxy") .append(Stmt.nestedCall(Stmt.newObject(remoteProxy.getClassDefinition())).returnValue()) .finish() .finish(); loadProxies.append(Stmt.invokeStatic(RemoteServiceProxyFactory.class, "addRemoteProxy", remote, proxyProvider));
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(); } }
@Override public String getCanonicalString(final Context context) { final BlockBuilder<AnonymousClassStructureBuilder> initBlock = ObjectBuilder.newInstanceOf(ArrayList.class, context).extend().initialize(); for (final Object v : getValue()) { initBlock.append(Stmt.loadVariable("this").invoke("add", LiteralFactory.getLiteral(context, v))); } return initBlock.finish().finish().toJavaString(); } }
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 generateFactoryLoader(final Injectable injectable, final MetaClass factoryClass) { final Statement runAsyncCallback = ObjectBuilder.newInstanceOf(DefaultRunAsyncCallback.class).extend() .publicOverridesMethod("onSuccess").append(loadVariable("callback").invoke("callback", castTo(Factory.class, invokeStatic(GWT.class, "create", loadLiteral(factoryClass))))) .finish().finish(); final Class<?> fragmentId = getAsyncFragmentId(injectable); final Object[] runAsyncParams = (fragmentId.equals(LoadAsync.NO_FRAGMENT.class) ? new Object[] { runAsyncCallback } : new Object[] { fragmentId, runAsyncCallback }); return ObjectBuilder.newInstanceOf(FactoryLoader.class).extend() .publicOverridesMethod("call", finalOf(FactoryLoaderCallback.class, "callback")) .append(invokeStatic(GWT.class, "runAsync", runAsyncParams)).finish().finish(); }
.newInstanceOf(org.jboss.errai.common.client.dom.EventListener.class) .extend() .publicOverridesMethod("call", Parameter.of(org.jboss.errai.common.client.dom.Event.class, "event")) .append(InjectUtil .invokePublicOrPrivateMethod(controller, method, invokeStatic(Js.class, "cast", loadVariable("event")))) .finish() .finish(); final ContextualStatementBuilder elementStmt; if (dataFieldTypes.containsKey(dataFieldName) && !"this".equals(dataFieldName)) { final MetaClass fieldType = dataFieldTypes.get(dataFieldName); if (fieldType.isAssignableTo(Widget.class)) { elementStmt = castTo(Widget.class, nestedCall(fieldsMap).invoke("get", dataFieldName)); elementStmt = nestedCall(fieldsMap).invoke("get", dataFieldName); elementStmt = loadVariable(dataFieldElementsVarName).invoke("get", dataFieldName);
private AnonymousClassStructureBuilder generateMethodDelegates(final Class<?> intf, final Decorable decorable, final FactoryController controller) { final BlockBuilder<AnonymousClassStructureBuilder> builder = ObjectBuilder.newInstanceOf(MessageCallback.class) .extend().publicOverridesMethod("callback", Parameter.of(Message.class, "message")) .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 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 Statement methodInvocation = Stmt.nestedCall(Stmt.loadVariable("instance")).invoke(method.getName(), (Object[]) objects); .invoke("subjectProvided").invoke("with", "MethodReply", Refs.get("ret")) .extend() .publicOverridesMethod("run") .finish().finish();
return Stmt.newObject(callContextType).extend() .publicOverridesMethod("getMethodName") .append(Stmt.load(method.getName()).returnValue()) .finish() .publicOverridesMethod("getReturnType") .append(Stmt.load(method.getReturnType()).returnValue()) .finish() .publicOverridesMethod("getAnnotations") .append(Stmt.load(filter(method.getAnnotations(), translatablePackages)).returnValue()) .finish() .publicOverridesMethod("getTypeAnnotations") .publicOverridesMethod("proceed") .publicOverridesMethod("proceed", Parameter.of(RemoteCallback.class, "interceptorCallback", true)) Stmt.loadVariable("remoteCallback").assignValue(Stmt.newObject(RemoteCallback.class).extend() .publicOverridesMethod("callback", Parameter.of(Object.class, "response")) .finish()) .publicOverridesMethod("proceed", Parameter.of(RemoteCallback.class, "interceptorCallback"), Stmt.newObject(ErrorCallback.class).extend() .publicOverridesMethod("error", Parameter.of(Object.class, "message"), .finish())
= ObjectBuilder.newInstanceOf(annotationClass, context) .extend(); try { method.setAccessible(true); builder.publicOverridesMethod(method.getName()) .append(Stmt.load(method.invoke(annotation)).returnValue()).finish(); return generatedCache = prettyPrintJava(builder.finish().toJavaString());
final Statement proceed, final List<Class<?>> interceptors) { final BlockStatement proceedLogic = new BlockStatement(); proceedLogic.addStatement(Stmt.loadVariable("status").invoke("proceed")); If.isNull(Stmt.loadVariable("status").invoke("getNextInterceptor"))._(proceed).finish(); Stmt.loadVariable("status").invoke("getNextInterceptor"), interceptor)) .append(Stmt.declareFinalVariable("ctx", callContextType, Stmt.loadVariable("this"))) .append( Stmt.declareVariable(CreationalCallback.class).asFinal().named("icc") .initializeWith( Stmt.newObject(CreationalCallback.class).extend() .publicOverridesMethod("callback", Parameter.of(Object.class, "beanInstance", true)) .append(Stmt.loadVariable("status").invoke("setProceeding", false)) .append( Stmt.castTo(interceptor, Stmt.loadVariable("beanInstance")).invoke("aroundInvoke", Variable.get("ctx"))) .append( .finish()) .finish() // finish the method override body .finish() // finish the anonymous CreationalCallback class body )) .append(generateAsyncInterceptorCreation(context, interceptor))
@Override protected List<Statement> generateCreateInstanceStatements(final ClassStructureBuilder<?> bodyBlockBuilder, final Injectable injectable, final DependencyGraph graph, final InjectionContext injectionContext) { final StatementBuilder anchorDeclaration = declareFinalVariable( "anchor", Anchor.class, castTo(Anchor.class, invokeStatic(Window.class, "getDocument") .invoke("createElement", "a"))); final ObjectBuilder clickListener = newObject(EventListener.class) .extend() .publicOverridesMethod("call", finalOf(Event.class, "event")) .append(navigationGoToInvocation(targetType)) .finish() .finish(); final ContextualStatementBuilder setClickListener = loadVariable("anchor").invoke("setOnclick", clickListener); final Statement returnValue = loadVariable("anchor").returnValue(); return Arrays.asList( anchorDeclaration, setClickListener, returnValue ); }
AnonymousClassStructureBuilder callBack = Stmt.newObject(callBackType).extend(); callBackBlock = callBack.initialize(); for (final String qualifierName : qualifierNames) { callBackBlock.append(Stmt.loadClassMember("qualifierSet").invoke("add", qualifierName)); callBack = callBackBlock.finish(); callBackBlock = callBack.publicOverridesMethod("fireEvent", Parameter.finalOf(eventType, "event")) .appendAll(callbackStatements) .finish() .publicOverridesMethod("toString") ._(Stmt.load("Observer: " + parmClassName + " " + Arrays.toString(qualifiers)).returnValue()); final Statement subscribeStatement = Stmt.create(ctx).invokeStatic(CDI.class, subscribeMethod, parmClassName, callBackBlock.finish().finish()); destroyStatements.add(controller.getReferenceStmt(subscrVar, Subscription.class).invoke("remove")); } else { initStatements.add(subscribeStatement); final ContextualStatementBuilder routingSubStmt = Stmt.invokeStatic(ErraiBus.class, "get").invoke("subscribe", CDI.getSubjectNameByType(cls.getName()), Stmt.loadStatic(CDI.class, "ROUTING_CALLBACK")); if (isEnclosingTypeDependent) {
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(); }
comparator = Stmt.loadLiteral(null); AnonymousClassStructureBuilder comparatorClassBuilder = ObjectBuilder.newInstanceOf(Comparator.class, context).extend(); BlockBuilder<AnonymousClassStructureBuilder> compareMethod = comparatorClassBuilder .publicOverridesMethod("compare", Parameter.of(Object.class, "o1"), Parameter.of(Object.class, "o2")); .append(Stmt.declareFinalVariable("lhs", resultType, Cast.to(resultType, Stmt.loadVariable("o1")))) .append(Stmt.declareFinalVariable("rhs", resultType, Cast.to(resultType, Stmt.loadVariable("o2")))); compareMethod.append(Stmt.declareVariable("result", int.class)); .append(Stmt.loadVariable("result").assignValue(Stmt.invokeStatic(Comparisons.class, "nullSafeCompare", lhs, rhs))) .append(Stmt.if_(Bool.notEquals(Stmt.loadVariable("result"), 0)) .append(Stmt.nestedCall(Arith.expr(ascDescOperator, Stmt.loadVariable("result"))).returnValue()) .finish()); compareMethod.append(Stmt.loadLiteral(0).returnValue()); comparator = compareMethod.finish().finish(); classBuilder.protectedMethod(Comparator.class, "getComparator") .append(Stmt.nestedCall(comparator).returnValue()) .finish();
private Statement generateComparatorFor(final MetaClass MC_annotationClass, final Collection<MetaMethod> methods) { final MetaClass MC_annoComparator = parameterizedAs(AnnotationComparator.class, typeParametersOf(MC_annotationClass)); final AnonymousClassStructureBuilder clsBuilder = ObjectBuilder.newInstanceOf(MC_annoComparator).extend(); final MethodBlockBuilder<AnonymousClassStructureBuilder> isEqualBuilder = clsBuilder .publicMethod(boolean.class, "isEqual", Parameter.of(MC_annotationClass, "a1"), Parameter.of(MC_annotationClass, "a2")) .annotatedWith(new Override() { @Override 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() = clsBuilder.publicOverridesMethod("hashCodeOf", Parameter.of(MC_annotationClass, "a1")); hashCodeOfBuilder._(Stmt.declareVariable(int.class).named("hash") return classStructureBuilder.finish();
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())))); final ObjectBuilder bindExec = newObject(StyleBindingExecutor.class) .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))); .castTo(BindingRegistrationHandle.class, controller.getReferenceStmt(registrationHandleVar, RefHolder.class).invoke("get")) .invoke("cleanup")); if (enclosingTypeIsDependent) { addCleanup(decorable, controller, destructionStmts);
statements.add(Stmt.declareFinalVariable("objectClass", Class.class, Stmt.loadLiteral(Object.class))); Stmt.newObject(QueryParamInitCallback.class).extend().publicOverridesMethod("getQueryParams"); queryParamCallback.append(Stmt.declareFinalVariable("paramsMap", Map.class, Stmt.newObject(HashMap.class))); fieldValueStmt = Stmt.loadLiteral(val); queryParamCallback.append(Stmt.loadVariable("paramsMap").invoke("put", param.name(), fieldValueStmt)); queryParamCallback.append(Stmt.loadVariable("paramsMap").returnValue()); statements.add(Stmt.declareFinalVariable("paramsCallback", QueryParamInitCallback.class, queryParamCallback.finish().finish())); statements.add(controller.setReferenceStmt("syncWorker", Stmt.invokeStatic(ClientSyncWorker.class, "create", Stmt.nestedCall(syncWorkerRef).invoke("addSyncCallback", createSyncCallback(decorable))); statements.add( Stmt.nestedCall(syncWorkerRef).invoke("start", Refs.get("instance"), Stmt.loadVariable("paramsCallback")));
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(); }
final Statement result; if (methodReturnType.equals(MetaClassFactory.get(void.class))) { result = load(null).returnValue(); 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(); .newInstanceOf(ResponseDemarshallingCallback.class) .extend() .publicOverridesMethod("demarshallResponse", Parameter.of(Response.class, "response")) .append(result) .finish() .finish();
final BlockBuilder<AnonymousClassStructureBuilder> listenerBuiler = ObjectBuilder.newInstanceOf(handlerType) .extend() .publicOverridesMethod(handlerType.getMethods()[0].getName(), Parameter.of(eventType, "event")); listenerBuiler.append(InjectUtil.invokePublicOrPrivateMethod(controller, method, Stmt.loadVariable("event"))); final ObjectBuilder listenerInstance = listenerBuiler.finish().finish(); eventSource = Stmt.loadVariable("instance"); eventSource = Stmt.nestedCall(fieldsMap).invoke("get", name); initStmts.add(Stmt.nestedCall(widget).invoke("add" + handlerType.getName(), Cast.to(handlerType, listenerInstance))); initStmts.add(Stmt.nestedCall(widget).invoke("addDomHandler", listenerInstance, Stmt.invokeStatic(eventType, "getType"))); } else if (RebindUtil.isNativeJsType(dataFieldType) || RebindUtil.isElementalIface(dataFieldType)) {