@Override public Statement newObject(final Class<?> type, final Object... parameters) { return ObjectBuilder.newInstanceOf(type, context, callElementBuilder) .withParameters(parameters); }
@Override public Statement newObject(final MetaClass type, final Object... parameters) { return ObjectBuilder.newInstanceOf(type, context, callElementBuilder) .withParameters(parameters); }
@Override public Statement newObject(final TypeLiteral<?> type, final Object... parameters) { return ObjectBuilder.newInstanceOf(type, context, callElementBuilder) .withParameters(parameters); }
@Override public Statement newObject(final MetaClass type, final Object... parameters) { return ObjectBuilder.newInstanceOf(type, context, callElementBuilder) .withParameters(parameters); }
@Override public Statement newObject(final TypeLiteral<?> type, final Object... parameters) { return ObjectBuilder.newInstanceOf(type, context, callElementBuilder) .withParameters(parameters); }
@Override public Statement newObject(final Class<?> type, final Object... parameters) { return ObjectBuilder.newInstanceOf(type, context, callElementBuilder) .withParameters(parameters); }
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(); }
public static StringBuilderBuilder newStringBuilder(final int length) { final ContextualStatementBuilder statementBuilder = Stmt.nestedCall(Stmt.newObject(StringBuilder.class).withParameters(length)); return new StringBuilderBuilder() { @Override public StringBuilderBuilder append(final Object statement) { statementBuilder.invoke("append", statement); return this; } String generatedCache; @Override public String generate(final Context context) { if (generatedCache != null) return generatedCache; return generatedCache = statementBuilder.generate(context); } @Override public MetaClass getType() { return statementBuilder.getType(); } }; }
public static StringBuilderBuilder newStringBuilder(final int length) { final ContextualStatementBuilder statementBuilder = Stmt.nestedCall(Stmt.newObject(StringBuilder.class).withParameters(length)); return new StringBuilderBuilder() { @Override public StringBuilderBuilder append(final Object statement) { statementBuilder.invoke("append", statement); return this; } String generatedCache; @Override public String generate(final Context context) { if (generatedCache != null) return generatedCache; return generatedCache = statementBuilder.generate(context); } @Override public MetaClass getType() { return statementBuilder.getType(); } }; }
@Override public String generate(Context context) { StringBuilder buf = new StringBuilder(); try { buf.append("throw "); if (throwableType != null) { buf.append(ObjectBuilder.newInstanceOf(throwableType).withParameters(parameters).generate(context)); } else { VariableReference exceptionVar = context.getVariable(exceptionVariableName); if (!exceptionVar.getType().isAssignableTo(Throwable.class)) { throw new InvalidTypeException("Variable " + exceptionVariableName + " is not a Throwable"); } buf.append(exceptionVar.generate(context)); } } catch (GenerationException e) { blameAndRethrow(e); } return buf.toString(); } };
@Override public String generate(Context context) { StringBuilder buf = new StringBuilder(); try { buf.append("throw "); if (throwableType != null) { buf.append(ObjectBuilder.newInstanceOf(throwableType).withParameters(parameters).generate(context)); } else { VariableReference exceptionVar = context.getVariable(exceptionVariableName); if (!exceptionVar.getType().isAssignableTo(Throwable.class)) { throw new InvalidTypeException("Variable " + exceptionVariableName + " is not a Throwable"); } buf.append(exceptionVar.generate(context)); } } catch (GenerationException e) { blameAndRethrow(e); } return buf.toString(); } };
/** * 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; }
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; }
@Test public void testObjectCreationWithLiteralParameter() { final String s = StatementBuilder.create().newObject(String.class).withParameters("original").toJavaString(); assertEquals("failed to generate new object with parameters", "new String(\"original\")", s); }
@Test public void testDeclareVariableWithObjectInitializationWithParameters() { String declaration = ContextBuilder.create() .declareVariable("str", String.class) .initializeWith(ObjectBuilder.newInstanceOf(String.class).withParameters("abc")) .toJavaString(); assertEquals("failed to generate variable declaration using an objectbuilder initialization with parameters", "String str = new String(\"abc\");", declaration); }
@Test public void testObjectCreationWithVariableParameter() { final String s = StatementBuilder.create() .declareVariable("original", String.class) .newObject(String.class).withParameters(Variable.get("original")).toJavaString(); assertEquals("failed to generate new object with parameters", "new String(original)", s); }
@Test public void testDeclareVariableWithObjectInitializationUsingSuperClassType() { String declaration = ContextBuilder.create() .declareVariable("str", Object.class) .initializeWith(ObjectBuilder.newInstanceOf(String.class).withParameters("abc")) .toJavaString(); assertEquals("failed to generate variable declaration using an objectbuilder initialization with parameters", "Object str = new String(\"abc\");", declaration); try { Stmt.declareVariable("str", Integer.class, ObjectBuilder.newInstanceOf(String.class).withParameters("abc")) .toJavaString(); fail("Expected InvalidTypeException"); } catch (InvalidTypeException e) { // expected } try { Stmt.declareVariable("str", String.class, ObjectBuilder.newInstanceOf(Object.class)) .toJavaString(); fail("Expected InvalidTypeException"); } catch (InvalidTypeException e) { // expected } }
@Test public void testPassBitwiseToMethodParameter() { final Statement bitwiseStatement = Bitwise.or(Stmt.load(1), Stmt.load(2), Expr.qualify(Bitwise.and(Stmt.load(10), Stmt.load(20)))); final String generate = Stmt.newObject(Integer.class).withParameters(bitwiseStatement).generate(Context.create()); assertEquals("new Integer(1 | 2 | (10 & 20))", generate); }
@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()); }
private Statement generateFactoryHandle(final Injectable injectable, @SuppressWarnings("rawtypes") final BlockBuilder curMethod) { final String handleVarName = "handleFor" + injectable.getFactoryName(); curMethod.append(declareFinalVariable(handleVarName, FactoryHandleImpl.class, ObjectBuilder.newInstanceOf(FactoryHandleImpl.class) .withParameters(loadLiteral(injectable.getInjectedType()), loadLiteral(injectable.getFactoryName()), loadLiteral(injectable.getScope()), loadLiteral(false), loadLiteral(injectable.getBeanName()), loadLiteral(!injectable.isContextual())))); curMethod.append(loadVariable(handleVarName).invoke("setAssignableTypes", getAssignableTypesArrayStmt(injectable))); if (!injectable.getQualifier().isDefaultQualifier()) { curMethod.append(loadVariable(handleVarName).invoke("setQualifiers", getAnnotationArrayStmt(injectable.getQualifier()))); } return loadVariable(handleVarName); }