org.opentripplanner.standalone.configure.DaggerConstructApplicationFactory Maven / Gradle / Ivy

Go to download
package org.opentripplanner.standalone.configure;

import dagger.internal.DaggerGenerated;
import dagger.internal.DoubleCheck;
import dagger.internal.InstanceFactory;
import dagger.internal.Preconditions;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import org.opentripplanner.routing.algorithm.astar.TraverseVisitor;
import org.opentripplanner.routing.algorithm.raptoradapter.transit.TripSchedule;
import org.opentripplanner.routing.graph.Graph;
import org.opentripplanner.standalone.api.OtpServerRequestContext;
import org.opentripplanner.standalone.config.ConfigModel;
import org.opentripplanner.standalone.config.RouterConfig;
import org.opentripplanner.standalone.config.configure.ConfigModule_ProvideRouterConfigFactory;
import org.opentripplanner.standalone.config.configure.ConfigModule_ProvidesRaptorConfigFactory;
import org.opentripplanner.standalone.server.MetricsLogging;
import org.opentripplanner.transit.raptor.configure.RaptorConfig;
import org.opentripplanner.transit.service.DefaultTransitService;
import org.opentripplanner.transit.service.TransitModel;
import org.opentripplanner.transit.service.TransitService;
import org.opentripplanner.visualizer.GraphVisualizer;

@DaggerGenerated
@Generated(
    value = "dagger.internal.codegen.ComponentProcessor",
    comments = "https://dagger.dev"
)
@SuppressWarnings({
    "unchecked",
    "rawtypes"
})
public final class DaggerConstructApplicationFactory {
  private DaggerConstructApplicationFactory() {
  }

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

  private static final class Builder implements ConstructApplicationFactory.Builder {
    private ConfigModel configModel;

    private Graph graph;

    private TransitModel transitModel;

    private GraphVisualizer graphVisualizer;

    @Override
    public Builder configModel(ConfigModel config) {
      this.configModel = Preconditions.checkNotNull(config);
      return this;
    }

    @Override
    public Builder graph(Graph graph) {
      this.graph = Preconditions.checkNotNull(graph);
      return this;
    }

    @Override
    public Builder transitModel(TransitModel transitModel) {
      this.transitModel = Preconditions.checkNotNull(transitModel);
      return this;
    }

    @Override
    public Builder graphVisualizer(GraphVisualizer graphVisualizer) {
      this.graphVisualizer = graphVisualizer;
      return this;
    }

    @Override
    public ConstructApplicationFactory build() {
      Preconditions.checkBuilderRequirement(configModel, ConfigModel.class);
      Preconditions.checkBuilderRequirement(graph, Graph.class);
      Preconditions.checkBuilderRequirement(transitModel, TransitModel.class);
      return new ConstructApplicationFactoryImpl(new ConstructApplicationModule(), configModel, graph, transitModel, graphVisualizer);
    }
  }

  private static final class ConstructApplicationFactoryImpl implements ConstructApplicationFactory {
    private final ConfigModel configModel;

    private final Graph graph;

    private final TransitModel transitModel;

    private final GraphVisualizer graphVisualizer;

    private final ConstructApplicationModule constructApplicationModule;

    private final ConstructApplicationFactoryImpl constructApplicationFactoryImpl = this;

    private Provider configModelProvider;

    private Provider> providesRaptorConfigProvider;

    private ConstructApplicationFactoryImpl(
        ConstructApplicationModule constructApplicationModuleParam, ConfigModel configModelParam,
        Graph graphParam, TransitModel transitModelParam, GraphVisualizer graphVisualizerParam) {
      this.configModel = configModelParam;
      this.graph = graphParam;
      this.transitModel = transitModelParam;
      this.graphVisualizer = graphVisualizerParam;
      this.constructApplicationModule = constructApplicationModuleParam;
      initialize(constructApplicationModuleParam, configModelParam, graphParam, transitModelParam, graphVisualizerParam);

    }

    private DefaultTransitService defaultTransitService() {
      return new DefaultTransitService(transitModel);
    }

    private RouterConfig routerConfig() {
      return ConfigModule_ProvideRouterConfigFactory.provideRouterConfig(configModel);
    }

    private TraverseVisitor traverseVisitor() {
      return constructApplicationModule.traverseVisitor(graphVisualizer);
    }

    @SuppressWarnings("unchecked")
    private void initialize(final ConstructApplicationModule constructApplicationModuleParam,
        final ConfigModel configModelParam, final Graph graphParam,
        final TransitModel transitModelParam, final GraphVisualizer graphVisualizerParam) {
      this.configModelProvider = InstanceFactory.create(configModelParam);
      this.providesRaptorConfigProvider = DoubleCheck.provider(ConfigModule_ProvidesRaptorConfigFactory.create(configModelProvider));
    }

    @Override
    public ConfigModel config() {
      return configModel;
    }

    @Override
    public RaptorConfig raptorConfig() {
      return providesRaptorConfigProvider.get();
    }

    @Override
    public Graph graph() {
      return graph;
    }

    @Override
    public TransitModel transitModel() {
      return transitModel;
    }

    @Override
    public GraphVisualizer graphVisualizer() {
      return graphVisualizer;
    }

    @Override
    public TransitService transitService() {
      return defaultTransitService();
    }

    @Override
    public OtpServerRequestContext createServerContext() {
      return ConstructApplicationModule_ProvidesServerContextFactory.providesServerContext(constructApplicationModule, routerConfig(), providesRaptorConfigProvider.get(), graph, defaultTransitService(), traverseVisitor());
    }

    @Override
    public MetricsLogging metricsLogging() {
      return new MetricsLogging(transitModel, providesRaptorConfigProvider.get());
    }
  }
}