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(); }
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(); } }
@Test public void testForeachLoopWithLiterals() { String s = StatementBuilder.create() .loadLiteral(new String[] { "s1", "s2" }) .foreach("s") .append(StatementBuilder.create().loadVariable("s").invoke("getBytes")) .finish().toJavaString(); assertEquals("Failed to generate foreach loop using a literal String array", FOREACH_LITERAL_STRING_ARRAY, s); }
@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 implementClearInstance(final ClassStructureBuilder<?> proxyImpl, final Injectable injectable) { proxyImpl.publicMethod(void.class, "clearInstance") .body() .append(loadVariable("proxyHelper").invoke("clearInstance")) .finish(); }
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 implementAsBeanType(final ClassStructureBuilder<?> proxyImpl, final Injectable injectable) { proxyImpl.publicMethod(injectable.getInjectedType(), "asBeanType") .body() .append(loadVariable("this").returnValue()) .finish(); }
/** * Generates the return statement of this proxy method if required. If the proxy method returns * void, it will just finish the method block. */ private void generateReturnStatement() { final Statement returnStatement = ProxyUtil.generateProxyMethodReturnStatement(resourceMethod.getMethod()); if (returnStatement != null) { methodBlock.append(returnStatement); } methodBlock.finish(); } }
@Test public void testSwitchBlockChainedOnInvocation() { String s = StatementBuilder.create() .declareVariable("str", String.class) .loadVariable("str") .invoke("length") .switch_() .case_(0) .append(Stmt.loadStatic(System.class, "out").invoke("println", "0")) .append(Stmt.loadStatic(System.class, "out").invoke("println", "break")) .append(Stmt.break_()) .finish() .case_(1) .append(Stmt.break_()) .finish() .default_() .append(Stmt.break_()) .finish() .toJavaString(); assertEquals("Failed to generate switch block chained on invocation", SWITCH_BLOCK_CHAINED_INVOCATION, s); } }
@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 } }
@Test public void testEmptyIfBlockUsingNoRhsAndNegation() { String s = StatementBuilder.create() .declareVariable("str", String.class) .loadVariable("str") .invoke("endsWith", "abc") .ifNot() .finish().toJavaString(); assertEquals("Failed to generate empty if block using no rhs", EMPTY_IF_BLOCK_NO_RHS_AND_NEGATION, s); }
public static Statement buildCheckStatement(ContextualStatementBuilder authzCall, String onGranted, String onDenied) { BooleanExpression boolExpr = BooleanExpressionBuilder.create(authzCall).negate(); BlockBuilder<ElseBlockBuilder> builder = If.cond(boolExpr); if (onDenied != null && onDenied.trim().length() > 0) { builder.append(Stmt.loadVariable("this").invoke(onDenied)); } BlockBuilder<StatementEnd> endBuilder = builder.append(Stmt.returnVoid()).finish().else_(); if (onGranted != null && onGranted.trim().length() > 0) { endBuilder.append(Stmt.loadVariable("this").invoke(onGranted)); } return endBuilder.finish(); }
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 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(); }
@Test public void testForeachLoopWithInvoke() { Builder loop = StatementBuilder.create() .declareVariable("map", Map.class) .loadVariable("map") .invoke("keySet") .foreach("key") .append(Stmt.loadStatic(System.class, "out").invoke("println", Variable.get("key"))) .finish(); assertEquals("Failed to generate foreach loop using invoke()", FOREACH_KEYSET_LOOP, loop.toJavaString()); }
@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); }