private static Statement marshal(final MetaClass type, final Statement statement) { ContextualStatementBuilder s = null; if (type.isPrimitive()) { s = Stmt.nestedCall(Stmt.newObject(type.asBoxed()).withParameters(statement)).invoke("toString"); } else if (type.getFullyQualifiedName().equals(Date.class.getName())) { s = Stmt.nestedCall(new TernaryStatement(Bool.isNull(statement), Stmt.load(""), Stmt.nestedCall(statement).invoke("toGMTString"))); } else { s = Stmt.nestedCall(new TernaryStatement(Bool.isNull(statement), Stmt.load(""), Stmt.nestedCall(statement))); if (!type.equals(MetaClassFactory.get(String.class))) { s = s.invoke("toString"); } } return s; }
private Statement generateCascadesMethod(MetaMethod method, Object sourceObject) { Attribute<?, ?> attr = (Attribute<?, ?>) sourceObject; // grab cascade annotations from live object then generate a statement like // return (cascadeType == [type] || cascadeType == [type] || ...) CascadeType[] cascadeTypes = extractCascadeTypes(getJavaMember(attr)); if (cascadeTypes == null) { return Stmt.throw_(UnsupportedOperationException.class, "Not a relationship attribute"); } if (cascadeTypes.length == 0) { return Stmt.loadLiteral(false).returnValue(); } BooleanExpression megaExpr = null; for (CascadeType type : cascadeTypes) { if (type == CascadeType.ALL) { // if the list includes ALL, abandon megaExpr and just return true return Stmt.loadLiteral(true).returnValue(); } BooleanExpression comparison = Bool.equals(Stmt.loadVariable(method.getParameters()[0].getName()), Stmt.loadLiteral(type)); if (megaExpr == null) { megaExpr = comparison; } else { megaExpr = Bool.or(comparison, megaExpr); } } return Stmt.load(megaExpr).returnValue(); }
classStructureBuilder.privateField("EMPTY_ARRAY", arrayType).initializesWith(Stmt.newArray(toMap, 0)).finish(); .append(Stmt.loadClassMember("EMPTY_ARRAY").returnValue()) .finish(); Parameter.of(EJValue.class, "a0"), Parameter.of(MarshallingSession.class, "a1")); builder.append(If.cond(Bool.isNull(Refs.get("obj"))).append(Stmt.load(null).returnValue()).finish()); builder.append( Stmt.if_(Bool.expr(loadVariable("a1").invoke("hasObject", loadVariable("objId")))) .append(loadVariable("a1") .invoke("getObject", toMap, loadVariable("objId")).returnValue()).finish()); .loadVariable("keys") .foreach("key", String.class) .append(Stmt.if_(Bool.or(loadVariable("key").invoke("equals", SerializationParts.ENCODED_TYPE), loadVariable("key").invoke("equals", SerializationParts.OBJECT_ID))) .append(Stmt.continue_()).finish()) .append(Stmt.declareVariable("objVal", EJValue.class, extractJSONObjectProperty(loadVariable("key"), EJObject.class, "getIfNotNull"))) .append(Stmt.if_(Bool.isNull(loadVariable("objVal"))).append(Stmt.continue_()).finish()) .append(switchBlock = Stmt.switch_(loadVariable("key"))) .finish());
.append(loadVariable("this").invoke("initialize", annoImpl)) .append(if_(Bool.expr(loadVariable("this").invoke("isValid", loadVariable("value"), castTo(ConstraintValidatorContext.class, loadLiteral(null))))) .append(invokeStatic(Collections.class, "emptySet").returnValue()) .finish().else_() .append(Stmt.declareVariable("paramMessage", String.class, castTo(String.class, loadVariable("parameters").invoke("get", Stmt.loadLiteral("message"))))) .append(Stmt.loadVariable("paramMessage").assignValue( new TernaryStatement(Bool.isNotNull(Stmt.loadVariable("paramMessage")), Stmt.loadVariable("paramMessage") .invoke("replaceAll", Stmt.loadLiteral("{"), Stmt.loadLiteral("")) .invoke("replaceAll", Stmt.loadLiteral("}"), Stmt.loadLiteral("")) ,Stmt.loadLiteral("")))) .append(Stmt.declareFinalVariable("message", String.class, Stmt.loadVariable("messageResolver").invoke("get", Refs.get("paramMessage")))) .append(invokeStatic(Collections.class, "singleton", createConstraintViolation()).returnValue()) .finish()) .finish();
BlockBuilder<CaseBlockBuilder> caseBlock = switchBlock.case_(property); caseBlock .append(target().invoke(setterMethod.getName(), Cast.to(setterMethod.getParameters()[0].getType().asBoxed(), Variable.get("value")))) .append(Stmt.break_()) .finish(); wrappedListProperty = Stmt.loadVariable(property).assignValue( Cast.to(paramType, agent().invoke("ensureBoundListIsProxied", property, Stmt.loadVariable(property)))); target().invoke(setterMethod.getName(), Cast.to(paramType, Stmt.loadVariable(property))); if (!setterMethod.getReturnType().equals(MetaClassFactory.get(void.class))) { callSetterOnTarget = if (DataBindingUtil.isBindableType(paramType)) { updateNestedProxy = Stmt.if_(Bool.expr(agent("binders").invoke("containsKey", property))) .append(Stmt.loadVariable(property).assignValue(Cast.to(paramType, agent("binders").invoke("get", property).invoke("setModel", Variable.get(property), Stmt.loadStatic(StateSync.class, "FROM_MODEL"), .append(updateNestedProxy) .append(wrappedListProperty) .append(loadVariable("this").invoke("changeAndFire", property, Variable.get(property))) .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( Bool.or(Bool.isNull(Stmt.loadVariable("fv" + idx)), Stmt.loadVariable("fv" + idx).invoke("isEmpty"))) .append( Stmt.loadVariable("this").invoke(injectorName, Stmt.loadVariable("widget"),
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(); interceptorStack = interceptorStack.elseif_(Bool.equals( Stmt.loadVariable("status").invoke("getNextInterceptor"), interceptor)) .append(Stmt.declareFinalVariable("ctx", callContextType, Stmt.loadVariable("this"))) .append( Stmt.declareVariable(CreationalCallback.class).asFinal().named("icc") .append(Stmt.loadVariable("status").invoke("setProceeding", false)) .append( Stmt.castTo(interceptor, Stmt.loadVariable("beanInstance")).invoke("aroundInvoke", Variable.get("ctx"))) .append( If.cond(Bool.and( Bool.notExpr(Stmt.loadVariable("status").invoke("isProceeding")), Bool.equals(Stmt.loadLiteral(interceptor), Stmt.loadVariable("status").invoke("getNextInterceptor")))) .append( Stmt.loadVariable("remoteCallback").invoke("callback",
comparator = Stmt.loadLiteral(null); .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(); .append(Stmt.nestedCall(comparator).returnValue()) .finish();
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(); }
@Test public void testLoopWithBreak() { String s = StatementBuilder.create() .declareVariable("i", Integer.class, 0) .loadVariable("i") .if_(BooleanOperator.GreaterThan, 100) .append(Stmt .for_(Stmt.loadVariable("i").assignValue(0), Bool.expr(Variable.get("i"), BooleanOperator.LessThan, 100), Stmt.loadVariable("i").assignValue(AssignmentOperator.PreIncrementAssign, 1)) .append(Stmt .if_(Bool.expr(Variable.get("i"), BooleanOperator.Equals, 50)) .append(Stmt.break_()) .finish()) .finish()) .finish() .toJavaString(); assertEquals("Failed to generate loop with continue", LOOP_WITH_BREAK, s); }
return Bool.notExpr(Stmt.invokeStatic( Comparisons.class, "nullSafeEquals", generateExpression(traverser, dotNodeResolver, containingMethod), generateExpression(traverser, dotNodeResolver, containingMethod))); Statement small = generateExpression(traverser, dotNodeResolver, containingMethod); Statement big = generateExpression(traverser, dotNodeResolver, containingMethod); return Bool.and( Statement small = generateExpression(traverser, dotNodeResolver, containingMethod); Statement big = generateExpression(traverser, dotNodeResolver, containingMethod); return Bool.or( return notIn ? Bool.notExpr(callToComparisonsIn) : callToComparisonsIn; return ast.getType() == HqlSqlTokenTypes.LIKE ? likeStmt : Bool.notExpr(likeStmt); return Bool.isNull(generateExpression(traverser, dotNodeResolver, containingMethod)); return Bool.isNotNull(generateExpression(traverser, dotNodeResolver, containingMethod)); return Bool.or(generateExpression(traverser, dotNodeResolver, containingMethod), generateExpression(traverser, dotNodeResolver, containingMethod)); return Bool.and(generateExpression(traverser, dotNodeResolver, containingMethod), generateExpression(traverser, dotNodeResolver, containingMethod)); return Bool.notExpr(generateExpression(traverser, dotNodeResolver, containingMethod)); trimChar = Stmt.nestedCall(trimStr).invoke("charAt", 0); ast = traverser.fastForwardTo(ast.getNextSibling());
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();
public Statement demarshallEnum(final Statement objStatement, final Statement valStatement, final MetaClass toType) { final Statement trueStatement = Stmt.invokeStatic(Enum.class, "valueOf", toType, Stmt.nestedCall(objStatement) .invoke("get", SerializationParts.ENUM_STRING_VALUE).invoke("isString").invoke("stringValue")); final Statement falseStatement = (valStatement != null) ? new TernaryStatement(Bool.isNotNull(Stmt.nestedCall(valStatement).invoke("isString")), Stmt.invokeStatic(Enum.class, "valueOf", toType, Stmt.nestedCall(valStatement).invoke("isString").invoke("stringValue")), Stmt.load(null)) : Stmt.load(null); return new TernaryStatement(Bool.isNotNull(objStatement), trueStatement, falseStatement); }
@Test public void testIfBlockUnchainedWithNestedExpressions() { Context ctx = Context.create().addVariable("a", boolean.class) .addVariable("b", boolean.class); String s = Stmt.create(ctx) .if_(Bool.expr( Bool.expr("foo", BooleanOperator.Equals, "bar"), BooleanOperator.Or, Bool.expr( Bool.expr("cat", BooleanOperator.Equals, "dog"), BooleanOperator.And, Bool.expr("girl", BooleanOperator.NotEquals, "boy")))) .finish() .elseif_(Bool.expr(Stmt.loadVariable("a"), BooleanOperator.And, Stmt.loadVariable("b"))) .append(Stmt.loadStatic(System.class, "out").invoke("println", Refs.get("a"))) .finish() .toJavaString(); assertEquals("Failed to generate if block using nested boolean expressions", IF_ELSEIF_BLOCK_UNCHAINED_NESTED_EXPRESSIONS, s); }
Bool.notEquals(Stmt.loadVariable("candidate").invoke("get", dotNode.getPropertyPath()).invoke("isNull"), null), Stmt.loadLiteral(null), Stmt.loadVariable("entityManager").invoke("find", Stmt.invokeStatic(Key.class, "fromJsonObject", Stmt.loadVariable("entityManager"), Stmt.loadVariable("candidate").invoke("get", dotNode.getPropertyPath()).invoke("isObject"), false), Stmt.loadStatic(Collections.class, "EMPTY_MAP")));
@Test public void testDoWhileLoopUnchainedWithNestedExpressions() { String s = StatementBuilder.create() .declareVariable("str", String.class) .do_() .append(StatementBuilder.create().loadStatic(System.class, "out").invoke("println", Variable.get("str"))) .finish() .while_(Bool.expr( Bool.expr(Variable.get("str"), BooleanOperator.NotEquals, null), BooleanOperator.And, Bool.expr(Stmt.loadVariable("str").invoke("length"), BooleanOperator.GreaterThan, 0))) .toJavaString(); assertEquals("Failed to generate do while loop with nested expression", DOWHILE_NESTED_EXPRESSION, s); }
if (jsinteropSupportEnabled && (jsType || windowScoped)) { final List<Statement> stmts = new ArrayList<>(); stmts.add(loadVariable("windowContext").invoke("addBeanProvider", injectable.getInjectedType().getFullyQualifiedName(), createJsTypeProviderFor(injectable))); for (final MetaClass mc : injectable.getInjectedType().getAllSuperTypesAndInterfaces()) { if (mc.isPublic() && !mc.equals(injectable.getInjectedType()) && !mc.getFullyQualifiedName().equals("java.lang.Object") && mc.isAnnotationPresent(JsType.class)) { stmts.add(loadVariable("windowContext").invoke("addSuperTypeAlias", mc.getFullyQualifiedName(), injectable.getInjectedType().getFullyQualifiedName())); .append(If .cond(Bool.expr(loadVariable("windowContext").invoke("hasProvider", injectable.getInjectedType().getFullyQualifiedName())).negate()) .appendAll(stmts).finish());
@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); }