All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.google.caliper.worker.DaggerWorkerMain Maven / Gradle / Ivy

    The newest version!
    package com.google.caliper.worker;

import com.google.caliper.bridge.DryRunRequest;
import com.google.caliper.bridge.ExperimentSpec;
import com.google.caliper.bridge.TargetInfoRequest;
import com.google.caliper.bridge.TrialRequest;
import com.google.caliper.model.BenchmarkSpec;
import com.google.caliper.model.InstrumentType;
import com.google.caliper.worker.connection.ClientConnectionService;
import com.google.caliper.worker.connection.ClientConnectionService_Factory;
import com.google.caliper.worker.handler.DryRunHandler_Factory;
import com.google.caliper.worker.handler.RequestDispatcher;
import com.google.caliper.worker.handler.RequestDispatcher_Factory;
import com.google.caliper.worker.handler.TargetInfoHandler_Factory;
import com.google.caliper.worker.handler.TrialHandler_Factory;
import com.google.caliper.worker.instrument.ArbitraryMeasurementWorkerInstrument_Factory;
import com.google.caliper.worker.instrument.BenchmarkCreator_Factory;
import com.google.caliper.worker.instrument.MacrobenchmarkWorkerInstrument_Factory;
import com.google.caliper.worker.instrument.RuntimeWorkerInstrument_Micro_Factory;
import com.google.caliper.worker.instrument.RuntimeWorkerInstrument_Pico_Factory;
import com.google.caliper.worker.instrument.WorkerInstrument;
import com.google.caliper.worker.instrument.WorkerInstrumentFactory;
import com.google.caliper.worker.instrument.WorkerInstrumentFactory_Factory;
import com.google.caliper.worker.instrument.WorkerInstrumentModule_ProvideBenchmarkInstanceFactory;
import com.google.caliper.worker.instrument.WorkerInstrumentModule_ProvideBenchmarkMethodFactory;
import com.google.caliper.worker.instrument.WorkerInstrumentModule_ProvideBenchmarkMethodNameFactory;
import com.google.caliper.worker.instrument.WorkerInstrumentModule_ProvideBenchmarkSpecFactory;
import com.google.caliper.worker.instrument.WorkerInstrumentModule_ProvideInstrumentTypeFactory;
import com.google.caliper.worker.instrument.WorkerInstrumentModule_ProvideTickerFactory;
import com.google.caliper.worker.instrument.WorkerInstrumentModule_ProvideUserParametersFactory;
import com.google.caliper.worker.instrument.WorkerInstrumentModule_ProvideWorkerInstrumentFactory;
import com.google.caliper.worker.instrument.WorkerInstrumentModule_ProvideWorkerInstrumentOptionsFactory;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSortedMap;
import dagger.internal.DoubleCheck;
import dagger.internal.InstanceFactory;
import dagger.internal.Preconditions;
import dagger.internal.SingleCheck;
import java.lang.reflect.Method;
import java.net.InetSocketAddress;
import java.util.Map;
import java.util.Random;
import java.util.UUID;
import javax.annotation.Generated;
import javax.inject.Provider;

@Generated(
  value = "dagger.internal.codegen.ComponentProcessor",
  comments = "https://google.github.io/dagger"
)
public final class DaggerWorkerMain extends WorkerMain {
  private Provider idProvider;

  private Provider clientAddressProvider;

  private Provider clientConnectionServiceProvider;

  private Provider> benchmarkClassProvider;

  @SuppressWarnings("rawtypes")
  private Provider targetInfoHandlerProvider;

  private Provider
      jvmWorkerInstrumentComponentBuilderProvider;

  private Provider workerInstrumentFactoryProvider;

  @SuppressWarnings("rawtypes")
  private Provider dryRunHandlerProvider;

  @SuppressWarnings("rawtypes")
  private Provider trialHandlerProvider;

  private Provider provideRandomProvider;

  private DaggerWorkerMain(WorkerOptionsModule workerOptionsModuleParam) {

    initialize(workerOptionsModuleParam);
  }

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

  private Map getMapOfClassOfAndProviderOfRequestHandler() {
    return ImmutableMap.of(
        TargetInfoRequest.class,
        targetInfoHandlerProvider,
        DryRunRequest.class,
        dryRunHandlerProvider,
        TrialRequest.class,
        trialHandlerProvider);
  }

  private RequestDispatcher getRequestDispatcher() {
    return RequestDispatcher_Factory.newInstance(
        (Map) getMapOfClassOfAndProviderOfRequestHandler());
  }

