@Override
protected void configure() {
    bindListener(Matchers.any(), new ProvisionListener() {
        @Override
        public <T> void onProvision(ProvisionInvocation<T> provision) {
            final ProvisionListener.ProvisionInvocation<?> prior = ContextualProvider.provisionInvocation.get();
            ContextualProvider.provisionInvocation.set(provision);
            try {
                provision.provision();
            } finally {
                if(prior != null) {
                    ContextualProvider.provisionInvocation.set(prior);
                } else {
                    ContextualProvider.provisionInvocation.remove();
                }
            }
        }
    });
}
 

@Override
public void configure(final Binder binder) {
  binder.bindListener(Matchers.any(), new ProvisionListener() {
    @Override
    public <T> void onProvision(ProvisionInvocation<T> provision) {
      Object obj = provision.provision();

      if (obj instanceof Managed) {
        handle((Managed) obj);
      }

      if (obj instanceof Task) {
        handle((Task) obj);
      }

      if (obj instanceof HealthCheck) {
        handle((HealthCheck) obj);
      }

      if (obj instanceof ServerLifecycleListener) {
        handle((ServerLifecycleListener) obj);
      }
    }
  });
}
 

@Override
final public T get() {
    final ProvisionListener.ProvisionInvocation<T> pi = (ProvisionListener.ProvisionInvocation<T>) provisionInvocation.get();
    if(pi == null) {
        return getWithoutContext();
    } else {
        return getFor(pi.getBinding(), pi.getDependencyChain());
    }
}
 

/**
 * Adapt a {@link Consumer} to be a {@link ProvisionListener} (which is not lambda compatible)
 */
static ProvisionListener provisionListener(Consumer<ProvisionListener.ProvisionInvocation<?>> consumer) {
    return consumer::accept;
}
 

/**
 * Adapt the given matcher and listener and pass them to {@link Binder#bindListener(Matcher, ProvisionListener...)}
 */
default void bindProvisionListener(Predicate<? super Binding<?>> matcher, Consumer<ProvisionListener.ProvisionInvocation<?>> listener) {
    bindListener(Matchers.predicate(matcher), provisionListener(listener));
}
 

default <T> void bindProvisionSubtypesOfListener(TypeLiteral<T> type, Consumer<ProvisionListener.ProvisionInvocation<T>> listener) {
    bindProvisionListener(bindingsForSubtypesOf(type), (Consumer) listener);
}
 

default <T> void bindProvisionSubtypesOfListener(Class<T> type, Consumer<ProvisionListener.ProvisionInvocation<T>> listener) {
    bindProvisionSubtypesOfListener(TypeLiteral.get(type), listener);
}
 

@Override
protected void configure() {
    final InjectionLogger listener = new InjectionLogger(logger);
    bindListener(Matchers.any(), (TypeListener) listener);
    bindListener(Matchers.any(), (ProvisionListener) listener);
}
 

@Override
protected void configure() {
  binder().bindListener(Matchers.any(), new ProvisionListener() {
    @Override
    public <T> void onProvision(ProvisionInvocation<T> provision) {
      final Binding<T> binding = provision.getBinding();
      logger.debug("provisioning {}", binding.getKey().getTypeLiteral());

      final T provisioned = provision.provision();

      if (provisioned != null && Service.class.isAssignableFrom(provisioned.getClass())) {
        final AtomicBoolean start = new AtomicBoolean(false);
        binding.acceptScopingVisitor(new DefaultBindingScopingVisitor<T>() {
          @Override
          public T visitEagerSingleton() {
            start.set(true);
            return super.visitEagerSingleton();
          }

          @Override
          public T visitScope(Scope scope) {
            if (scope instanceof SingletonScope) {
              start.set(true);
            }
            return super.visitScope(scope);
          }
        });

        if (start.get()) {
          serviceList.push(binding.getKey().getTypeLiteral().getRawType());
          try {
            logger.debug("starting {}", binding.getKey().getTypeLiteral());
            ((Service) provisioned).start();
          } catch (Exception e) {
            throwIfUnchecked(e);
            throw new RuntimeException(e);
          }
        }
      }
    }
  });
}