/*
 * Copyright (C) 2006 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.inject;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;

import com.google.inject.binder.AnnotatedBindingBuilder;
import com.google.inject.binder.AnnotatedConstantBindingBuilder;
import com.google.inject.binder.LinkedBindingBuilder;
import com.google.inject.matcher.Matcher;
import com.google.inject.spi.Message;
import com.google.inject.spi.ProvisionListener;
import com.google.inject.spi.TypeConverter;
import com.google.inject.spi.TypeListener;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

A support class for Modules which reduces repetition and results in a more readable configuration. Simply extend this class, implement configure(), and call the inherited methods which mirror those found in Binder. For example: 
public class MyModule extends AbstractModule {
  protected void configure() {
    bind(Service.class).to(ServiceImpl.class).in(Singleton.class);
    bind(CreditCardPaymentService.class);
    bind(PaymentService.class).to(CreditCardPaymentService.class);
    bindConstant().annotatedWith(Names.named("port")).to(8080);
  }
}

Author:
crazybob@google.com (Bob Lee)/**
 * A support class for {@link Module}s which reduces repetition and results in a more readable
 * configuration. Simply extend this class, implement {@link #configure()}, and call the inherited
 * methods which mirror those found in {@link Binder}. For example:
 *
 * <pre>
 * public class MyModule extends AbstractModule {
 *   protected void configure() {
 *     bind(Service.class).to(ServiceImpl.class).in(Singleton.class);
 *     bind(CreditCardPaymentService.class);
 *     bind(PaymentService.class).to(CreditCardPaymentService.class);
 *     bindConstant().annotatedWith(Names.named("port")).to(8080);
 *   }
 * }
 * </pre>
 *
 * @author crazybob@google.com (Bob Lee)
 */
public abstract class AbstractModule implements Module {

  Binder binder;

  @Override
  public final synchronized void configure(Binder builder) {
    checkState(this.binder == null, "Re-entry is not allowed.");

    this.binder = checkNotNull(builder, "builder");
    try {
      configure();
    } finally {
      this.binder = null;
    }
  }

  
Configures a Binder via the exposed methods. /** Configures a {@link Binder} via the exposed methods. */
  protected void configure() {}

  
Gets direct access to the underlying Binder. /** Gets direct access to the underlying {@code Binder}. */
  protected Binder binder() {
    checkState(binder != null, "The binder can only be used inside configure()");
    return binder;
  }

  
See Also:
Binder.bindScope(Class<? extends Annotation>, Scope)/** @see Binder#bindScope(Class, Scope) */
  protected void bindScope(Class<? extends Annotation> scopeAnnotation, Scope scope) {
    binder().bindScope(scopeAnnotation, scope);
  }

  
See Also:
Binder.bind(Key<Object>)/** @see Binder#bind(Key) */
  protected <T> LinkedBindingBuilder<T> bind(Key<T> key) {
    return binder().bind(key);
  }

  
See Also:
Binder.bind(TypeLiteral<Object>)/** @see Binder#bind(TypeLiteral) */
  protected <T> AnnotatedBindingBuilder<T> bind(TypeLiteral<T> typeLiteral) {
    return binder().bind(typeLiteral);
  }

  
See Also:
Binder.bind(Class<Object>)/** @see Binder#bind(Class) */
  protected <T> AnnotatedBindingBuilder<T> bind(Class<T> clazz) {
    return binder().bind(clazz);
  }

  
See Also:
Binder.bindConstant()/** @see Binder#bindConstant() */
  protected AnnotatedConstantBindingBuilder bindConstant() {
    return binder().bindConstant();
  }

  
See Also:
Binder.install(Module)/** @see Binder#install(Module) */
  protected void install(Module module) {
    binder().install(module);
  }

  
See Also:
Binder.addError(String, Object[])/** @see Binder#addError(String, Object[]) */
  protected void addError(String message, Object... arguments) {
    binder().addError(message, arguments);
  }

  
See Also:
Binder.addError(Throwable)/** @see Binder#addError(Throwable) */
  protected void addError(Throwable t) {
    binder().addError(t);
  }

  
See Also:
addError.addError(Message)
Since:
2.0/**
   * @see Binder#addError(Message)
   * @since 2.0
   */
  protected void addError(Message message) {
    binder().addError(message);
  }

  
See Also:
requestInjection.requestInjection(Object)
Since:
2.0/**
   * @see Binder#requestInjection(Object)
   * @since 2.0
   */
  protected void requestInjection(Object instance) {
    binder().requestInjection(instance);
  }

  
See Also:
Binder.requestStaticInjection(Class<?>[])/** @see Binder#requestStaticInjection(Class[]) */
  protected void requestStaticInjection(Class<?>... types) {
    binder().requestStaticInjection(types);
  }