  @SuppressWarnings("unchecked")
  private void initialize(final WorkerOptionsModule workerOptionsModuleParam) {
    this.idProvider = WorkerOptionsModule_IdFactory.create(workerOptionsModuleParam);
    this.clientAddressProvider =
        WorkerOptionsModule_ClientAddressFactory.create(workerOptionsModuleParam);
    this.clientConnectionServiceProvider =
        DoubleCheck.provider(
            ClientConnectionService_Factory.create(idProvider, clientAddressProvider));
    this.benchmarkClassProvider =
        SingleCheck.provider(
            WorkerOptionsModule_BenchmarkClassFactory.create(workerOptionsModuleParam));
    this.targetInfoHandlerProvider =
        TargetInfoHandler_Factory.create(clientConnectionServiceProvider, benchmarkClassProvider);
    this.jvmWorkerInstrumentComponentBuilderProvider =
        new Provider() {
          @Override
          public JvmWorkerInstrumentComponent.Builder get() {
            return new JvmWorkerInstrumentComponentBuilder();
          }
        };
    this.workerInstrumentFactoryProvider =
        WorkerInstrumentFactory_Factory.create(
            (Provider) jvmWorkerInstrumentComponentBuilderProvider);
    this.dryRunHandlerProvider =
        DryRunHandler_Factory.create(
            clientConnectionServiceProvider, workerInstrumentFactoryProvider);
    this.trialHandlerProvider =
        TrialHandler_Factory.create(
            clientConnectionServiceProvider, workerInstrumentFactoryProvider);
    this.provideRandomProvider = DoubleCheck.provider(WorkerModule_ProvideRandomFactory.create());
  }

  @Override
  public Worker worker() {
    return new Worker(clientConnectionServiceProvider.get(), getRequestDispatcher());
  }

  private static final class Builder implements WorkerMain.Builder {
    private WorkerOptionsModule workerOptionsModule;

    @Override
    public Builder options(WorkerOptionsModule arg0) {
      this.workerOptionsModule = Preconditions.checkNotNull(arg0);
      return this;
    }

    @Override
    public WorkerMain build() {
      Preconditions.checkBuilderRequirement(workerOptionsModule, WorkerOptionsModule.class);
      return new DaggerWorkerMain(workerOptionsModule);
    }
  }

  private final class JvmWorkerInstrumentComponentBuilder
      implements JvmWorkerInstrumentComponent.Builder {
    private ExperimentSpec experiment;

    @Override
    public JvmWorkerInstrumentComponentBuilder experiment(ExperimentSpec arg0) {
      this.experiment = Preconditions.checkNotNull(arg0);
      return this;
    }

    @Override
    public JvmWorkerInstrumentComponent build() {
      Preconditions.checkBuilderRequirement(experiment, ExperimentSpec.class);
      return new JvmWorkerInstrumentComponentImpl(experiment);
    }
  }

  private final class JvmWorkerInstrumentComponentImpl implements JvmWorkerInstrumentComponent {
    private final ExperimentSpec experiment;

    private Provider experimentProvider;

    private Provider provideBenchmarkSpecProvider;

    private Provider> provideUserParametersProvider;

    @SuppressWarnings("rawtypes")
    private Provider benchmarkCreatorProvider;

    private Provider provideBenchmarkInstanceProvider;

    private Provider provideBenchmarkMethodProvider;

    private Provider> provideWorkerInstrumentOptionsProvider;

    private Provider> provideBeforeExperimentMethodsProvider;

    private Provider> provideAfterExperimentMethodsProvider;

    @SuppressWarnings("rawtypes")
    private Provider arbitraryMeasurementWorkerInstrumentProvider;

    @SuppressWarnings("rawtypes")
    private Provider macrobenchmarkWorkerInstrumentProvider;

    @SuppressWarnings("rawtypes")
    private Provider microProvider;

    @SuppressWarnings("rawtypes")
    private Provider picoProvider;

    private Provider provideBenchmarkMethodNameProvider;

    private Provider allAllocationsRecorderProvider;

    private Provider provideAllocationRecorderProvider;

    private Provider
        microbenchmarkAllocationWorkerInstrumentProvider;

    private Provider
        macrobenchmarkAllocationWorkerInstrumentProvider;

    private JvmWorkerInstrumentComponentImpl(ExperimentSpec experimentParam) {
      this.experiment = experimentParam;
      initialize(experimentParam);
    }

    private InstrumentType getInstrumentType() {
      return WorkerInstrumentModule_ProvideInstrumentTypeFactory.provideInstrumentType(experiment);
    }

    private Map>
        getMapOfInstrumentTypeAndProviderOfWorkerInstrument() {
      return ImmutableMap.>builderWithExpectedSize(6)
          .put(InstrumentType.ARBITRARY_MEASUREMENT, arbitraryMeasurementWorkerInstrumentProvider)
          .put(InstrumentType.RUNTIME_MACRO, macrobenchmarkWorkerInstrumentProvider)
          .put(InstrumentType.RUNTIME_MICRO, microProvider)
          .put(InstrumentType.RUNTIME_PICO, picoProvider)
          .put(
              InstrumentType.ALLOCATION_MICRO,
              (Provider) microbenchmarkAllocationWorkerInstrumentProvider)
          .put(
              InstrumentType.ALLOCATION_MACRO,
              (Provider) macrobenchmarkAllocationWorkerInstrumentProvider)
          .build();
    }

