/** * @return True iff the enclosing injectable is {@link Dependent} scoped. */ public boolean isEnclosingTypeDependent() { return injectable.getWiringElementTypes().contains(WiringElementType.DependentBean); }
@Override public boolean matches(final Injectable injectable) { return injectable.getWiringElementTypes().contains(WiringElementType.Simpleton); } },
@Override public boolean canValidate(final Injectable injectable) { return injectable.getWiringElementTypes().contains(WiringElementType.PseudoScopedBean) && !visited.contains(injectable); }
private void logAddedInjectable(final Injectable injectable) { logger.debug("Adding new injectable: {}", injectable); if (logger.isTraceEnabled()) { logger.trace("Injectable type: {}", injectable.getInjectableType()); logger.trace("Injectable wiring types: {}", injectable.getWiringElementTypes()); } }
private Predicate<Injectable> reachabilityRootPredicate(final ReachabilityStrategy strategy) { switch (strategy) { case All: return inj -> true; case Annotated: return inj -> !inj.getWiringElementTypes().contains(WiringElementType.Simpleton); case Aggressive: return inj -> EntryPoint.class.equals(inj.getScope()) || inj.getWiringElementTypes().contains(WiringElementType.JsType); default: throw new RuntimeException("Unrecognized reachability strategy, " + strategy.toString()); } }
@Override public boolean matches(final Injectable injectable) { return matchingTypes.contains(injectable.getInjectableType()) && !injectable.getWiringElementTypes().contains(WiringElementType.Simpleton); } },
@Override public boolean matches(final Injectable injectable) { return injectable.getWiringElementTypes().contains(WiringElementType.AlternativeBean) && !InjectableType.Disabled.equals(injectable.getInjectableType()); } },
@Override public boolean matches(final Injectable injectable) { return injectable.getInjectableType().equals(InjectableType.JsType) && injectable.getWiringElementTypes().contains(WiringElementType.SharedSingleton); } },
private static void validateDependentScopedInjectable(final Injectable injectable, final Set<Injectable> visiting, final Set<Injectable> visited, final Collection<String> problems, final boolean onlyConstuctorDeps) { if (InjectableType.Disabled.equals(injectable.getInjectableType())) { visited.add(injectable); return; } if (visiting.contains(injectable)) { problems.add(createCycleMessage(visiting, injectable)); return; } visiting.add(injectable); for (final Dependency dep : injectable.getDependencies()) { if (onlyConstuctorDeps && !dep.getDependencyType().equals(DependencyType.Constructor)) { continue; } final Injectable resolved = GraphUtil.getResolvedDependency(dep, injectable); if (!visited.contains(resolved)) { if (dep.getDependencyType().equals(DependencyType.ProducerMember)) { validateDependentScopedInjectable(resolved, visiting, visited, problems, true); } else if (resolved.getWiringElementTypes().contains(WiringElementType.PseudoScopedBean)) { validateDependentScopedInjectable(resolved, visiting, visited, problems, false); } } } visiting.remove(injectable); visited.add(injectable); }
private void addFieldInjectionPoints(final Injectable typeInjectable, final DependencyGraphBuilder builder, final List<String> problems) { final boolean noPublicFieldsAllowed = typeInjectable.getWiringElementTypes().contains(WiringElementType.NormalScopedBean); final MetaClass type = typeInjectable.getInjectedType(); final Collection<Class<? extends Annotation>> injectAnnotations = injectionContext.getAnnotationsForElementType(WiringElementType.InjectionPoint); for (final Class<? extends Annotation> inject : injectAnnotations) { for (final MetaField field : type.getFieldsAnnotatedWith(inject)) { if (noPublicFieldsAllowed && field.isPublic()) { problems.add("The normal scoped bean " + type.getFullyQualifiedName() + " has a public field " + field.getName()); } builder.addFieldDependency(typeInjectable, field.getType(), qualFactory.forSink(field), field); } } }
private void processConstructorDependencyStatement(final List<Statement> createInstanceStatements, final Object[] constructorParameterStatements, final List<Statement> dependentScopedRegistrationStatements, final Dependency dep) { final Injectable depInjectable = dep.getInjectable(); final ParamDependency paramDep = ParamDependency.class.cast(dep); final ContextualStatementBuilder injectedValue = getInjectedValue(depInjectable, paramDep); final String paramLocalVarName = getLocalVariableName(paramDep.getParameter()); createInstanceStatements.add(declareFinalVariable(paramLocalVarName, paramDep.getParameter().getType(), injectedValue)); if (dep.getInjectable().getWiringElementTypes().contains(WiringElementType.DependentBean)) { dependentScopedRegistrationStatements.add(loadVariable("this").invoke("registerDependentScopedReference", loadVariable("instance"), loadVariable(paramLocalVarName))); } constructorParameterStatements[paramDep.getParamIndex()] = loadVariable(paramLocalVarName); }
private Statement[] generateProducerParams(final MetaMethod producingMember, final Collection<Dependency> paramDeps, final List<Statement> varDeclarationStmts, final List<Statement> depScopeRegistrationStmts) { // TODO validate params final Statement[] params = new Statement[producingMember.getParameters().length]; for (final Dependency dep : paramDeps) { final ParamDependency paramDep = (ParamDependency) dep; final ContextualStatementBuilder producerParamCreationStmt = generateProducerParamCreationStmt(paramDep); final String paramVarName = getLocalVariableName(paramDep.getParameter()); varDeclarationStmts.add(declareFinalVariable(paramVarName, paramDep.getParameter().getType(), producerParamCreationStmt)); if (paramDep.getInjectable().getWiringElementTypes().contains(WiringElementType.DependentBean)) { depScopeRegistrationStmts.add(loadVariable("this").invoke("registerDependentScopedReference", loadVariable("instance"), loadVariable(paramVarName))); } params[paramDep.getParamIndex()] = loadVariable(paramVarName); } return params; }
private List<Statement> methodCreateInstanceStatements(final MetaMethod producingMember, final Injectable producerInjectable, final Injectable producedInjectable, final Collection<Dependency> paramDeps, 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(castTo(producerInjectable.getInjectedType(), invokeStatic(Factory.class, "maybeUnwrapProxy", loadVariable(PRODUCER_INSTANCE))))); } final List<Statement> depScopeRegistrationStmts = new ArrayList<>(); final Statement[] producerParams = generateProducerParams(producingMember, paramDeps, stmts, depScopeRegistrationStmts); final Statement invocation = controller.exposedMethodStmt(loadVariable(PRODUCER_INSTANCE), producingMember, producerParams); 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.addAll(depScopeRegistrationStmts); stmts.add(loadVariable("instance").returnValue()); return stmts; }
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; }
final MetaClass factoryClass = addFactoryDeclaration(injectable, processingContext); registerFactoryWithContext(injectable, factoryClass, scopeContexts, registerFactoriesBody); final boolean windowScoped = injectable.getWiringElementTypes().contains(WiringElementType.SharedSingleton); final boolean jsType = injectable.getWiringElementTypes().contains(WiringElementType.JsType); final boolean jsinteropSupportEnabled = isJsInteropSupportEnabled(); if (jsinteropSupportEnabled && (jsType || windowScoped)) {
private Statement[] getDisposerParams(final MetaMethod disposer, final Collection<Dependency> disposerParams, final BuildMetaClass factory) { final Statement[] params = new Statement[disposer.getParameters().length]; for (final Dependency dep : disposerParams) { final ParamDependency paramDep = (ParamDependency) dep; final ContextualStatementBuilder paramInstance = castTo(paramDep.getInjectable().getInjectedType(), loadVariable("contextManager").invoke("getInstance", paramDep.getInjectable().getFactoryName())); final ContextualStatementBuilder paramExpression; if (paramDep.getInjectable().getWiringElementTypes().contains(WiringElementType.DependentBean)) { paramExpression = loadVariable("this").invoke("registerDependentScopedReference", loadVariable("instance"), paramInstance); } else { paramExpression = paramInstance; } params[paramDep.getParamIndex()] = paramExpression; } final MetaParameter disposesParam = disposer.getParametersAnnotatedWith(Disposes.class).get(0); params[disposesParam.getIndex()] = loadVariable("instance"); return params; }
if (depInjectable.getWiringElementTypes().contains(WiringElementType.DependentBean)) { createInstanceStatements .add(loadVariable("this").invoke("registerDependentScopedReference", loadVariable("instance"), loadVariable(fieldDepVarName)));
if (depInjectable.getWiringElementTypes().contains(WiringElementType.DependentBean)) { createInstanceStatements .add(loadVariable("this").invoke("registerDependentScopedReference", loadVariable("instance"), loadVariable(paramLocalVarName)));