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(); }
protected void addReturnStatement(final List<Statement> createInstanceStatements) { createInstanceStatements.add(loadVariable("this").invoke("setIncompleteInstance", loadLiteral(null))); createInstanceStatements.add(loadVariable("instance").returnValue()); }
@Override protected List<Statement> generateCreateInstanceStatements(final ClassStructureBuilder<?> bodyBlockBuilder, final Injectable injectable, final DependencyGraph graph, final InjectionContext injectionContext) { return Arrays.asList(Stmt.loadLiteral(value).returnValue()); } };
@Override protected List<Statement> generateCreateInstanceStatements(final ClassStructureBuilder<?> bodyBlockBuilder, final Injectable injectable, final DependencyGraph graph, final InjectionContext injectionContext) { final List<Statement> statements = new ArrayList<>(validators.size()+2); statements.add(Stmt.declareFinalVariable("dynamicValidator", DynamicValidator.class, ObjectBuilder.newInstanceOf(DynamicValidator.class))); bodyBlockBuilder.privateField("messageResolver", ValidationMessageResolver.class) .initializesWith(Stmt.invokeStatic(GWT.class, "create", Stmt.loadLiteral(ProviderValidationMessageResolver.class))).finish(); validators .stream() .map(validator -> addDynamicValidator(bodyBlockBuilder, validator)) .collect(Collectors.toCollection(() -> statements)); statements.add(loadVariable("dynamicValidator").returnValue()); return statements; }
private static Statement createMarshallerLookup(final MetaClass marshallerForType, final MetaClass type, final Statement marshallerCreationCallback) { Statement marshallerLookup = null; if (type.equals(marshallerForType)) { marshallerLookup = Stmt.loadVariable("this"); } else if (marshallerCreationCallback == null) { marshallerLookup = Stmt.invokeStatic(Marshalling.class, "getMarshaller", Stmt.loadLiteral(type.asBoxed())); } else { marshallerLookup = Stmt.invokeStatic(Marshalling.class, "getMarshaller", Stmt.loadLiteral(type.asBoxed().asClass()), marshallerCreationCallback); } return marshallerLookup; } }
private static Statement createMarshallerLookup(final MetaClass marshallerForType, final MetaClass type, final Statement marshallerCreationCallback) { Statement marshallerLookup = null; if (type.equals(marshallerForType)) { marshallerLookup = Stmt.loadVariable("this"); } else if (marshallerCreationCallback == null) { marshallerLookup = Stmt.invokeStatic(Marshalling.class, "getMarshaller", Stmt.loadLiteral(type.asBoxed())); } else { marshallerLookup = Stmt.invokeStatic(Marshalling.class, "getMarshaller", Stmt.loadLiteral(type.asBoxed().asClass()), marshallerCreationCallback); } return marshallerLookup; } }
private void implementConstructor(final ClassStructureBuilder<?> proxyImpl, final MetaConstructor accessibleConstructor) { final Object[] args = new Object[accessibleConstructor.getParameters().length]; for (int i = 0; i < args.length; i++) { args[i] = loadLiteral(null); } proxyImpl.publicConstructor().callSuper(args).finish(); }
protected ContextualStatementBuilder lookupProviderStmt(final Injectable providerInjectable, final MetaClass paramterizedProviderType) { final ContextualStatementBuilder provider = castTo(paramterizedProviderType, loadVariable("contextManager").invoke("getInstance", loadLiteral(providerInjectable.getFactoryName()))); return provider; }
/** * Generates code to call * {@link Factory#getReferenceAs(Object, String, Class)} for an instance in * {@link Factory#createInstance(org.jboss.errai.ioc.client.container.ContextManager)} * and * {@link Factory#destroyInstance(Object, org.jboss.errai.ioc.client.container.ContextManager)} * methods. */ public static ContextualStatementBuilder constructGetReference(final String name, final MetaClass refType) { // This cast is for the benefit of codegen, which is sometimes unable to // identify the value for the type parameter of Factory.getReferenceAs. return castTo(refType, loadVariable("thisInstance").invoke("getReferenceAs", loadVariable("instance"), name, loadLiteral(refType))); }
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); }
private ContextualStatementBuilder getInjectedValue(final Injectable depInjectable, final ParamDependency paramDep) { final ContextualStatementBuilder injectedValue; if (depInjectable.isContextual()) { final MetaClass[] typeArgsClasses = getTypeArguments(paramDep.getParameter().getType()); final Annotation[] qualifiers = getQualifiers(paramDep.getParameter()).toArray(new Annotation[0]); injectedValue = castTo(depInjectable.getInjectedType(), loadVariable("contextManager").invoke("getContextualInstance", loadLiteral(depInjectable.getFactoryName()), typeArgsClasses, qualifiers)); } else { injectedValue = castTo(depInjectable.getInjectedType(), loadVariable("contextManager").invoke("getInstance", loadLiteral(depInjectable.getFactoryName()))); } return injectedValue; } }
protected Statement generateFactoryHandleStatement(final Injectable injectable) { final Statement newObject; if (injectable.getInjectedType().isAnnotationPresent(ActivatedBy.class)) { final Class<? extends BeanActivator> activatorType = injectable.getInjectedType().getAnnotation(ActivatedBy.class).value(); newObject = newObject(FactoryHandleImpl.class, loadLiteral(injectable.getInjectedType()), injectable.getFactoryName(), injectable.getScope(), isEager(injectable.getInjectedType()), injectable.getBeanName(), !injectable.isContextual(), loadLiteral(activatorType)); } else { newObject = newObject(FactoryHandleImpl.class, loadLiteral(injectable.getInjectedType()), injectable.getFactoryName(), injectable.getScope(), isEager(injectable.getInjectedType()), injectable.getBeanName(), !injectable.isContextual()); } return newObject; }
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(); }
private ObjectBuilder createAnnoImpl(final MetaClass annoType) { final AnonymousClassStructureBuilder builder = ObjectBuilder.newInstanceOf(annoType).extend(); Arrays.stream(annoType.getDeclaredMethods()) .forEach(m -> builder.publicOverridesMethod(m.getName()) .append(castTo(m.getReturnType(), loadVariable("parameters").invoke("get", m.getName())).returnValue()).finish()); builder.publicOverridesMethod("annotationType").append(loadLiteral(annoType).returnValue()).finish(); return builder.finish(); }
@Override public Statement resolve(DotNode dotNode) { Class<?> lhsType = dotNode.getLhs().getDataType().getReturnedClass(); // ensure the attribute is available as a field of the comparator String attrVarName = dotNode.getPath().replace('.', '_') + "_attr"; if (containingClass != null && !generatedClassVariables.contains(attrVarName)) { generatedClassVariables.add(attrVarName); containingClass.privateField(attrVarName, ErraiAttribute.class) .modifiers(Modifier.Final) .initializesWith( Stmt.nestedCall(new StringStatement("entityManager.getMetamodel()", MetaClassFactory.get(ErraiMetamodel.class))) .invoke("entity", Stmt.loadLiteral(lhsType)) .invoke("getAttribute", dotNode.getPropertyPath())) .finish(); } // XXX need a StringStatement here because codegen can't see fields of anonymous inner classes. (ERRAI-363) return Stmt.nestedCall(new StringStatement(attrVarName, MetaClassFactory.get(ErraiAttribute.class))) .invoke("get", Stmt.loadVariable(variableName)); } }
private void createPutMarshallerMethod() { classStructureBuilder .privateMethod(boolean.class, "putMarshaller", Parameter.of(String.class, "fqcn"), Parameter.of(Marshaller.class, "m")) .append(Stmt.loadVariable(MARSHALLERS_VAR).invoke("put", Stmt.loadVariable("fqcn"), Stmt.loadVariable("m"))) .append(Stmt.loadLiteral(true).returnValue()) .finish(); }
private void createPutMarshallerMethod() { classStructureBuilder .privateMethod(boolean.class, "putMarshaller", Parameter.of(String.class, "fqcn"), Parameter.of(Marshaller.class, "m")) .append(Stmt.loadVariable(MARSHALLERS_VAR).invoke("put", Stmt.loadVariable("fqcn"), Stmt.loadVariable("m"))) .append(Stmt.loadLiteral(true).returnValue()) .finish(); }
private Statement generateFactoryLoader(final Injectable injectable, final MetaClass factoryClass) { final Statement runAsyncCallback = ObjectBuilder.newInstanceOf(DefaultRunAsyncCallback.class).extend() .publicOverridesMethod("onSuccess").append(loadVariable("callback").invoke("callback", castTo(Factory.class, invokeStatic(GWT.class, "create", loadLiteral(factoryClass))))) .finish().finish(); final Class<?> fragmentId = getAsyncFragmentId(injectable); final Object[] runAsyncParams = (fragmentId.equals(LoadAsync.NO_FRAGMENT.class) ? new Object[] { runAsyncCallback } : new Object[] { fragmentId, runAsyncCallback }); return ObjectBuilder.newInstanceOf(FactoryLoader.class).extend() .publicOverridesMethod("call", finalOf(FactoryLoaderCallback.class, "callback")) .append(invokeStatic(GWT.class, "runAsync", runAsyncParams)).finish().finish(); }
private Statement createJsTypeProviderFor(final Injectable injectable) { final MetaClass type = injectable.getInjectedType(); final AnonymousClassStructureBuilder jsTypeProvider = newInstanceOf(parameterizedAs(JsTypeProvider.class, typeParametersOf(type))).extend(); jsTypeProvider .publicOverridesMethod("getInstance") .append(Stmt.castTo(type, loadVariable("contextManager").invoke("getInstance", injectable.getFactoryName())) .returnValue()).finish() .publicOverridesMethod("getName") .append(Stmt.loadLiteral(getBeanName(injectable)).returnValue()) .finish() .publicOverridesMethod("getFactoryName") .append(Stmt.loadLiteral(injectable.getFactoryName()).returnValue()) .finish() .publicOverridesMethod("getQualifiers") .append(Stmt.nestedCall(Stmt.newObject(parameterizedAs(JsArray.class, typeParametersOf(String.class)), Stmt.loadLiteral(AnnotationSerializer.serialize(injectable.getQualifier().iterator())))).returnValue()) .finish(); return jsTypeProvider.finish(); }
/** * Adds the public override method {@code matches(JSONObject candidate)} to * the given class builder. The matching logic is, of course, generated based * on the JPA query this generator was created with. * * @param classBuilder * The class builder to append the generated matcher method to. */ private void appendMatchesMethod(AnonymousClassStructureBuilder classBuilder) { AstInorderTraversal traverser = new AstInorderTraversal(query.getSqlAST().getWalker().getAST()); AST whereClause = traverser.fastForwardTo(HqlSqlTokenTypes.WHERE); BlockBuilder<?> matchesMethod = classBuilder .publicOverridesMethod("matches", Parameter.of(JSONObject.class, "candidate")); Statement matchesStmt; if (whereClause != null) { matchesStmt = generateExpression(traverser, new JsonDotNodeResolver(), matchesMethod); } else { matchesStmt = Stmt.loadLiteral(true); } matchesMethod.append(Stmt.nestedCall(matchesStmt).returnValue()); matchesMethod.finish(); }