Injectors.java

package com.googlecode.gwt.test.gin;

import com.google.gwt.i18n.client.Messages;
import com.google.gwt.inject.client.AbstractGinModule;
import com.google.gwt.inject.client.AsyncProvider;
import com.google.gwt.inject.client.GinModules;
import com.google.gwt.inject.client.Ginjector;
import com.google.gwt.inject.client.assistedinject.GinFactoryModuleBuilder;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.rpc.RemoteService;
import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;
import com.google.inject.Inject;
import com.google.inject.Provider;
import com.google.inject.Provides;
import com.google.inject.Singleton;
import com.google.inject.assistedinject.Assisted;

public class Injectors {

    public static interface AssistedInjectFactory {

        ClassWithAssistedInjection newClassWithAssistedInjection(String assitedString);

    }

    public static class ClassWithAssistedInjection {

        final String assistedString;

        @Inject
        Virtual virtual;

        @Inject
        public ClassWithAssistedInjection(@Assisted
                                                  String assistedString) {
            this.assistedString = assistedString;
        }
    }

    public static class ClassWithAsyncProvider {

        private final AsyncProvider<Impl2> provider;

        @Inject
        public ClassWithAsyncProvider(AsyncProvider<Impl2> provider) {
            this.provider = provider;
        }

        public void onSuccess(AsyncCallback<Impl2> callback) {
            provider.get(callback);
        }

    }

    @GinModules({Gin1Module.class})
    public interface Gin1Injector extends Ginjector {
        Virtual virtual();
    }

    // This module will only contain a single binding
    public static final class Gin1Module extends AbstractGinModule {
        @Override
        protected void configure() {
            bind(Virtual.class).to(Impl.class).in(Singleton.class);
        }
    }

    @GinModules({Gin2Module.class})
    public interface Gin2Injector extends Ginjector {
        SomeServiceAsync service();

        Virtual virtual();

        VirtualMore virtualMore();
    }

    public static final class Gin2Module extends AbstractGinModule {
        @Override
        protected void configure() {
            bind(Virtual.class).to(Impl2.class);
            bind(VirtualMore.class).to(ImplMore.class);
        }
    }

    @GinModules({Gin3Module.class})
    public interface Gin3Injector extends Ginjector {
        ImplMore implMore();
    }

    public static final class Gin3Module extends AbstractGinModule {
        @Override
        protected void configure() {
            bind(Virtual.class).to(Impl2.class);
        }
    }

    @GinModules(Gin4Module.class)
    public interface Gin4Injector extends Ginjector {
        Virtual virtual();
    }

    public static class Gin4Module extends AbstractGinModule {
        @Override
        protected void configure() {
            bind(Virtual.class).to(ImplementationWithProviders.class);
            bind(VirtualMore.class).to(ImplMore.class);
        }
    }

    @GinModules(Gin5Module.class)
    public interface Gin5Injector extends Ginjector {
        Impl singletonImpl();

        Virtual singletonVirtual();

    }

    public static class Gin5Module extends AbstractGinModule {

        @Override
        protected void configure() {
            bind(Impl.class).in(Singleton.class);

            bind(Virtual.class).to(Impl.class);
        }

    }

    @GinModules(Gin6Module.class)
    public interface Gin6Injector extends Ginjector {
        Virtual singletonImpl();

        Impl3 wrapper();

    }

    public static class Gin6Module extends AbstractGinModule {

        @Override
        protected void configure() {
            bind(Virtual.class).to(Impl.class).in(Singleton.class);

        }

        @Provides
        Impl3 provideImpl3(Virtual toWrap) {
            return new Impl3(toWrap);
        }

    }

    @GinModules(Gin7Module.class)
    public interface Gin7Injector extends Ginjector {
        Impl2 eagerSingleton();
    }

    public static class Gin7Module extends AbstractGinModule {

        @Override
        protected void configure() {
            bind(Impl2.class).asEagerSingleton();
        }
    }

    @GinModules({Gin8Module.class})
    public interface Gin8Injector extends Ginjector {
        ClassWithAsyncProvider classWithAsyncProvider();
    }

    // This module will only contain a single binding
    public static final class Gin8Module extends AbstractGinModule {
        @Override
        protected void configure() {
            bind(VirtualMore.class).to(ImplMore.class);
            bind(Virtual.class).to(Impl.class);
        }
    }

    @GinModules({Gin9Module.class})
    public interface Gin9Injector extends Ginjector {
        AssistedInjectFactory assistedInjectFactory();
    }

    public static class Gin9Module extends AbstractGinModule {

        @Override
        protected void configure() {
            bind(Virtual.class).to(Impl2.class);
            install(new GinFactoryModuleBuilder().build(AssistedInjectFactory.class));
        }

    }

    public static class Impl implements Virtual {
    }

    public static class Impl2 implements Virtual {
        TestMessages messages;

        @Inject
        public Impl2(TestMessages messages) {
            this.messages = messages;
        }
    }

    public static class Impl3 implements Virtual {

        protected final Virtual wrapped;

        public Impl3(Virtual impl) {
            this.wrapped = impl;
        }
    }

    public static class ImplementationWithProviders implements Virtual {

        Provider<VirtualMore> provider;

        @Inject
        public ImplementationWithProviders(Provider<VirtualMore> provider) {
            this.provider = provider;
        }
    }

    public static class ImplMore implements VirtualMore {
        Virtual core;

        @Inject
        public ImplMore(Virtual core) {
            super();
            this.core = core;
        }

    }

    // These bindings test the ability of Ginjector GwtCreateHandler
    // to fallback to GWT.create for unbound ones (like RemoteService,
    // Constants, Messages, etc).
    @RemoteServiceRelativePath("service")
    public interface Service extends RemoteService {
        String name();
    }

    public interface ServiceAsync {
        void name(AsyncCallback<String> callback);
    }

    public static class ServiceImpl implements Service {

        public String name() {
            return "Service Implementation";
        }

    }

    @RemoteServiceRelativePath("someService")
    public interface SomeService extends RemoteService {
    }

    public interface SomeServiceAsync {
    }

    public static class SomeServiceImpl implements SomeService {

    }

    public interface TestMessages extends Messages {
        @DefaultMessage("this is junit")
        String myName();
    }

    // Simple bindings
    public interface Virtual {
    }

    public interface VirtualMore {
    }

}