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 Statement generateInterceptorLogic(ClassStructureBuilder<?> classBuilder, MetaMethod method, Statement requestLogic, List<Statement> parmVars, List<Class<?>> interceptors) { final Statement callContext = ProxyUtil.generateProxyMethodCallContext(context, RemoteCallContext.class, classBuilder.getClassDefinition(), method, requestLogic, interceptors).finish(); return Stmt.try_() .append( Stmt.declareVariable(CallContextStatus.class).asFinal().named("status").initializeWith( Stmt.newObject(CallContextStatus.class).withParameters(interceptors.toArray()))) .append( Stmt.declareVariable(RemoteCallContext.class).asFinal().named("callContext") .initializeWith(callContext)) .append( Stmt.loadVariable("callContext").invoke("setParameters", Stmt.newArray(Object.class).initialize(parmVars.toArray()))) .append( Stmt.loadVariable("callContext").invoke("proceed")) .finish() .catch_(Throwable.class, "throwable") .append( If.cond(Bool.notEquals(Stmt.loadVariable("errorCallback"), Stmt.loadLiteral(null))) .append( If.cond(Stmt.loadVariable("errorCallback").invoke("error", Stmt.load(null), Variable.get("throwable"))) .append(Stmt.loadVariable("this").invoke("invokeDefaultErrorHandlers", Variable.get("throwable"))) .finish() ).finish() .else_() .append(Stmt.loadVariable("this").invoke("invokeDefaultErrorHandlers", Variable.get("throwable"))) .finish()) .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());
@Override public Statement newObject(final Class<?> type, final Object... parameters) { return ObjectBuilder.newInstanceOf(type, context, callElementBuilder) .withParameters(parameters); }
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(); }
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 ); }
Parameter.of(String.class, "property")); Parameter.of(String.class, "property"), Parameter.of(Object.class, "value")); CaseBlockBuilder getSwitchBlock = Stmt.switch_(loadVariable("property")); CaseBlockBuilder setSwitchBlock = Stmt.switch_(loadVariable("property")); generateSetter(classBuilder, property, setSwitchBlock); getSwitchBlock.case_("this").append(target().returnValue()).finish(); setSwitchBlock.case_("this") .append(Stmt.loadClassMember(targetField).assignValue(Stmt.castTo(bindable, Stmt.loadVariable("value")))) .append(agent().loadField("target").assignValue(Stmt.loadClassMember(targetField))) .append(Stmt.break_()) .finish(); .append(Stmt.declareFinalVariable("props", Map.class, ObjectBuilder.newInstanceOf(HashMap.class) .withParameters(agent().loadField("propertyTypes")))) .append(Stmt.loadVariable("props").invoke("remove", "this")) .append(Stmt.invokeStatic(Collections.class, "unmodifiableMap", Stmt.loadVariable("props")).returnValue()) .finish();
@Override public String getCanonicalString(final Context context) { final BlockBuilder<AnonymousClassStructureBuilder> initBlock = ObjectBuilder.newInstanceOf(HashSet.class, context).extend().initialize(); for (final Object v : getValue()) { initBlock.append(Stmt.loadVariable("this").invoke("add", LiteralFactory.getLiteral(v))); } return initBlock.finish().finish().toJavaString(); } }
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(); }
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 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(); }
method.append(Stmt.declareFinalVariable("pageState", Map.class, new HashMap<String, Object>())); for (MetaField field : pageClass.getFieldsAnnotatedWith(PageState.class)) { PageState psAnno = field.getAnnotation(PageState.class); method.append(Stmt.declareVariable(fieldName, Stmt.newObject(HashSet.class))); method.append(Stmt.declareVariable(fieldName, Stmt.newObject(ArrayList.class))); method.append( Stmt.loadVariable("state").invoke("getState").invoke("get", queryParamName).foreach("elem", Object.class) .append(Stmt.declareVariable("fv" + idx, Stmt.castTo(String.class, Stmt.loadVariable("elem")))) .append( Stmt.loadVariable(fieldName).invoke("add", paramFromStringStatement(elementType, Stmt.loadVariable("fv" + idx)))) .append( Stmt.loadVariable("pageState").invoke( "put", fieldName, Stmt.loadVariable(fieldName))) .finish() method.append(Stmt.declareFinalVariable("fv" + idx, Collection.class, Stmt.loadVariable("state").invoke( "getState").invoke("get", queryParamName))); method.append( If.cond( method.append(Stmt.invokeStatic(CDI.class, "fireEvent", Stmt.newObject(NavigationEvent.class).withParameters( Stmt.newObject(PageRequest.class).withParameters(getPageName(pageClass), Stmt.loadVariable("pageState"))) ));
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();
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(); }
@Test public void testAnonymousClass() { String src = ObjectBuilder.newInstanceOf(Bar.class, Context.create().autoImport()) .extend() .publicOverridesMethod("setName", Parameter.of(String.class, "name")) .append(Stmt.loadClassMember("name").assignValue(Variable.get("name"))) .finish() .finish() .toJavaString(); assertEquals("failed to generate anonymous class with overloaded construct", "new Bar() {\n" + "public void setName(String name) {\n" + "this.name = name;\n" + "}\n" + "}", src); }
AnonymousClassStructureBuilder pageImplBuilder = ObjectBuilder.newInstanceOf( MetaClassFactory.parameterizedAs(PageNode.class, MetaClassFactory.typeParametersOf(pageClass))).extend(); .publicMethod(String.class, "name") .append(Stmt.loadLiteral(pageName).returnValue()).finish() .publicMethod(String.class, "toString") .append(Stmt.loadLiteral(pageName).returnValue()).finish() .publicMethod(String.class, "getURL") .append(Stmt.loadLiteral(getPageURL(pageClass, pageName)).returnValue()).finish() .publicMethod(Class.class, "contentType") .append(Stmt.loadLiteral(pageClass).returnValue()).finish() .publicMethod(void.class, "produceContent", Parameter.of(CreationalCallback.class, "callback")) .append(Stmt.nestedCall(Refs.get("bm")) .invoke("lookupBean", Stmt.loadLiteral(pageClass))
private BlockBuilder<AnonymousClassStructureBuilder> getSubscriptionCallback(final Decorable decorable, final FactoryController controller) { final MetaParameter parm = decorable.getAsParameter(); final MetaClass eventType = parm.getType().asBoxed(); final String parmClassName = eventType.getFullyQualifiedName(); final List<Annotation> annotations = InjectUtil.extractQualifiers(parm); final Annotation[] qualifiers = annotations.toArray(new Annotation[annotations.size()]); final Set<String> qualifierNames = new HashSet<>(CDI.getQualifiersPart(qualifiers)); final MetaClass callBackType = parameterizedAs(AbstractCDIEventCallback.class, typeParametersOf(eventType)); AnonymousClassStructureBuilder callBack = Stmt.newObject(callBackType).extend(); BlockBuilder<AnonymousClassStructureBuilder> callBackBlock; if (!qualifierNames.isEmpty()) { callBackBlock = callBack.initialize(); for (final String qualifierName : qualifierNames) { callBackBlock.append(Stmt.loadClassMember("qualifierSet").invoke("add", qualifierName)); } callBack = callBackBlock.finish(); } 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("fireEvent", Parameter.finalOf(eventType, "event")) .appendAll(fireEventStmts) .finish() .publicOverridesMethod("toString") ._(Stmt.load("Observer: " + parmClassName + " " + Arrays.toString(qualifiers)).returnValue()); return callBackBlock; }
return Stmt.try_() .append( Stmt.declareVariable(CallContextStatus.class).asFinal().named("status").initializeWith( Stmt.newObject(CallContextStatus.class).withParameters(interceptors.toArray()))) .append( Stmt.declareVariable(RestCallContext.class).asFinal().named("callContext") .initializeWith(callContext)) .append( Stmt.loadVariable("callContext").invoke("setRequestBuilder", Variable.get("requestBuilder"))) .append( Stmt.loadVariable("callContext").invoke("setParameters", Stmt.newArray(Object.class).initialize(parameters.toArray()))) .append( Stmt.loadVariable("callContext").invoke("proceed")) .finish() .catch_(Throwable.class, "throwable") .append( Stmt.loadStatic(declaringClass, "this").invoke("handleError", Variable.get("throwable"), null, null)) .finish();