Dagger Dependent Component

dependent-component.md

DaggerMyAppComponent

package app.ericn.daggerplain;

import android.content.Context;
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<Context> appContextProvider;

  private Provider<Retrofit> retrofitProvider;

  private Provider<CatApi> catApiProvider;

  private Provider<CatRepository> catRepositoryProvider;

  private DaggerMyAppComponent(CatModule catModuleParam, ContextModule contextModuleParam) {

    initialize(catModuleParam, contextModuleParam);
  }

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

  @SuppressWarnings("unchecked")
  private void initialize(final CatModule catModuleParam, final ContextModule contextModuleParam) {
    this.appContextProvider = DoubleCheck.provider(ContextModule_AppContextFactory.create(contextModuleParam));
    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 Context appContext() {
    return appContextProvider.get();}

  @Override
  public CatRepository catRepository() {
    return catRepositoryProvider.get();}

  public static final class Builder {
    private CatModule catModule;

    private ContextModule contextModule;

    private Builder() {
    }

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

    public Builder contextModule(ContextModule contextModule) {
      this.contextModule = Preconditions.checkNotNull(contextModule);
      return this;
    }

    public MyAppComponent build() {
      if (catModule == null) {
        this.catModule = new CatModule();
      }
      Preconditions.checkBuilderRequirement(contextModule, ContextModule.class);
      return new DaggerMyAppComponent(catModule, contextModule);
    }
  }
}

DaggerMainActivityComponent

package app.ericn.daggerplain;

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

@Generated(
    value = "dagger.internal.codegen.ComponentProcessor",
    comments = "https://dagger.dev"
)
@SuppressWarnings({
    "unchecked",
    "rawtypes"
})
public final class DaggerMainActivityComponent implements MainActivityComponent {
  private final MyAppComponent myAppComponent;

  private Provider<CatRepository> catRepositoryProvider;

  private Provider<MainPresenter> presenterProvider;

  private DaggerMainActivityComponent(
      MainActivityComponent.MainActivityModule mainActivityModuleParam,
      MyAppComponent myAppComponentParam) {
    this.myAppComponent = myAppComponentParam;
    initialize(mainActivityModuleParam, myAppComponentParam);
  }

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

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

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

  @Override
  public CatRepository catRepo() {
    return Preconditions.checkNotNull(myAppComponent.catRepository(), "Cannot return null from a non-@Nullable component method");}

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

  public static final class Builder {
    private MainActivityComponent.MainActivityModule mainActivityModule;

    private MyAppComponent myAppComponent;

    private Builder() {
    }

    public Builder mainActivityModule(MainActivityComponent.MainActivityModule mainActivityModule) {
      this.mainActivityModule = Preconditions.checkNotNull(mainActivityModule);
      return this;
    }

    public Builder myAppComponent(MyAppComponent myAppComponent) {
      this.myAppComponent = Preconditions.checkNotNull(myAppComponent);
      return this;
    }

    public MainActivityComponent build() {
      Preconditions.checkBuilderRequirement(mainActivityModule, MainActivityComponent.MainActivityModule.class);
      Preconditions.checkBuilderRequirement(myAppComponent, MyAppComponent.class);
      return new DaggerMainActivityComponent(mainActivityModule, myAppComponent);
    }
  }

  private static class app_ericn_daggerplain_MyAppComponent_catRepository implements Provider<CatRepository> {
    private final MyAppComponent myAppComponent;

    app_ericn_daggerplain_MyAppComponent_catRepository(MyAppComponent myAppComponent) {
      this.myAppComponent = myAppComponent;
    }

    @Override
    public CatRepository get() {
      return Preconditions.checkNotNull(myAppComponent.catRepository(), "Cannot return null from a non-@Nullable component method");
    }
  }
}

DaggerChildFragmentComponent

package app.ericn.daggerplain;

import dagger.internal.Preconditions;
import javax.annotation.Generated;

@Generated(
    value = "dagger.internal.codegen.ComponentProcessor",
    comments = "https://dagger.dev"
)
@SuppressWarnings({
    "unchecked",
    "rawtypes"
})
public final class DaggerChildFragmentComponent implements ChildFragmentComponent {
  private final MainActivityComponent mainActivityComponent;

  private DaggerChildFragmentComponent(MainActivityComponent mainActivityComponentParam) {
    this.mainActivityComponent = mainActivityComponentParam;
  }

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

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

  private ChildFragment injectChildFragment(ChildFragment instance) {
    ChildFragment_MembersInjector.injectCatRepository(instance, Preconditions.checkNotNull(mainActivityComponent.catRepo(), "Cannot return null from a non-@Nullable component method"));
    return instance;
  }

  public static final class Builder {
    private MainActivityComponent mainActivityComponent;

    private Builder() {
    }

    /**
     * @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 childFragmentModule(
        ChildFragmentComponent.ChildFragmentModule childFragmentModule) {
      Preconditions.checkNotNull(childFragmentModule);
      return this;
    }

    public Builder mainActivityComponent(MainActivityComponent mainActivityComponent) {
      this.mainActivityComponent = Preconditions.checkNotNull(mainActivityComponent);
      return this;
    }

    public ChildFragmentComponent build() {
      Preconditions.checkBuilderRequirement(mainActivityComponent, MainActivityComponent.class);
      return new DaggerChildFragmentComponent(mainActivityComponent);
    }
  }
}