private <T> ProviderMethod<T> createProviderMethod(
      Binder binder, Method method, Annotation annotation) {
    binder = binder.withSource(method);
    Errors errors = new Errors(method);

    // prepare the parameter providers
    InjectionPoint point = InjectionPoint.forMethod(method, typeLiteral);
    List<Dependency<?>> dependencies = point.getDependencies();
    List<Provider<?>> parameterProviders = Lists.newArrayList();
    for (Dependency<?> dependency : point.getDependencies()) {
      parameterProviders.add(binder.getProvider(dependency));
    }

    @SuppressWarnings("unchecked") // Define T as the method's return type.
    TypeLiteral<T> returnType = (TypeLiteral<T>) typeLiteral.getReturnType(method);
    Key<T> key = getKey(errors, returnType, method, method.getAnnotations());
    try {
      key = scanner.prepareMethod(binder, annotation, key, point);
    } catch (Throwable t) {
      binder.addError(t);
    }
    Class<? extends Annotation> scopeAnnotation =
        Annotations.findScopeAnnotation(errors, method.getAnnotations());
    for (Message message : errors.getMessages()) {
      binder.addError(message);
    }
    return ProviderMethod.create(
        key,
        method,
        delegate,
        ImmutableSet.copyOf(dependencies),
        parameterProviders,
        scopeAnnotation,
        skipFastClassGeneration,
        annotation);
  }
 public void applyTo(Binder binder) {
   getScoping()
       .applyTo(
           binder.withSource(getSource()).bind(getKey()).toProvider(getUserSuppliedProvider()));
 }
Exemple #3
0
 public void applyTo(Binder binder) {
   binder.withSource(getSource()).bindScope(annotationType, scope);
 }
 @Override
 public void applyTo(Binder binder) {
   getScoping().applyTo(binder.withSource(getSource()).bind(getKey()));
 }
 @Override
 public Binder withSource(Object source) {
   return binder.withSource(source);
 }
 @Override
 public void bindListener(Matcher<? super TypeLiteral<?>> typeMatcher, TypeListener listener) {
   binder.withSource(getBindingLocation()).bindListener(typeMatcher, listener);
 }
 @Override
 public void install(Module module) {
   binder.withSource(getBindingLocation()).install(module);
 }
 @Override
 public void requestStaticInjection(Class<?>... types) {
   binder.withSource(getBindingLocation()).requestStaticInjection(types);
 }
 @Override
 public void requestInjection(Object instance) {
   binder.withSource(getBindingLocation()).requestInjection(instance);
 }
 @Override
 public <T> void requestInjection(TypeLiteral<T> type, T instance) {
   binder.withSource(getBindingLocation()).requestInjection(type, instance);
 }
 @Override
 public AnnotatedConstantBindingBuilder bindConstant() {
   return binder.withSource(getBindingLocation()).bindConstant();
 }
 @Override
 public <T> AnnotatedBindingBuilder<T> bind(Class<T> type) {
   warnOnSpecialized(type);
   return binder.withSource(getBindingLocation()).bind(type);
 }
 @Override
 public <T> AnnotatedBindingBuilder<T> bind(TypeLiteral<T> typeLiteral) {
   warnOnSpecialized(typeLiteral.getRawType());
   return binder.withSource(getBindingLocation()).bind(typeLiteral);
 }
 @Override
 public <T> LinkedBindingBuilder<T> bind(Key<T> key) {
   warnOnSpecialized(key.getTypeLiteral().getRawType());
   return binder.withSource(getBindingLocation()).bind(key);
 }