dagger-subcomponent.md

DaggerMyAppComponent

package app.ericn.daggerplain;

import dagger.internal.DoubleCheck;
import dagger.internal.Preconditions;
import javax.annotation.Generated;
import javax.inject.Provider;
import retrofit2.Retrofit;

@Generated(
    value = "dagger.internal.codegen.ComponentProcessor",
    comments = "https://dagger.dev"
)
@SuppressWarnings({
    "unchecked",
    "rawtypes"
})
public final class DaggerMyAppComponent implements MyAppComponent {
  private Provider<Retrofit> retrofitProvider;

  private Provider<CatApi> catApiProvider;

  private Provider<CatRepository> catRepositoryProvider;

  private DaggerMyAppComponent(CatModule catModuleParam) {

    initialize(catModuleParam);
  }

  public static Builder builder() {
    return new Builder();
  }

  public static MyAppComponent create() {
    return new Builder().build();
  }

  @SuppressWarnings("unchecked")
  private void initialize(final CatModule catModuleParam) {
    this.retrofitProvider = DoubleCheck.provider(CatModule_RetrofitFactory.create(catModuleParam));
    this.catApiProvider = DoubleCheck.provider(CatModule_CatApiFactory.create(catModuleParam, retrofitProvider));
    this.catRepositoryProvider = DoubleCheck.provider(CatRepository_Factory.create(catApiProvider));
  }

  @Override
  public MainActivityComponent mainActivityComponent(
      MainActivityComponent.MainActivityModule mainActivityModule) {
    Preconditions.checkNotNull(mainActivityModule);
    return new MainActivityComponentImpl(mainActivityModule);
  }

  public static final class Builder {
    private CatModule catModule;

    private Builder() {
    }

    public Builder catModule(CatModule catModule) {
      this.catModule = Preconditions.checkNotNull(catModule);
      return this;
    }

    /**
     * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules.
     */
    @Deprecated
    public Builder contextModule(ContextModule contextModule) {
      Preconditions.checkNotNull(contextModule);
      return this;
    }

    public MyAppComponent build() {
      if (catModule == null) {
        this.catModule = new CatModule();
      }
      return new DaggerMyAppComponent(catModule);
    }
  }

  private final class MainActivityComponentImpl implements MainActivityComponent {
    private Provider<MainPresenter> presenterProvider;

    private MainActivityComponentImpl(
        MainActivityComponent.MainActivityModule mainActivityModuleParam) {

      initialize(mainActivityModuleParam);
    }

    @SuppressWarnings("unchecked")
    private void initialize(
        final MainActivityComponent.MainActivityModule mainActivityModuleParam) {
      this.presenterProvider = DoubleCheck.provider(MainActivityComponent_MainActivityModule_PresenterFactory.create(mainActivityModuleParam, DaggerMyAppComponent.this.catRepositoryProvider));
    }

    @Override
    public void inject(MainActivity mainActivity) {
      injectMainActivity(mainActivity);}

    @Override
    public ChildFragmentComponent fragmentComponent(
        ChildFragmentComponent.ChildFragmentModule module) {
      Preconditions.checkNotNull(module);
      return new ChildFragmentComponentImpl(module);
    }

    private MainActivity injectMainActivity(MainActivity instance) {
      MainActivity_MembersInjector.injectPresenter(instance, presenterProvider.get());
      return instance;
    }

    private final class ChildFragmentComponentImpl implements ChildFragmentComponent {
      private ChildFragmentComponentImpl(ChildFragmentComponent.ChildFragmentModule module) {

      }

      @Override
      public void inject(ChildFragment fragment) {
        injectChildFragment(fragment);}

      private ChildFragment injectChildFragment(ChildFragment instance) {
        ChildFragment_MembersInjector.injectCatRepository(instance, DaggerMyAppComponent.this.catRepositoryProvider.get());
        return instance;
      }
    }
  }
}