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(); }
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(); }
/** * Generates code to call {@link Factory#setReference(Object, String, Object)} * for an instance in the * {@link Factory#createInstance(org.jboss.errai.ioc.client.container.ContextManager)} * method. */ public static ContextualStatementBuilder constructSetReference(final String name, final Statement value) { return loadVariable("thisInstance").invoke("setReference", Stmt.loadVariable("instance"), name, value); }
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 void callFinishInitOnContextManager(final String contextManagerFieldName, final BlockBuilder<?> methodBody) { methodBody.append(loadVariable(contextManagerFieldName).invoke("finishInit")); }
@Test public void testForLoopChainedWithoutCountingExpression() { String s = StatementBuilder.create() .declareVariable("i", Integer.class, 0) .loadVariable("i") .for_(Stmt.loadVariable("i").assignValue(0), Bool.expr(BooleanOperator.LessThan, 100)) .finish().toJavaString(); assertEquals("Failed to generate for loop with initializer and chained lhs", FOR_CHAINED_INITIALIZER_NO_COUNTING_EXP_EMPTY, s); }
private void generateCommonSetter(final ClassStructureBuilder<?> classBuilder) { classBuilder.privateMethod(void.class, "changeAndFire", Parameter.of(String.class, "property"), Parameter.of(Object.class, "value")) .append(Stmt.declareFinalVariable("oldValue", Object.class, Stmt.loadVariable("this").invoke("get", loadVariable("property")))) .append(Stmt.loadVariable("this").invoke("set", loadVariable("property"), loadVariable("value"))) .append(agent().invoke("updateWidgetsAndFireEvent", false, loadVariable("property"), Variable.get("oldValue"), loadVariable("value"))) .finish(); }
private void implementAsBeanType(final ClassStructureBuilder<?> proxyImpl, final Injectable injectable) { proxyImpl.publicMethod(injectable.getInjectedType(), "asBeanType") .body() .append(loadVariable("this").returnValue()) .finish(); }
private Statement invokePrivateAccessorWithNoParams(final String accessorName) { return loadVariable("this").invoke(accessorName, loadVariable("instance")); }
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 void addContextsToContextManager(final Collection<MetaClass> scopeContextImpls, final String contextManagerFieldName, @SuppressWarnings("rawtypes") final BlockBuilder methodBody) { for (final MetaClass scopeContextImpl : scopeContextImpls) { methodBody.append(loadVariable(contextManagerFieldName).invoke("addContext", loadVariable(getContextVarName(scopeContextImpl)))); } }
@Test public void testSwitchBlockWithInvalidCaseValueUsingIntForEnum() { try { Context c = Context.create().addVariable("t", TestEnum.class); StatementBuilder.create(c) .switch_(Stmt.loadVariable("t")) .case_(1) .finish() .toJavaString(); fail("expected InvalidTypeException"); } catch (InvalidTypeException e) { // expected } }
private void generateCommonSetter(final ClassStructureBuilder<?> classBuilder) { classBuilder.privateMethod(void.class, "changeAndFire", Parameter.of(String.class, "property"), Parameter.of(Object.class, "value")) .append(Stmt.declareFinalVariable("oldValue", Object.class, Stmt.loadVariable("this").invoke("get", loadVariable("property")))) .append(Stmt.loadVariable("this").invoke("set", loadVariable("property"), loadVariable("value"))) .append(agent().invoke("updateWidgetsAndFireEvent", false, loadVariable("property"), Variable.get("oldValue"), loadVariable("value"))) .finish(); }
private void implementInitProxyProperties(final ClassStructureBuilder<?> proxyImpl, final Injectable injectable) { final BlockBuilder<?> initBody = proxyImpl .publicMethod(void.class, "initProxyProperties", finalOf(injectable.getInjectedType(), "instance")).body(); for (final Entry<String, Statement> prop : controller.getProxyProperties()) { proxyImpl.privateField(prop.getKey(), prop.getValue().getType()).finish(); initBody.append(loadVariable(prop.getKey()).assignValue(prop.getValue())); } initBody.finish(); }
/** * Generates code to call * {@link Factory#getReferenceAs(Object, String, Class)} for an instance in * {@link Factory#createInstance(org.jboss.errai.ioc.client.container.ContextManager)} * and * {@link Factory#destroyInstance(Object, org.jboss.errai.ioc.client.container.ContextManager)} * methods. */ public static ContextualStatementBuilder constructGetReference(final String name, final Class<?> refType) { // This cast is for the benefit of codegen, which is sometimes unable to // identify the value for the type parameter of Factory.getReferenceAs. return castTo(refType, loadVariable("thisInstance").invoke("getReferenceAs", loadVariable("instance"), name, refType)); }
private void maybeImplementDestroyInstance(final ClassStructureBuilder<?> bodyBlockBuilder, final Injectable injectable, final List<Statement> destroyInstanceStatements) { if (!destroyInstanceStatements.isEmpty()) { bodyBlockBuilder .publicMethod(void.class, "generatedDestroyInstance", finalOf(Object.class, "instance"), finalOf(ContextManager.class, "contextManager")) .append(loadVariable("this").invoke("destroyInstanceHelper", Stmt.castTo(injectable.getInjectedType(), loadVariable("instance")), loadVariable("contextManager"))) .finish(); bodyBlockBuilder.publicMethod(void.class, "destroyInstanceHelper", finalOf(injectable.getInjectedType(), "instance"), finalOf(ContextManager.class, "contextManager")) .appendAll(destroyInstanceStatements).finish(); } }
private void registerAsyncFactory(final Injectable injectable, final IOCProcessingContext processingContext, @SuppressWarnings("rawtypes") final BlockBuilder curMethod, final MetaClass factoryClass) { final Statement handle = generateFactoryHandle(injectable, curMethod); final Statement loader = generateFactoryLoader(injectable, factoryClass); curMethod.append(loadVariable("asyncBeanManagerSetup").invoke("registerAsyncBean", handle, loader)); for (final Dependency dep : injectable.getDependencies()) { if (dep.getInjectable().loadAsync()) { curMethod.append(loadVariable("asyncBeanManagerSetup").invoke("registerAsyncDependency", injectable.getFactoryName(), dep.getInjectable().getFactoryName())); } } }
@Test public void testDefineClassWithAccessorMethodsUsingThisKeyword() { final String cls = ClassBuilder .define("org.foo.Foo") .publicScope() .body() .privateField("name", String.class) .initializesWith(Stmt.load("default")) .finish() .publicMethod(String.class, "getName") .append(Stmt.loadVariable("name").returnValue()) .finish() .publicMethod(void.class, "setName", Parameter.of(String.class, "name")) .append(Stmt.loadVariable("this.name").assignValue(Variable.get("name"))) .finish() .toJavaString(); assertEquals("failed to generate class definition with accessor methods", CLASS_WITH_ACCESSOR_METHODS, cls); }
private void implementEquals(final ClassStructureBuilder<?> proxyImpl) { proxyImpl.publicMethod(boolean.class, "equals", Parameter.of(Object.class, "obj")).body() .append(loadVariable("obj").assignValue(invokeStatic(Factory.class, "maybeUnwrapProxy", loadVariable("obj")))) .append(loadVariable("proxyHelper").invoke("getInstance", loadVariable("this")).invoke("equals", loadVariable("obj")).returnValue()) .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(); }