  /*if[AOP]*/
  
See Also:
bindInterceptor.bindInterceptor(Matcher, Matcher, MethodInterceptor[])/**
   * @see Binder#bindInterceptor(com.google.inject.matcher.Matcher,
   *     com.google.inject.matcher.Matcher, org.aopalliance.intercept.MethodInterceptor[])
   */
  protected void bindInterceptor(
      Matcher<? super Class<?>> classMatcher,
      Matcher<? super Method> methodMatcher,
      org.aopalliance.intercept.MethodInterceptor... interceptors) {
    binder().bindInterceptor(classMatcher, methodMatcher, interceptors);
  }
  /*end[AOP]*/

  
Adds a dependency from this module to key. When the injector is created, Guice will report an error if key cannot be injected. Note that this requirement may be satisfied by implicit binding, such as a public no-arguments constructor. 
Since:
2.0/**
   * Adds a dependency from this module to {@code key}. When the injector is created, Guice will
   * report an error if {@code key} cannot be injected. Note that this requirement may be satisfied
   * by implicit binding, such as a public no-arguments constructor.
   *
   * @since 2.0
   */
  protected void requireBinding(Key<?> key) {
    binder().getProvider(key);
  }

  
Adds a dependency from this module to type. When the injector is created, Guice will report an error if type cannot be injected. Note that this requirement may be satisfied by implicit binding, such as a public no-arguments constructor. 
Since:
2.0/**
   * Adds a dependency from this module to {@code type}. When the injector is created, Guice will
   * report an error if {@code type} cannot be injected. Note that this requirement may be satisfied
   * by implicit binding, such as a public no-arguments constructor.
   *
   * @since 2.0
   */
  protected void requireBinding(Class<?> type) {
    binder().getProvider(type);
  }

  
See Also:
getProvider.getProvider(Key)
Since:
2.0/**
   * @see Binder#getProvider(Key)
   * @since 2.0
   */
  protected <T> Provider<T> getProvider(Key<T> key) {
    return binder().getProvider(key);
  }

  
See Also:
getProvider.getProvider(Class)
Since:
2.0/**
   * @see Binder#getProvider(Class)
   * @since 2.0
   */
  protected <T> Provider<T> getProvider(Class<T> type) {
    return binder().getProvider(type);
  }

  
See Also:
convertToTypes.convertToTypes
Since:
2.0/**
   * @see Binder#convertToTypes
   * @since 2.0
   */
  protected void convertToTypes(
      Matcher<? super TypeLiteral<?>> typeMatcher, TypeConverter converter) {
    binder().convertToTypes(typeMatcher, converter);
  }

  
See Also:
currentStage.currentStage()
Since:
2.0/**
   * @see Binder#currentStage()
   * @since 2.0
   */
  protected Stage currentStage() {
    return binder().currentStage();
  }

  
See Also:
getMembersInjector.getMembersInjector(Class)
Since:
2.0/**
   * @see Binder#getMembersInjector(Class)
   * @since 2.0
   */
  protected <T> MembersInjector<T> getMembersInjector(Class<T> type) {
    return binder().getMembersInjector(type);
  }

  
See Also:
getMembersInjector.getMembersInjector(TypeLiteral)
Since:
2.0/**
   * @see Binder#getMembersInjector(TypeLiteral)
   * @since 2.0
   */
  protected <T> MembersInjector<T> getMembersInjector(TypeLiteral<T> type) {
    return binder().getMembersInjector(type);
  }

  
See Also:
bindListener.bindListener(Matcher, TypeListener)
Since:
2.0/**
   * @see Binder#bindListener(com.google.inject.matcher.Matcher, com.google.inject.spi.TypeListener)
   * @since 2.0
   */
  protected void bindListener(Matcher<? super TypeLiteral<?>> typeMatcher, TypeListener listener) {
    binder().bindListener(typeMatcher, listener);
  }

  
See Also:
bindListener.bindListener(Matcher, ProvisionListener...)
Since:
4.0/**
   * @see Binder#bindListener(Matcher, ProvisionListener...)
   * @since 4.0
   */
  protected void bindListener(
      Matcher<? super Binding<?>> bindingMatcher, ProvisionListener... listener) {
    binder().bindListener(bindingMatcher, listener);
  }
}