private Statement generateRequest(ClassStructureBuilder<?> classBuilder, MetaMethod method, Statement methodParams, boolean intercepted) { final Statement sendable = Stmt .invokeStatic(MessageBuilder.class, "createCall") .invoke("call", remote.getFullyQualifiedName()) .invoke("endpoint", ProxyUtil.createCallSignature(method), Stmt.loadClassMember("qualifiers"), methodParams) .invoke("respondTo", method.getReturnType().asBoxed(), Stmt.loadVariable("remoteCallback")) .invoke("errorsHandledBy", Stmt.loadVariable("errorCallback")); final BlockStatement requestBlock = new BlockStatement(); requestBlock.addStatement(Stmt.declareVariable("sendable", RemoteCallSendable.class, sendable)); requestBlock.addStatement(Stmt.loadStatic(classBuilder.getClassDefinition(), "this") .invoke("sendRequest", Variable.get("bus"), Variable.get("sendable"))); return requestBlock; } }
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(); }
/** * Generates the declaration for a new {@link RequestBuilder} instance, initialized with the * generated URL {@link #generateUrl(JaxrsResourceMethodParameters)} * * @return the RequestBuilder statement */ private Statement generateRequestBuilder() { final Statement requestBuilder = Stmt.declareVariable("requestBuilder", RequestBuilder.class, Stmt.newObject(RequestBuilder.class) .withParameters(resourceMethod.getHttpMethod(), Stmt.loadVariable("url").invoke("toString"))); return requestBuilder; }
public static BlockBuilder<StatementEnd> autoForLoop(final String varName, final Statement value) { return Stmt.for_(Stmt.declareVariable(int.class).named("i").initializeWith(0), Bool.lessThan(Variable.get("i"), value), new StringStatement(varName + "++", null)); }
public static BlockBuilder<StatementEnd> autoForLoop(final String varName, final Statement value) { return Stmt.for_(Stmt.declareVariable(int.class).named("i").initializeWith(0), Bool.lessThan(Variable.get("i"), value), new StringStatement(varName + "++", null)); }
private List<Statement> fieldCreateInstanceStatements(final MetaField producingMember, final Injectable producerInjectable, final Injectable producedInjectable, final ClassStructureBuilder<?> bodyBlockBuilder) { final List<Statement> stmts = new ArrayList<>(); controller.ensureMemberExposed(producingMember); if (!producingMember.isStatic()) { final Statement producerInstanceValue = loadVariable("contextManager").invoke("getInstance", producerInjectable.getFactoryName()); stmts.add(declareVariable(PRODUCER_INSTANCE, producerInjectable.getInjectedType(), producerInstanceValue)); stmts.add(loadVariable(PRODUCER_INSTANCE).assignValue(Stmt.castTo(producerInjectable.getInjectedType(), invokeStatic(Factory.class, "maybeUnwrapProxy", loadVariable(PRODUCER_INSTANCE))))); } final Statement invocation = controller.exposedFieldStmt(loadVariable(PRODUCER_INSTANCE), producingMember); stmts.add(declareFinalVariable("instance", producedInjectable.getInjectedType(), invocation)); if (!producingMember.isStatic()) { stmts.add(setProducerInstanceReference()); if (producerInjectable.getWiringElementTypes().contains(WiringElementType.DependentBean)) { stmts.add(loadVariable("this").invoke("registerDependentScopedReference", loadVariable("instance"), loadVariable(PRODUCER_INSTANCE))); } } stmts.add(loadVariable("instance").returnValue()); return stmts; }
@Test public void testCastDown() { final Statement stmt = Cast.to(String.class, Stmt.declareVariable("obj", Object.class).loadVariable("obj")); assertEquals("failed to generate cast", "(String) obj", stmt.generate(Context.create())); }
@Test public void testCastUp() { final Statement stmt = Cast.to(Object.class, Stmt.declareVariable("str", String.class).loadVariable("str")); assertEquals("created a redundant cast", "str", stmt.generate(Context.create())); }
@Test public void testInvalidCast() { try { final Statement stmt = Cast.to(Integer.class, Stmt.declareVariable("str", String.class).loadVariable("str")); stmt.generate(Context.create()); fail("expected InvalidTypeException"); } catch (InvalidTypeException e) { // expected assertEquals("Wrong exception message", "java.lang.String cannot be cast to java.lang.Integer", e.getMessage()); } }
private void bootstrapContainer(final IOCProcessingContext processingContext, final DependencyGraph dependencyGraph, final Set<MetaClass> scopeContextSet, final Statement[] contextLocalVarInvocation, final String contextManagerFieldName) { processingContext.getBlockBuilder() .appendAll(contextLocalVarDeclarations(scopeContextSet)) .append(loadVariable("logger").invoke("debug", "Registering factories with contexts.")) .append(declareVariable("start", long.class, currentTime())) .append(loadVariable("this").invoke("registerFactories", (Object[]) contextLocalVarInvocation)) .append(loadVariable("logger").invoke("debug", "Registered " + dependencyGraph.getNumberOfInjectables() + " factories in {}ms", subtractFromCurrentTime(loadVariable("start")))) .append(loadVariable("logger").invoke("debug", "Adding contexts to context manager...")) .append(loadVariable("start").assignValue(currentTime())); addContextsToContextManager(scopeContextSet, contextManagerFieldName, processingContext.getBlockBuilder()); processingContext.getBlockBuilder() .append(loadVariable("logger").invoke("debug", "Added " + scopeContextSet.size() + " contexts in {}ms", subtractFromCurrentTime(loadVariable("start")))) .append(loadVariable("logger").invoke("debug", "Calling finishInit on " + ContextManager.class.getSimpleName())) .append(loadVariable("start").assignValue(currentTime())); callFinishInitOnContextManager(contextManagerFieldName, processingContext.getBlockBuilder()); processingContext.getBlockBuilder() .append(loadVariable("logger").invoke("debug", "ContextManager#finishInit ran in {}ms", subtractFromCurrentTime(loadVariable("start")))); }
@Test public void testIfElseBlockUsingNoRhs() { String s = StatementBuilder.create() .declareVariable("str", String.class) .loadVariable("str") .invoke("endsWith", "abc") .if_() ._(Stmt.declareVariable(Integer.class).named("n").initializeWith(0)) .finish() .else_() ._(Stmt.declareVariable(Integer.class).named("n").initializeWith(1)) .finish().toJavaString(); assertEquals("Failed to generate empty if block using no rhs", IF_ELSE_BLOCK_NO_RHS, s); }
@Test public void testIfElseBlockUsingRhs() { String s = StatementBuilder.create() .declareVariable("n", Integer.class) .declareVariable("m", Integer.class) .loadVariable("n") .if_(BooleanOperator.GreaterThan, Variable.get("m")) ._(Stmt.declareVariable(Integer.class).named("n").initializeWith(0)) .finish() .else_() ._(Stmt.declareVariable(Integer.class).named("n").initializeWith(1)) .finish().toJavaString(); assertEquals("Failed to generate empty if block using a rhs", IF_ELSE_BLOCK_RHS, s); }
private Statement generateRequest(ClassStructureBuilder<?> classBuilder, MetaMethod method, Statement methodParams, boolean intercepted) { final Statement sendable = Stmt .invokeStatic(MessageBuilder.class, "createCall") .invoke("call", remote.getFullyQualifiedName()) .invoke("endpoint", ProxyUtil.createCallSignature(method), Stmt.loadClassMember("qualifiers"), methodParams) .invoke("respondTo", method.getReturnType().asBoxed(), Stmt.loadVariable("remoteCallback")) .invoke("errorsHandledBy", Stmt.loadVariable("errorCallback")); final BlockStatement requestBlock = new BlockStatement(); requestBlock.addStatement(Stmt.declareVariable("sendable", RemoteCallSendable.class, sendable)); requestBlock.addStatement(Stmt.loadStatic(classBuilder.getClassDefinition(), "this") .invoke("sendRequest", Variable.get("bus"), Variable.get("sendable"))); return requestBlock; } }
@Test public void testDeclareVariableWithStatementInitialization() { final Context ctx = Context.create(); final String s = Stmt.declareVariable("str", String.class, Stmt.nestedCall(Stmt.newObject(Integer.class).withParameters(2)).invoke("toString")) .generate(ctx); assertEquals("failed to generate variable declaration with statement initialization", "String str = new Integer(2).toString();", s); final VariableReference str = ctx.getVariable("str"); assertEquals("Wrong variable name", "str", str.getName()); Assert.assertEquals("Wrong variable type", MetaClassFactory.get(String.class), str.getType()); }
@Test public void testAssignmentOfAnonymousClass() { Statement stmt = ObjectBuilder.newInstanceOf(Retention.class) .extend() .publicOverridesMethod("annotationType") .append(Stmt.load(Retention.class).returnValue()) .finish() .finish(); Statement declaration = Stmt.declareVariable(java.lang.annotation.Annotation.class) .named("foo").initializeWith(stmt); String cls = declaration.generate(Context.create()); assertEquals("java.lang.annotation.Annotation foo = new java.lang.annotation.Retention() {\n" + " public Class annotationType() {\n" + " return java.lang.annotation.Retention.class;\n" + " }\n" + "\n" + "\n" + "};", cls); }
@Test public void testForLoopUnchainedWithDeclaringInitializerAndCountingExpression() { String s = StatementBuilder.create() .for_(Stmt.declareVariable(int.class).named("i").initializeWith(0), Bool.expr(Variable.get("i"), BooleanOperator.LessThan, 100), StatementBuilder.create().loadVariable("i").assignValue(AssignmentOperator.PreIncrementAssign, 1)) .append(StatementBuilder.create().loadStatic(System.class, "out").invoke("println", Variable.get("i"))) .finish().toJavaString(); assertEquals("Failed to generate for loop with declaring initializer and counting expression", FOR_DECLARE_INITIALIZER_COUNTING_EXP, s); }
public static void createJavaReflectionFieldInitializerUtilMethod(final ClassStructureBuilder<?> classBuilder) { if (classBuilder.getClassDefinition().getMethod(JAVA_REFL_FLD_UTIL_METH, Class.class, Field.class) != null) { return; } classBuilder.privateMethod(Field.class, JAVA_REFL_FLD_UTIL_METH).modifiers(Modifier.Static) .parameters(DefParameters.of(Parameter.of(Class.class, "cls"), Parameter.of(String.class, "name"))) .body() ._(Stmt.try_() ._(Stmt.declareVariable("fld", Stmt.loadVariable("cls").invoke("getDeclaredField", Stmt.loadVariable("name")))) ._(Stmt.loadVariable("fld").invoke("setAccessible", true)) ._(Stmt.loadVariable("fld").returnValue()) .finish() .catch_(Throwable.class, "e") ._(Stmt.loadVariable("e").invoke("printStackTrace")) ._(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish()) .finish(); }
public static void createJavaReflectionFieldInitializerUtilMethod(final ClassStructureBuilder<?> classBuilder) { if (classBuilder.getClassDefinition().getMethod(JAVA_REFL_FLD_UTIL_METH, Class.class, Field.class) != null) { return; } classBuilder.privateMethod(Field.class, JAVA_REFL_FLD_UTIL_METH).modifiers(Modifier.Static) .parameters(DefParameters.of(Parameter.of(Class.class, "cls"), Parameter.of(String.class, "name"))) .body() ._(Stmt.try_() ._(Stmt.declareVariable("fld", Stmt.loadVariable("cls").invoke("getDeclaredField", Stmt.loadVariable("name")))) ._(Stmt.loadVariable("fld").invoke("setAccessible", true)) ._(Stmt.loadVariable("fld").returnValue()) .finish() .catch_(Throwable.class, "e") ._(Stmt.loadVariable("e").invoke("printStackTrace")) ._(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish()) .finish(); }
public static void createJavaReflectionMethodInitializerUtilMethod( final ClassStructureBuilder<?> classBuilder) { if (classBuilder.getClassDefinition().getMethod(JAVA_REFL_METH_UTIL_METH, Class.class, String.class, Class[].class) != null) { return; } classBuilder.privateMethod(Method.class, JAVA_REFL_METH_UTIL_METH).modifiers(Modifier.Static) .parameters(DefParameters.of(Parameter.of(Class.class, "cls"), Parameter.of(String.class, "name"), Parameter.of(Class[].class, "parms"))) .body() ._(Stmt.try_() ._(Stmt.declareVariable("meth", Stmt.loadVariable("cls").invoke("getDeclaredMethod", Stmt.loadVariable("name"), Stmt.loadVariable("parms")))) ._(Stmt.loadVariable("meth").invoke("setAccessible", true)) ._(Stmt.loadVariable("meth").returnValue()) .finish() .catch_(Throwable.class, "e") ._(Stmt.loadVariable("e").invoke("printStackTrace")) ._(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish()) .finish(); }
public static void createJavaReflectionMethodInitializerUtilMethod( final ClassStructureBuilder<?> classBuilder) { if (classBuilder.getClassDefinition().getMethod(JAVA_REFL_METH_UTIL_METH, Class.class, String.class, Class[].class) != null) { return; } classBuilder.privateMethod(Method.class, JAVA_REFL_METH_UTIL_METH).modifiers(Modifier.Static) .parameters(DefParameters.of(Parameter.of(Class.class, "cls"), Parameter.of(String.class, "name"), Parameter.of(Class[].class, "parms"))) .body() ._(Stmt.try_() ._(Stmt.declareVariable("meth", Stmt.loadVariable("cls").invoke("getDeclaredMethod", Stmt.loadVariable("name"), Stmt.loadVariable("parms")))) ._(Stmt.loadVariable("meth").invoke("setAccessible", true)) ._(Stmt.loadVariable("meth").returnValue()) .finish() .catch_(Throwable.class, "e") ._(Stmt.loadVariable("e").invoke("printStackTrace")) ._(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish()) .finish(); }