com.google.caliper.worker.DaggerCaliperProxyComponent Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of caliper-worker-android Show documentation
The newest version!
// Generated by Dagger (https://google.github.io/dagger).
package com.google.caliper.worker;

import com.google.caliper.worker.connection.ClientConnectionService;
import com.google.caliper.worker.connection.ClientConnectionService_Factory;
import com.google.common.collect.ImmutableMap;
import dagger.internal.DoubleCheck;
import dagger.internal.InstanceFactory;
import dagger.internal.Preconditions;
import java.net.InetSocketAddress;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import javax.inject.Provider;

public final class DaggerCaliperProxyComponent implements CaliperProxyComponent {
  private Provider clientAddressProvider;

  private Provider idProvider;

  private Provider clientConnectionServiceProvider;

  private Provider executorProvider;

  private Provider classpathProvider;

  private Provider nativeLibraryDirProvider;

  private Provider> processEnvProvider;

  private Provider caliperProxyProvider;

  private DaggerCaliperProxyComponent(
      UUID idParam,
      String classpathParam,
      String nativeLibraryDirParam,
      ImmutableMap processEnvParam,
      InetSocketAddress clientAddressParam) {

    initialize(idParam, classpathParam, nativeLibraryDirParam, processEnvParam, clientAddressParam);
  }

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

  @SuppressWarnings("unchecked")
  private void initialize(
      final UUID idParam,
      final String classpathParam,
      final String nativeLibraryDirParam,
      final ImmutableMap processEnvParam,
      final InetSocketAddress clientAddressParam) {
    this.clientAddressProvider = InstanceFactory.create(clientAddressParam);
    this.idProvider = InstanceFactory.create(idParam);
    this.clientConnectionServiceProvider =
        DoubleCheck.provider(
            ClientConnectionService_Factory.create(idProvider, clientAddressProvider));
    this.executorProvider = DoubleCheck.provider(CaliperProxyModule_ExecutorFactory.create());
    this.classpathProvider = InstanceFactory.create(classpathParam);
    this.nativeLibraryDirProvider = InstanceFactory.create(nativeLibraryDirParam);
    this.processEnvProvider = InstanceFactory.create(processEnvParam);
    this.caliperProxyProvider =
        DoubleCheck.provider(
            CaliperProxy_Factory.create(
                clientAddressProvider,
                clientConnectionServiceProvider,
                executorProvider,
                classpathProvider,
                nativeLibraryDirProvider,
                processEnvProvider));
  }

  @Override
  public CaliperProxy caliperProxy() {
    return caliperProxyProvider.get();
  }

  private static final class Builder implements CaliperProxyComponent.Builder {
    private UUID id;

    private String classpath;

    private String nativeLibraryDir;

    private ImmutableMap processEnv;

    private InetSocketAddress clientAddress;

    @Override
    public Builder id(UUID id) {
      this.id = Preconditions.checkNotNull(id);
      return this;
    }

    @Override
    public Builder classpath(String classpath) {
      this.classpath = Preconditions.checkNotNull(classpath);
      return this;
    }

    @Override
    public Builder nativeLibraryDir(String nativeLibraryDir) {
      this.nativeLibraryDir = Preconditions.checkNotNull(nativeLibraryDir);
      return this;
    }

    @Override
    public Builder processEnv(ImmutableMap processEnv) {
      this.processEnv = Preconditions.checkNotNull(processEnv);
      return this;
    }

    @Override
    public Builder clientAddress(InetSocketAddress address) {
      this.clientAddress = Preconditions.checkNotNull(address);
      return this;
    }

    @Override
    public CaliperProxyComponent build() {
      Preconditions.checkBuilderRequirement(id, UUID.class);
      Preconditions.checkBuilderRequirement(classpath, String.class);
      Preconditions.checkBuilderRequirement(nativeLibraryDir, String.class);
      Preconditions.checkBuilderRequirement(processEnv, ImmutableMap.class);
      Preconditions.checkBuilderRequirement(clientAddress, InetSocketAddress.class);
      return new DaggerCaliperProxyComponent(
          id, classpath, nativeLibraryDir, processEnv, clientAddress);
    }
  }
}