dagger2_code_generation_issue_gen

dagger2_code_generation_issue_Child1_MembersInjector.java

package dagger2_code_generation_issue;

import dagger.MembersInjector;
import javax.annotation.Generated;
import javax.inject.Provider;

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class Child1_MembersInjector implements MembersInjector<Child1> {
  private final MembersInjector<Parent> supertypeInjector;
  private final Provider<ChildMember> childMemberProvider;

  public Child1_MembersInjector(MembersInjector<Parent> supertypeInjector, Provider<ChildMember> childMemberProvider) {  
    assert supertypeInjector != null;
    this.supertypeInjector = supertypeInjector;
    assert childMemberProvider != null;
    this.childMemberProvider = childMemberProvider;
  }

  @Override
  public void injectMembers(Child1 instance) {  
    if (instance == null) {
      throw new NullPointerException("Cannot inject members into a null reference");
    }
    supertypeInjector.injectMembers(instance);
    instance.childMember = childMemberProvider.get();
  }

  public static MembersInjector<Child1> create(MembersInjector<Parent> supertypeInjector, Provider<ChildMember> childMemberProvider) {  
      return new Child1_MembersInjector(supertypeInjector, childMemberProvider);
  }
}

dagger2_code_generation_issue_Child2_MembersInjector.java

package dagger2_code_generation_issue;

import dagger.MembersInjector;
import javax.annotation.Generated;
import javax.inject.Provider;

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class Child2_MembersInjector implements MembersInjector<Child2> {
  private final MembersInjector<Parent> supertypeInjector;
  private final Provider<ChildMember> childMemberProvider;

  public Child2_MembersInjector(MembersInjector<Parent> supertypeInjector, Provider<ChildMember> childMemberProvider) {  
    assert supertypeInjector != null;
    this.supertypeInjector = supertypeInjector;
    assert childMemberProvider != null;
    this.childMemberProvider = childMemberProvider;
  }

  @Override
  public void injectMembers(Child2 instance) {  
    if (instance == null) {
      throw new NullPointerException("Cannot inject members into a null reference");
    }
    supertypeInjector.injectMembers(instance);
    instance.childMember = childMemberProvider.get();
  }

  public static MembersInjector<Child2> create(MembersInjector<Parent> supertypeInjector, Provider<ChildMember> childMemberProvider) {  
      return new Child2_MembersInjector(supertypeInjector, childMemberProvider);
  }
}

dagger2_code_generation_issue_ChildMember_Factory.java

package dagger2_code_generation_issue;

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

@Generated("dagger.internal.codegen.ComponentProcessor")
public enum ChildMember_Factory implements Factory<ChildMember> {
INSTANCE;

  @Override
  public ChildMember get() {  
    return new ChildMember();
  }

  public static Factory<ChildMember> create() {  
    return INSTANCE;
  }
}

dagger2_code_generation_issue_DaggerAppTestComponent.java

package dagger2_code_generation_issue;

import dagger.MembersInjector;
import dagger.internal.ScopedProvider;
import javax.annotation.Generated;
import javax.inject.Provider;

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class DaggerAppTestComponent implements AppTestComponent {
  private Provider<ParentMember> parentMemberProvider;
  private MembersInjector<Parent> parentMembersInjector;
  private Provider<ChildMember> childMemberProvider;
  private MembersInjector<Child2> child2MembersInjector;

  private DaggerAppTestComponent(Builder builder) {  
    assert builder != null;
    initialize(builder);
  }

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

  public static AppTestComponent create() {  
    return builder().build();
  }

  private void initialize(final Builder builder) {  
    this.parentMemberProvider = ScopedProvider.create(ParentMember_Factory.create());
    this.parentMembersInjector = Parent_MembersInjector.create(parentMemberProvider);
    this.childMemberProvider = ScopedProvider.create(ChildMember_Factory.create());
    this.child2MembersInjector = Child2_MembersInjector.create(parentMembersInjector, childMemberProvider);
  }

  @Override
  public void inject(Child2 userHolder) {  
    child2MembersInjector.injectMembers(userHolder);
  }

  @Override
  public ActivityScopeComponent plus() {  
    return new ActivityScopeComponentImpl();
  }

  public static final class Builder {
    private Builder() {  
    }
  
    public AppTestComponent build() {  
      return new DaggerAppTestComponent(this);
    }
  }

  private final class ActivityScopeComponentImpl implements ActivityScopeComponent {
    private MembersInjector<Child1> child1MembersInjector;
    private MembersInjector<Parent> parentMembersInjector;
    private MembersInjector<Child2> child2MembersInjector;
  
    private ActivityScopeComponentImpl() {  
      initialize();
    }
  
    private void initialize() {  
      this.child1MembersInjector = Child1_MembersInjector.create(parentMembersInjector, DaggerAppTestComponent.this.childMemberProvider);
      this.parentMembersInjector = Parent_MembersInjector.create(DaggerAppTestComponent.this.parentMemberProvider);
      this.child2MembersInjector = Child2_MembersInjector.create(parentMembersInjector, DaggerAppTestComponent.this.childMemberProvider);
    }
  
    @Override
    public void inject(Child1 child1) {  
      child1MembersInjector.injectMembers(child1);
    }
  }
}

dagger2_code_generation_issue_Parent_MembersInjector.java

package dagger2_code_generation_issue;

import dagger.MembersInjector;
import javax.annotation.Generated;
import javax.inject.Provider;

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class Parent_MembersInjector implements MembersInjector<Parent> {
  private final Provider<ParentMember> parentMemberProvider;

  public Parent_MembersInjector(Provider<ParentMember> parentMemberProvider) {  
    assert parentMemberProvider != null;
    this.parentMemberProvider = parentMemberProvider;
  }

  @Override
  public void injectMembers(Parent instance) {  
    if (instance == null) {
      throw new NullPointerException("Cannot inject members into a null reference");
    }
    instance.parentMember = parentMemberProvider.get();
  }

  public static MembersInjector<Parent> create(Provider<ParentMember> parentMemberProvider) {  
      return new Parent_MembersInjector(parentMemberProvider);
  }
}

dagger2_code_generation_issue_ParentMember_Factory.java

package dagger2_code_generation_issue;

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

@Generated("dagger.internal.codegen.ComponentProcessor")
public enum ParentMember_Factory implements Factory<ParentMember> {
INSTANCE;

  @Override
  public ParentMember get() {  
    return new ParentMember();
  }

  public static Factory<ParentMember> create() {  
    return INSTANCE;
  }
}