@Override public boolean matches(final Injectable injectable) { return InjectableType.Disabled.equals(injectable.getInjectableType()); } };
private static boolean qualifiersMatch(final InjectableReference injectableReference, final HasInjectableHandle candidate) { return injectableReference.qualifier.isSatisfiedBy(candidate.getQualifier()); }
@Override public boolean canValidate(final Injectable injectable) { return !injectable.loadAsync(); }
private void addProviderInjectable(final Injectable providerImplInjectable, final DependencyGraphBuilder builder, final boolean enabled) { final MetaClass providerImpl = providerImplInjectable.getInjectedType(); final MetaMethod providerMethod = providerImpl.getMethod("get", new Class[0]); final MetaClass providedType = getMethodReturnType(providerMethod); final InjectableType injectableType = (enabled ? InjectableType.Provider : InjectableType.Disabled); final Injectable providedInjectable = builder.addInjectable(providedType, qualFactory.forSource(providerMethod), EXACT_TYPE, Dependent.class, injectableType, WiringElementType.Provider, WiringElementType.DependentBean); builder.addProducerMemberDependency(providedInjectable, providerImplInjectable.getInjectedType(), providerImplInjectable.getQualifier(), providerMethod); }
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); }
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 addContextualProviderInjectable(final Injectable providerInjectable, final DependencyGraphBuilder builder, final boolean enabled) { final MetaClass providerImpl = providerInjectable.getInjectedType(); final MetaMethod providerMethod = providerImpl.getMethod("provide", Class[].class, Annotation[].class); // Do not get generic return type for contextual providers final MetaClass providedType = providerMethod.getReturnType(); final InjectableType injectableType = (enabled ? InjectableType.ContextualProvider : InjectableType.Disabled); final Injectable providedInjectable = builder.addInjectable(providedType, qualFactory.forUniversallyQualified(), EXACT_TYPE, Dependent.class, injectableType, WiringElementType.Provider, WiringElementType.DependentBean); builder.addProducerMemberDependency(providedInjectable, providerImpl, providerInjectable.getQualifier(), providerMethod); }
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)); }
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 MetaClass addFactoryDeclaration(final Injectable injectable, final IOCProcessingContext processingContext) { final String factoryName = injectable.getFactoryName(); final MetaClass typeCreatedByFactory = injectable.getInjectedType(); return addFactoryDeclaration(factoryName, typeCreatedByFactory, processingContext); }
@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()); } } } }
@Override public boolean matches(final Injectable injectable) { return injectable.getInjectableType().equals(InjectableType.JsType) && injectable.getWiringElementTypes().contains(WiringElementType.SharedSingleton); } },
private void addDisposerDependencies(final Injectable producedInjectable, final MetaMethod disposer, final DependencyGraphBuilder builder) { for (final MetaParameter param : disposer.getParameters()) { if (param.isAnnotationPresent(Disposes.class)) { builder.addDisposesMethodDependency(producedInjectable, disposer.getDeclaringClass(), qualFactory.forSink(disposer.getDeclaringClass()), disposer); } else { builder.addDisposesParamDependency(producedInjectable, param.getType(), qualFactory.forSink(param), param.getIndex(), param); } } }
private void addConstructorInjectionPoints(final Injectable concreteInjectable, final MetaConstructor injectableConstructor, final DependencyGraphBuilder builder) { final MetaParameter[] params = injectableConstructor.getParameters(); for (int i = 0; i < params.length; i++) { final MetaParameter param = params[i]; builder.addConstructorDependency(concreteInjectable, param.getType(), qualFactory.forSink(param), i, param); } }
@Override public boolean isContextual() { return InjectableType.ContextualProvider.equals(injectableType); }
public String getBeanName() { return qualifier.getName(); }
private void processProducerField(final Injectable producerInjectable, final MetaClass producerType, final DependencyGraphBuilder builder, final Collection<MetaMethod> disposesMethods, final MetaField field, final boolean enabled, final List<String> problems) { final Class<? extends Annotation> scopeAnno = getScope(field); final InjectableType injectableType = (enabled ? InjectableType.Producer : InjectableType.Disabled); final Injectable producedInjectable = builder.addInjectable(field.getType(), qualFactory.forSource(field), getPathPredicate(field, problems), scopeAnno, injectableType, getWiringTypeForProducer(producerType, field, scopeAnno)); if (field.isStatic()) { builder.addProducerMemberDependency(producedInjectable, producerType, field); } else { builder.addProducerMemberDependency(producedInjectable, producerInjectable.getInjectedType(), producerInjectable.getQualifier(), field); } if (enabled) { processDisposerDependencies(builder, disposesMethods, field, producedInjectable); } }
@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 InjectableType.JsType.equals(injectable.getInjectableType()); } },