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); }
static Injectable getResolvedDependency(final Dependency dep, final Injectable depOwner) { return Validate.notNull(dep.getInjectable(), "The dependency %s in %s should have already been resolved.", dep, depOwner); }
private static Statement getAccessStatementForAutoBoundDataBinder(final Decorable decorable, final FactoryController controller) { final Injectable enclosingInjectable = decorable.getEnclosingInjectable(); for (final Dependency dep : enclosingInjectable.getDependencies()) { switch (dep.getDependencyType()) { case Constructor: case SetterParameter: if (!(dep instanceof ParamDependency)) { throw new RuntimeException("Found " + dep.getDependencyType() + " dependency that was not of type " + ParamDependency.class.getName()); throw new RuntimeException("Found " + dep.getDependencyType() + " dependency that was not of type " + FieldDependency.class.getName());
private static Statement getAccessStatementForAutoBoundDataBinder(final Decorable decorable, final FactoryController controller) { final Injectable enclosingInjectable = decorable.getEnclosingInjectable(); for (final Dependency dep : enclosingInjectable.getDependencies()) { switch (dep.getDependencyType()) { case Constructor: case SetterParameter: if (!(dep instanceof ParamDependency)) { throw new RuntimeException("Found " + dep.getDependencyType() + " dependency that was not of type " + ParamDependency.class.getName()); throw new RuntimeException("Found " + dep.getDependencyType() + " dependency that was not of type " + FieldDependency.class.getName());
private MetaConstructor getAccessibleConstructor(final Injectable injectable) { final MetaClass type = injectable.getInjectedType(); final MetaConstructor noArgConstr = getAccessibleNoArgConstructor(type); if (noArgConstr != null) { return noArgConstr; } for (final Dependency dep : injectable.getDependencies()) { if (dep.getDependencyType().equals(DependencyType.Constructor)) { final MetaConstructor injectableConstr = (MetaConstructor) ((ParamDependency) dep).getParameter().getDeclaringMember(); return (injectableConstr.isPublic() || injectableConstr.isProtected()) ? injectableConstr : null; } } return null; }
protected Injectable getProviderInjectable(final Injectable depInjectable) { for (final Dependency dep : depInjectable.getDependencies()) { if (dep.getDependencyType().equals(DependencyType.ProducerMember)) { final MetaClass providerType = dep.getInjectable().getInjectedType(); if (providerType.isAssignableTo(getProviderRawType())) { return dep.getInjectable(); } else { throw new RuntimeException("Unrecognized contextual provider type " + providerType.getFullyQualifiedName()); } } } throw new RuntimeException(); }
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 void addDependency(final Injectable injectable, final Dependency dependency) { assert (injectable instanceof InjectableImpl); if (InjectableType.Disabled.equals(injectable.getInjectableType()) && (!DependencyType.ProducerMember.equals(dependency.getDependencyType()) || !injectable.getDependencies().isEmpty())) { throw new RuntimeException("The injectable, " + injectable + ", is disabled." + " A disabled injectable may only have a single dependency if it is produced by a disabled bean."); } final InjectableImpl injectableAsImpl = (InjectableImpl) injectable; injectableAsImpl.dependencies.add(BaseDependency.class.cast(dependency)); }
protected static Multimap<DependencyType, Dependency> separateByType(final Collection<Dependency> dependencies) { final Multimap<DependencyType, Dependency> separated = HashMultimap.create(); for (final Dependency dep : dependencies) { separated.put(dep.getDependencyType(), dep); } return separated; }
@Override public void validate(final Injectable injectable, final Collection<String> problems) { for (final Dependency dep : injectable.getDependencies()) { if (dep.getInjectable().loadAsync()) { problems.add("The bean " + injectable + " is not @LoadAsync but depends on the @LoadAsync bean " + dep.getInjectable()); } } } }
private void registerAsyncFactory(final Injectable injectable, final IOCProcessingContext processingContext, @SuppressWarnings("rawtypes") final BlockBuilder curMethod, final MetaClass factoryClass) { final Statement handle = generateFactoryHandle(injectable, curMethod); final Statement loader = generateFactoryLoader(injectable, factoryClass); curMethod.append(loadVariable("asyncBeanManagerSetup").invoke("registerAsyncBean", handle, loader)); for (final Dependency dep : injectable.getDependencies()) { if (dep.getInjectable().loadAsync()) { curMethod.append(loadVariable("asyncBeanManagerSetup").invoke("registerAsyncDependency", injectable.getFactoryName(), dep.getInjectable().getFactoryName())); } } }
private Injectable getRootDisabledInjectable(Injectable inj, final Collection<String> problems, final Map<String, Injectable> customProvidedInjectables) { while (inj.getDependencies().size() == 1) { final Dependency dep = inj.getDependencies().iterator().next(); if (DependencyType.ProducerMember.equals(dep.getDependencyType())) { inj = resolveDependency((BaseDependency) dep, inj, problems, customProvidedInjectables); } } return inj; }
private static void traceConstituentHashContents(final Injectable injectable, final String name) { log.trace("Begin trace of hashContent for {}", name); log.trace("Combined content: {}", injectable.hashContent()); log.trace("HashContent for injectable type: {}", injectable.getInjectedType().hashContent()); for (final Dependency dep : injectable.getDependencies()) { log.trace("HashContent for {} dep of type {}: {}", dep.getDependencyType().toString(), dep.getInjectable().getInjectedType(), dep.getInjectable().getInjectedType().hashContent()); } log.trace("End trace of hashContent for {}", name); }