Guice3 Binder Proxy

BinderProxy.java

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

import org.aopalliance.intercept.MethodInterceptor;

import com.google.inject.Binder;
import com.google.inject.Key;
import com.google.inject.MembersInjector;
import com.google.inject.Module;
import com.google.inject.PrivateBinder;
import com.google.inject.Provider;
import com.google.inject.Scope;
import com.google.inject.Stage;
import com.google.inject.TypeLiteral;
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.TypeConverter;
import com.google.inject.spi.TypeListener;


public class BinderProxy implements Binder {
	
	private final Binder proxy;

	public BinderProxy(Binder proxy){
		this.proxy = proxy;
	}

	@Override
	public void bindInterceptor(Matcher<? super Class<?>> classMatcher, Matcher<? super Method> methodMatcher, MethodInterceptor... interceptors) {
		proxy.bindInterceptor(classMatcher, methodMatcher, interceptors);
	}

	@Override
	public void bindScope(Class<? extends Annotation> annotationType, Scope scope) {
		proxy.bindScope(annotationType, scope);
	}

	@Override
	public <T> LinkedBindingBuilder<T> bind(Key<T> key) {
		return proxy.bind(key);
	}

	@Override
	public <T> AnnotatedBindingBuilder<T> bind(TypeLiteral<T> typeLiteral) {
		return proxy.bind(typeLiteral);
	}

	@Override
	public <T> AnnotatedBindingBuilder<T> bind(Class<T> type) {
		return proxy.bind(type);
	}

	@Override
	public AnnotatedConstantBindingBuilder bindConstant() {
		return proxy.bindConstant();
	}

	@Override
	public <T> void requestInjection(TypeLiteral<T> type, T instance) {
		proxy.requestInjection(type, instance);
	}

	@Override
	public void requestInjection(Object instance) {
		proxy.requestInjection(instance);
	}

	@Override
	public void requestStaticInjection(Class<?>... types) {
		proxy.requestInjection(types);
	}

	@Override
	public void install(Module module) {
		proxy.install(module);
	}

	@Override
	public Stage currentStage() {
		return proxy.currentStage();
	}

	@Override
	public void addError(String message, Object... arguments) {
		proxy.addError(message, arguments);
	}

	@Override
	public void addError(Throwable t) {
		proxy.addError(t);
	}

	@Override
	public void addError(Message message) {
		proxy.addError(message);
	}

	@Override
	public <T> Provider<T> getProvider(Key<T> key) {
		return proxy.getProvider(key);
	}

	@Override
	public <T> Provider<T> getProvider(Class<T> type) {
		return getProvider(type);
	}

	@Override
	public <T> MembersInjector<T> getMembersInjector(TypeLiteral<T> typeLiteral) {
		return getMembersInjector(typeLiteral);
	}

	@Override
	public <T> MembersInjector<T> getMembersInjector(Class<T> type) {
		return getMembersInjector(type);
	}

	@Override
	public void convertToTypes(Matcher<? super TypeLiteral<?>> typeMatcher, TypeConverter converter) {
		convertToTypes(typeMatcher, converter);
	}

	@Override
	public void bindListener(Matcher<? super TypeLiteral<?>> typeMatcher, TypeListener listener) {
		bindListener(typeMatcher, listener);
	}

	@Override
	public Binder withSource(Object source) {
		return proxy.withSource(source);
	}

	@Override
	public Binder skipSources(@SuppressWarnings("rawtypes") Class... classesToSkip) {
		return proxy.skipSources(classesToSkip);
	}

	@Override
	public PrivateBinder newPrivateBinder() {
		return proxy.newPrivateBinder();
	}

	@Override
	public void requireExplicitBindings() {
		proxy.requireExplicitBindings();
	}

	@Override
	public void disableCircularProxies() {
		proxy.disableCircularProxies();
	}

}