.extend() .publicOverridesMethod("getProxy") .append(Stmt.nestedCall(Stmt.newObject(remoteProxy.getClassDefinition())).returnValue()) .finish() .finish();
private void addConstructorInjectionStatements(final Injectable injectable, final Collection<Dependency> constructorDependencies, final List<Statement> createInstanceStatements) { final Object[] constructorParameterStatements = new Object[constructorDependencies.size()]; final List<Statement> dependentScopedRegistrationStatements = new ArrayList<>(constructorDependencies.size()); for (final Dependency dep : constructorDependencies) { processConstructorDependencyStatement(createInstanceStatements, constructorParameterStatements, dependentScopedRegistrationStatements, dep); } createInstanceStatements.add(declareFinalVariable("instance", injectable.getInjectedType(), newObject(injectable.getInjectedType(), constructorParameterStatements))); createInstanceStatements.addAll(dependentScopedRegistrationStatements); }
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 static void _doRunnableTasks(final Collection<MetaClass> classes, final BlockBuilder<?> blockBuilder) { for (final MetaClass clazz : classes) { if (!clazz.isAssignableTo(Runnable.class)) { throw new RuntimeException("annotated @IOCBootstrap task: " + clazz.getName() + " is not of type: " + Runnable.class.getName()); } blockBuilder.append(Stmt.nestedCall(Stmt.newObject(clazz)).invoke("run")); } }
private String addArrayMarshaller(final MetaClass type, final boolean gwtTarget) { final String varName = getVarName(type); if (!arrayMarshallers.contains(varName)) { final String marshallerClassName = getMarshallerImplClassName(type, gwtTarget); final InnerClass arrayMarshaller = new InnerClass(generateArrayMarshaller(type, marshallerClassName, gwtTarget)); classStructureBuilder.declaresInnerClass(arrayMarshaller); addConditionalAssignment(type, Stmt.newObject(QualifyingMarshallerWrapper.class, Stmt.newObject(arrayMarshaller.getType()), type .asClass())); } arrayMarshallers.add(varName); return varName; }
private static Statement demarshal(final MetaClass type, final Statement statement) { if (type.equals(statement.getType())) { return statement; } if (MetaClassFactory.get(void.class).equals(type)) { return Stmt.load(null); } if (MetaClassFactory.get(Date.class).equals(type)) { return Stmt.newObject(Date.class, statement); } return Stmt.invokeStatic(type.asBoxed(), "valueOf", statement); } }
private String addArrayMarshaller(final MetaClass type, final boolean gwtTarget) { final String varName = getVarName(type); if (!arrayMarshallers.contains(varName)) { final String marshallerClassName = getMarshallerImplClassName(type, gwtTarget); final InnerClass arrayMarshaller = new InnerClass(generateArrayMarshaller(type, marshallerClassName, gwtTarget)); classStructureBuilder.declaresInnerClass(arrayMarshaller); addConditionalAssignment(type, Stmt.newObject(QualifyingMarshallerWrapper.class, Stmt.newObject(arrayMarshaller.getType()), type .asClass())); } arrayMarshallers.add(varName); return varName; }
private Statement initializeProxyHelper(final Injectable injectable) { return newObject( parameterizedAs(ProxyHelperImpl.class, typeParametersOf(injectable.getInjectedType())), injectable.getFactoryName()); }
private void assignNewObjectWithZeroArgConstructor(final Injectable injectable, final List<Statement> createInstanceStatements) { final MetaConstructor noArgConstr = injectable.getInjectedType().getDeclaredConstructor(new MetaClass[0]); final Object newObjectStmt; if (noArgConstr.isPublic()) { newObjectStmt = newObject(injectable.getInjectedType()); } else { newObjectStmt = controller.exposedConstructorStmt(noArgConstr); } createInstanceStatements.add(declareFinalVariable("instance", injectable.getInjectedType(), newObjectStmt)); }
/** * 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 ObjectBuilder createAnonymousImpl(final MetaClass type) { final AnonymousClassStructureBuilder builder = newObject(type).extend(); stream(type.getMethods()) .filter(m -> m.isPublic() && m.isAbstract()) .forEach(m -> { builder .publicOverridesMethod(m.getName(), of(m.getParameters())) .append(Stmt.throw_(RuntimeException.class)) .finish(); }); return builder.finish(); }
@Override public void generateDecorator(final Decorable decorable, final FactoryController controller) { final Statement callbackStmt = Stmt.newObject(Runnable.class).extend() .publicOverridesMethod("run") .append(decorable.getAccessStatement()) .finish() .finish(); controller.addInitializationStatements(Collections.<Statement>singletonList(Stmt.invokeStatic(InitVotes.class, "registerOneTimeInitCallback", callbackStmt))); } }
public static void autoInitializedField(final ClassStructureBuilder<?> builder, final MetaClass type, final String name, MetaClass implementation) { implementation = MetaClassFactory.parameterizedAs(implementation, type.getParameterizedType()); builder.privateField(name, type) .initializesWith(Stmt.newObject(implementation)).finish(); }
public static void autoInitializedField(final ClassStructureBuilder<?> builder, final MetaClass type, final String name, MetaClass implementation) { implementation = MetaClassFactory.parameterizedAs(implementation, type.getParameterizedType()); builder.privateField(name, type) .initializesWith(Stmt.newObject(implementation)).finish(); }
@Test public void testObjectCreationOfUninstantiableType() { try { Stmt.newObject(List.class).toJavaString(); fail("Expected InvalidTypeExcpetion"); } catch (InvalidTypeException e) { // Expected, List is not instantiable } }
/** * Generates an anonymous {@link DataSyncCallback} that will invoke the decorated sync method. */ private Statement createSyncCallback(Decorable decorable) { return Stmt.newObject(DataSyncCallback.class) .extend() .publicOverridesMethod("onSync", Parameter.of(SyncResponses.class, "responses", true)) .append(decorable.getAccessStatement(Stmt.loadVariable("responses"))) .finish() .finish(); }
private ObjectBuilder createJsTypeProvider(final MetaClass type) { return newObject(DummyJsTypeProvider.class) .extend() .publicOverridesMethod("getInstance") .append(nestedCall(createAnonymousImpl(type)).returnValue()) .finish() .publicOverridesMethod("getName") .append(loadLiteral("Anti-inlining impl for: " + type.getFullyQualifiedName()).returnValue()) .finish() .finish(); }
@Test public void testAssignField() { final String s = Stmt.create(Context.create().autoImport()).nestedCall( Stmt.newObject(Foo.class)).loadField("bar").loadField("name").assignValue("test").toJavaString(); assertEquals("failed to generate nested field assignment", "new Foo().bar.name = \"test\";", s); }
@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()); }