    @SuppressWarnings("unchecked")
    private void initialize(final ExperimentSpec experimentParam) {
      this.experimentProvider = InstanceFactory.create(experimentParam);
      this.provideBenchmarkSpecProvider =
          WorkerInstrumentModule_ProvideBenchmarkSpecFactory.create(experimentProvider);
      this.provideUserParametersProvider =
          WorkerInstrumentModule_ProvideUserParametersFactory.create(provideBenchmarkSpecProvider);
      this.benchmarkCreatorProvider =
          BenchmarkCreator_Factory.create(
              DaggerWorkerMain.this.benchmarkClassProvider, provideUserParametersProvider);
      this.provideBenchmarkInstanceProvider =
          WorkerInstrumentModule_ProvideBenchmarkInstanceFactory.create(benchmarkCreatorProvider);
      this.provideBenchmarkMethodProvider =
          SingleCheck.provider(
              WorkerInstrumentModule_ProvideBenchmarkMethodFactory.create(
                  experimentProvider,
                  provideBenchmarkSpecProvider,
                  DaggerWorkerMain.this.benchmarkClassProvider));
      this.provideWorkerInstrumentOptionsProvider =
          WorkerInstrumentModule_ProvideWorkerInstrumentOptionsFactory.create(experimentProvider);
      this.provideBeforeExperimentMethodsProvider =
          SingleCheck.provider(
              WorkerModule_ProvideBeforeExperimentMethodsFactory.create(
                  DaggerWorkerMain.this.benchmarkClassProvider));
      this.provideAfterExperimentMethodsProvider =
          SingleCheck.provider(
              WorkerModule_ProvideAfterExperimentMethodsFactory.create(
                  DaggerWorkerMain.this.benchmarkClassProvider));
      this.arbitraryMeasurementWorkerInstrumentProvider =
          ArbitraryMeasurementWorkerInstrument_Factory.create(
              provideBenchmarkInstanceProvider,
              provideBenchmarkMethodProvider,
              provideWorkerInstrumentOptionsProvider,
              provideBeforeExperimentMethodsProvider,
              provideAfterExperimentMethodsProvider);
      this.macrobenchmarkWorkerInstrumentProvider =
          MacrobenchmarkWorkerInstrument_Factory.create(
              provideBenchmarkInstanceProvider,
              provideBenchmarkMethodProvider,
              WorkerInstrumentModule_ProvideTickerFactory.create(),
              provideWorkerInstrumentOptionsProvider,
              provideBeforeExperimentMethodsProvider,
              provideAfterExperimentMethodsProvider);
      this.microProvider =
          RuntimeWorkerInstrument_Micro_Factory.create(
              provideBenchmarkInstanceProvider,
              provideBenchmarkMethodProvider,
              DaggerWorkerMain.this.provideRandomProvider,
              WorkerInstrumentModule_ProvideTickerFactory.create(),
              provideWorkerInstrumentOptionsProvider,
              provideBeforeExperimentMethodsProvider,
              provideAfterExperimentMethodsProvider);
      this.picoProvider =
          RuntimeWorkerInstrument_Pico_Factory.create(
              provideBenchmarkInstanceProvider,
              provideBenchmarkMethodProvider,
              DaggerWorkerMain.this.provideRandomProvider,
              WorkerInstrumentModule_ProvideTickerFactory.create(),
              provideWorkerInstrumentOptionsProvider,
              provideBeforeExperimentMethodsProvider,
              provideAfterExperimentMethodsProvider);
      this.provideBenchmarkMethodNameProvider =
          WorkerInstrumentModule_ProvideBenchmarkMethodNameFactory.create(
              provideBenchmarkMethodProvider);
      this.allAllocationsRecorderProvider =
          AllAllocationsRecorder_Factory.create(
              DaggerWorkerMain.this.benchmarkClassProvider, provideBenchmarkMethodNameProvider);
      this.provideAllocationRecorderProvider =
          JvmWorkerInstrumentModule_ProvideAllocationRecorderFactory.create(
              provideWorkerInstrumentOptionsProvider,
              allAllocationsRecorderProvider,
              AggregateAllocationsRecorder_Factory.create());
      this.microbenchmarkAllocationWorkerInstrumentProvider =
          MicrobenchmarkAllocationWorkerInstrument_Factory.create(
              provideBenchmarkInstanceProvider,
              provideBenchmarkMethodProvider,
              provideAllocationRecorderProvider,
              DaggerWorkerMain.this.provideRandomProvider,
              provideBeforeExperimentMethodsProvider,
              provideAfterExperimentMethodsProvider);
      this.macrobenchmarkAllocationWorkerInstrumentProvider =
          MacrobenchmarkAllocationWorkerInstrument_Factory.create(
              provideBenchmarkInstanceProvider,
              provideBenchmarkMethodProvider,
              provideAllocationRecorderProvider,
              provideBeforeExperimentMethodsProvider,
              provideAfterExperimentMethodsProvider);
    }

    @Override
    public WorkerInstrument instrument() {
      return WorkerInstrumentModule_ProvideWorkerInstrumentFactory.provideWorkerInstrument(
          getInstrumentType(), getMapOfInstrumentTypeAndProviderOfWorkerInstrument());
    }
  }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy