All Downloads are FREE. Search and download functionalities are using the official Maven repository.

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

The newest version!
package org.opentripplanner.standalone.configure;

import dagger.internal.DaggerGenerated;
import dagger.internal.DoubleCheck;
import dagger.internal.InstanceFactory;
import dagger.internal.Preconditions;
import dagger.internal.Provider;
import java.util.List;
import javax.annotation.processing.Generated;
import org.opentripplanner.astar.spi.TraverseVisitor;
import org.opentripplanner.ext.emissions.EmissionsDataModel;
import org.opentripplanner.ext.emissions.EmissionsService;
import org.opentripplanner.ext.emissions.EmissionsServiceModule;
import org.opentripplanner.ext.emissions.EmissionsServiceModule_ProvideEmissionsServiceFactory;
import org.opentripplanner.ext.geocoder.LuceneIndex;
import org.opentripplanner.ext.geocoder.configure.GeocoderModule;
import org.opentripplanner.ext.geocoder.configure.GeocoderModule_LuceneIndexFactory;
import org.opentripplanner.ext.interactivelauncher.configuration.InteractiveLauncherModule;
import org.opentripplanner.ext.interactivelauncher.configuration.InteractiveLauncherModule_RequestDecoratorFactory;
import org.opentripplanner.ext.ridehailing.RideHailingService;
import org.opentripplanner.ext.ridehailing.configure.RideHailingServicesModule;
import org.opentripplanner.ext.ridehailing.configure.RideHailingServicesModule_ServicesFactory;
import org.opentripplanner.ext.stopconsolidation.StopConsolidationRepository;
import org.opentripplanner.ext.stopconsolidation.StopConsolidationService;
import org.opentripplanner.ext.stopconsolidation.configure.StopConsolidationServiceModule;
import org.opentripplanner.ext.stopconsolidation.configure.StopConsolidationServiceModule_ServiceFactory;
import org.opentripplanner.graph_builder.issue.api.DataImportIssueSummary;
import org.opentripplanner.raptor.configure.RaptorConfig;
import org.opentripplanner.routing.algorithm.raptoradapter.transit.TripSchedule;
import org.opentripplanner.routing.graph.Graph;
import org.opentripplanner.service.realtimevehicles.RealtimeVehicleRepository;
import org.opentripplanner.service.realtimevehicles.RealtimeVehicleService;
import org.opentripplanner.service.realtimevehicles.internal.DefaultRealtimeVehicleService;
import org.opentripplanner.service.realtimevehicles.internal.DefaultRealtimeVehicleService_Factory;
import org.opentripplanner.service.vehiclerental.VehicleRentalRepository;
import org.opentripplanner.service.vehiclerental.VehicleRentalService;
import org.opentripplanner.service.vehiclerental.internal.DefaultVehicleRentalService;
import org.opentripplanner.service.vehiclerental.internal.DefaultVehicleRentalService_Factory;
import org.opentripplanner.service.worldenvelope.WorldEnvelopeRepository;
import org.opentripplanner.service.worldenvelope.WorldEnvelopeService;
import org.opentripplanner.service.worldenvelope.internal.DefaultWorldEnvelopeService;
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.street.model.StreetLimitationParameters;
import org.opentripplanner.street.service.StreetLimitationParametersService;
import org.opentripplanner.street.service.StreetLimitationParametersServiceModule;
import org.opentripplanner.street.service.StreetLimitationParametersServiceModule_ProvideStreetLimitationParametersServiceFactory;
import org.opentripplanner.transit.service.DefaultTransitService;
import org.opentripplanner.transit.service.DefaultTransitService_Factory;
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",
    "KotlinInternal",
    "KotlinInternalInJava",
    "cast",
    "deprecation"
})
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;

    private WorldEnvelopeRepository worldEnvelopeRepository;

    private StopConsolidationRepository stopConsolidationRepository;

    private DataImportIssueSummary dataImportIssueSummary;

    private EmissionsDataModel emissionsDataModel;

    private StreetLimitationParameters streetLimitationParameters;

    @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 Builder worldEnvelopeRepository(WorldEnvelopeRepository worldEnvelopeRepository) {
      this.worldEnvelopeRepository = Preconditions.checkNotNull(worldEnvelopeRepository);
      return this;
    }

    @Override
    public Builder stopConsolidationRepository(
        StopConsolidationRepository stopConsolidationRepository) {
      this.stopConsolidationRepository = stopConsolidationRepository;
      return this;
    }

    @Override
    public Builder dataImportIssueSummary(DataImportIssueSummary issueSummary) {
      this.dataImportIssueSummary = Preconditions.checkNotNull(issueSummary);
      return this;
    }

    @Override
    public Builder emissionsDataModel(EmissionsDataModel emissionsDataModel) {
      this.emissionsDataModel = Preconditions.checkNotNull(emissionsDataModel);
      return this;
    }

    @Override
    public Builder streetLimitationParameters(
        StreetLimitationParameters streetLimitationParameters) {
      this.streetLimitationParameters = Preconditions.checkNotNull(streetLimitationParameters);
      return this;
    }

    @Override
    public ConstructApplicationFactory build() {
      Preconditions.checkBuilderRequirement(configModel, ConfigModel.class);
      Preconditions.checkBuilderRequirement(graph, Graph.class);
      Preconditions.checkBuilderRequirement(transitModel, TransitModel.class);
      Preconditions.checkBuilderRequirement(worldEnvelopeRepository, WorldEnvelopeRepository.class);
      Preconditions.checkBuilderRequirement(dataImportIssueSummary, DataImportIssueSummary.class);
      Preconditions.checkBuilderRequirement(emissionsDataModel, EmissionsDataModel.class);
      Preconditions.checkBuilderRequirement(streetLimitationParameters, StreetLimitationParameters.class);
      return new ConstructApplicationFactoryImpl(new ConstructApplicationModule(), new RideHailingServicesModule(), new EmissionsServiceModule(), new StopConsolidationServiceModule(), new InteractiveLauncherModule(), new StreetLimitationParametersServiceModule(), new GeocoderModule(), configModel, graph, transitModel, graphVisualizer, worldEnvelopeRepository, stopConsolidationRepository, dataImportIssueSummary, emissionsDataModel, streetLimitationParameters);
    }
  }

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

    private final Graph graph;

    private final TransitModel transitModel;

    private final WorldEnvelopeRepository worldEnvelopeRepository;

    private final DataImportIssueSummary dataImportIssueSummary;

    private final EmissionsDataModel emissionsDataModel;

    private final GraphVisualizer graphVisualizer;

    private final ConstructApplicationModule constructApplicationModule;

    private final InteractiveLauncherModule interactiveLauncherModule;

    private final StopConsolidationRepository stopConsolidationRepository;

    private final StreetLimitationParameters streetLimitationParameters;

    private final ConstructApplicationFactoryImpl constructApplicationFactoryImpl = this;

    private Provider configModelProvider;

    private Provider> providesRaptorConfigProvider;

    private Provider transitModelProvider;

    private Provider defaultTransitServiceProvider;

    private Provider defaultRealtimeVehicleServiceProvider;

    private Provider defaultVehicleRentalServiceProvider;

    private Provider provideRouterConfigProvider;

    private Provider> servicesProvider;

    private Provider stopConsolidationRepositoryProvider;

    private Provider serviceProvider;

    private Provider streetLimitationParametersProvider;

    private Provider provideStreetLimitationParametersServiceProvider;

    private Provider emissionsDataModelProvider;

    private Provider provideEmissionsServiceProvider;

    private Provider luceneIndexProvider;

    private ConstructApplicationFactoryImpl(
        ConstructApplicationModule constructApplicationModuleParam,
        RideHailingServicesModule rideHailingServicesModuleParam,
        EmissionsServiceModule emissionsServiceModuleParam,
        StopConsolidationServiceModule stopConsolidationServiceModuleParam,
        InteractiveLauncherModule interactiveLauncherModuleParam,
        StreetLimitationParametersServiceModule streetLimitationParametersServiceModuleParam,
        GeocoderModule geocoderModuleParam, ConfigModel configModelParam, Graph graphParam,
        TransitModel transitModelParam, GraphVisualizer graphVisualizerParam,
        WorldEnvelopeRepository worldEnvelopeRepositoryParam,
        StopConsolidationRepository stopConsolidationRepositoryParam,
        DataImportIssueSummary dataImportIssueSummaryParam,
        EmissionsDataModel emissionsDataModelParam,
        StreetLimitationParameters streetLimitationParametersParam) {
      this.configModel = configModelParam;
      this.graph = graphParam;
      this.transitModel = transitModelParam;
      this.worldEnvelopeRepository = worldEnvelopeRepositoryParam;
      this.dataImportIssueSummary = dataImportIssueSummaryParam;
      this.emissionsDataModel = emissionsDataModelParam;
      this.graphVisualizer = graphVisualizerParam;
      this.constructApplicationModule = constructApplicationModuleParam;
      this.interactiveLauncherModule = interactiveLauncherModuleParam;
      this.stopConsolidationRepository = stopConsolidationRepositoryParam;
      this.streetLimitationParameters = streetLimitationParametersParam;
      initialize(constructApplicationModuleParam, rideHailingServicesModuleParam, emissionsServiceModuleParam, stopConsolidationServiceModuleParam, interactiveLauncherModuleParam, streetLimitationParametersServiceModuleParam, geocoderModuleParam, configModelParam, graphParam, transitModelParam, graphVisualizerParam, worldEnvelopeRepositoryParam, stopConsolidationRepositoryParam, dataImportIssueSummaryParam, emissionsDataModelParam, streetLimitationParametersParam);

    }

    private DefaultWorldEnvelopeService defaultWorldEnvelopeService() {
      return new DefaultWorldEnvelopeService(worldEnvelopeRepository);
    }

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

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

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

    @SuppressWarnings("unchecked")
    private void initialize(final ConstructApplicationModule constructApplicationModuleParam,
        final RideHailingServicesModule rideHailingServicesModuleParam,
        final EmissionsServiceModule emissionsServiceModuleParam,
        final StopConsolidationServiceModule stopConsolidationServiceModuleParam,
        final InteractiveLauncherModule interactiveLauncherModuleParam,
        final StreetLimitationParametersServiceModule streetLimitationParametersServiceModuleParam,
        final GeocoderModule geocoderModuleParam, final ConfigModel configModelParam,
        final Graph graphParam, final TransitModel transitModelParam,
        final GraphVisualizer graphVisualizerParam,
        final WorldEnvelopeRepository worldEnvelopeRepositoryParam,
        final StopConsolidationRepository stopConsolidationRepositoryParam,
        final DataImportIssueSummary dataImportIssueSummaryParam,
        final EmissionsDataModel emissionsDataModelParam,
        final StreetLimitationParameters streetLimitationParametersParam) {
      this.configModelProvider = InstanceFactory.create(configModelParam);
      this.providesRaptorConfigProvider = DoubleCheck.provider(ConfigModule_ProvidesRaptorConfigFactory.create(configModelProvider));
      this.transitModelProvider = InstanceFactory.create(transitModelParam);
      this.defaultTransitServiceProvider = DefaultTransitService_Factory.create(transitModelProvider);
      this.defaultRealtimeVehicleServiceProvider = DoubleCheck.provider(DefaultRealtimeVehicleService_Factory.create(((Provider) defaultTransitServiceProvider)));
      this.defaultVehicleRentalServiceProvider = DoubleCheck.provider(DefaultVehicleRentalService_Factory.create());
      this.provideRouterConfigProvider = ConfigModule_ProvideRouterConfigFactory.create(configModelProvider);
      this.servicesProvider = DoubleCheck.provider(RideHailingServicesModule_ServicesFactory.create(rideHailingServicesModuleParam, provideRouterConfigProvider));
      this.stopConsolidationRepositoryProvider = InstanceFactory.createNullable(stopConsolidationRepositoryParam);
      this.serviceProvider = DoubleCheck.provider(StopConsolidationServiceModule_ServiceFactory.create(stopConsolidationServiceModuleParam, stopConsolidationRepositoryProvider, transitModelProvider));
      this.streetLimitationParametersProvider = InstanceFactory.create(streetLimitationParametersParam);
      this.provideStreetLimitationParametersServiceProvider = DoubleCheck.provider(StreetLimitationParametersServiceModule_ProvideStreetLimitationParametersServiceFactory.create(streetLimitationParametersServiceModuleParam, streetLimitationParametersProvider));
      this.emissionsDataModelProvider = InstanceFactory.create(emissionsDataModelParam);
      this.provideEmissionsServiceProvider = DoubleCheck.provider(EmissionsServiceModule_ProvideEmissionsServiceFactory.create(emissionsServiceModuleParam, emissionsDataModelProvider));
      this.luceneIndexProvider = DoubleCheck.provider(GeocoderModule_LuceneIndexFactory.create(geocoderModuleParam, transitModelProvider, serviceProvider));
    }

    @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 WorldEnvelopeRepository worldEnvelopeRepository() {
      return worldEnvelopeRepository;
    }

    @Override
    public WorldEnvelopeService worldEnvelopeService() {
      return defaultWorldEnvelopeService();
    }

    @Override
    public RealtimeVehicleRepository realtimeVehicleRepository() {
      return defaultRealtimeVehicleServiceProvider.get();
    }

    @Override
    public RealtimeVehicleService realtimeVehicleService() {
      return defaultRealtimeVehicleServiceProvider.get();
    }

    @Override
    public VehicleRentalRepository vehicleRentalRepository() {
      return defaultVehicleRentalServiceProvider.get();
    }

    @Override
    public VehicleRentalService vehicleRentalService() {
      return defaultVehicleRentalServiceProvider.get();
    }

    @Override
    public DataImportIssueSummary dataImportIssueSummary() {
      return dataImportIssueSummary;
    }

    @Override
    public EmissionsDataModel emissionsDataModel() {
      return emissionsDataModel;
    }

    @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(), defaultWorldEnvelopeService(), defaultRealtimeVehicleServiceProvider.get(), defaultVehicleRentalServiceProvider.get(), servicesProvider.get(), serviceProvider.get(), provideStreetLimitationParametersServiceProvider.get(), traverseVisitorOfAnd(), provideEmissionsServiceProvider.get(), InteractiveLauncherModule_RequestDecoratorFactory.requestDecorator(interactiveLauncherModule), luceneIndexProvider.get());
    }

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

    @Override
    public StopConsolidationRepository stopConsolidationRepository() {
      return stopConsolidationRepository;
    }

    @Override
    public StreetLimitationParameters streetLimitationParameters() {
      return streetLimitationParameters;
    }

    @Override
    public LuceneIndex luceneIndex() {
      return luceneIndexProvider.get();
    }
  }
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy