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

Go to download
Show more of this group Show more artifacts with this name
Show all versions of application Show documentation
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 graphql.schema.GraphQLSchema;
import java.util.List;
import javax.annotation.Nullable;
import javax.annotation.processing.Generated;
import org.opentripplanner.apis.gtfs.configure.SchemaModule;
import org.opentripplanner.apis.gtfs.configure.SchemaModule_ProvideSchemaFactory;
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.sorlandsbanen.SorlandsbanenNorwayService;
import org.opentripplanner.ext.sorlandsbanen.configure.SorlandsbanenNorwayModule;
import org.opentripplanner.ext.sorlandsbanen.configure.SorlandsbanenNorwayModule_ProvidesSorlandsbanenNorwayServiceFactory;
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.model.TimetableSnapshot;
import org.opentripplanner.raptor.api.request.RaptorEnvironment;
import org.opentripplanner.raptor.configure.RaptorConfig;
import org.opentripplanner.routing.algorithm.raptoradapter.transit.TripSchedule;
import org.opentripplanner.routing.algorithm.raptoradapter.transit.mappers.RealTimeRaptorTransitDataUpdater;
import org.opentripplanner.routing.api.request.RouteRequest;
import org.opentripplanner.routing.graph.Graph;
import org.opentripplanner.routing.via.ViaCoordinateTransferFactory;
import org.opentripplanner.routing.via.configure.ViaModule_ProvidesViaTransferResolverFactory;
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.vehicleparking.VehicleParkingRepository;
import org.opentripplanner.service.vehicleparking.VehicleParkingService;
import org.opentripplanner.service.vehicleparking.internal.DefaultVehicleParkingService;
import org.opentripplanner.service.vehicleparking.internal.DefaultVehicleParkingService_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.BuildConfig;
import org.opentripplanner.standalone.config.ConfigModel;
import org.opentripplanner.standalone.config.DebugUiConfig;
import org.opentripplanner.standalone.config.RouterConfig;
import org.opentripplanner.standalone.config.configure.ConfigModule_ProvideBuildConfigFactory;
import org.opentripplanner.standalone.config.configure.ConfigModule_ProvideDebugUiConfigFactory;
import org.opentripplanner.standalone.config.configure.ConfigModule_ProvideRouterConfigFactory;
import org.opentripplanner.standalone.config.configure.ConfigModule_ProvidesRaptorConfigFactory;
import org.opentripplanner.standalone.config.configure.ConfigModule_ProvidesRaptorEnvironmentFactory;
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.configure.TransitModule_RealtimeRaptorTransitDataUpdaterFactory;
import org.opentripplanner.transit.configure.TransitModule_TimetableSnapshotFactory;
import org.opentripplanner.transit.configure.TransitModule_TimetableSnapshotManagerFactory;
import org.opentripplanner.transit.service.DefaultTransitService;
import org.opentripplanner.transit.service.DefaultTransitService_Factory;
import org.opentripplanner.transit.service.TimetableRepository;
import org.opentripplanner.transit.service.TransitService;
import org.opentripplanner.updater.trip.TimetableSnapshotManager;
import org.opentripplanner.visualizer.GraphVisualizer;

@DaggerGenerated
@Generated(
    value = "dagger.internal.codegen.ComponentProcessor",
    comments = "https://dagger.dev"
)
@SuppressWarnings({
    "unchecked",
    "rawtypes",
    "KotlinInternal",
    "KotlinInternalInJava",
    "cast",
    "deprecation",
    "nullness:initialization.field.uninitialized"
})
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 TimetableRepository timetableRepository;

    private GraphVisualizer graphVisualizer;

    private WorldEnvelopeRepository worldEnvelopeRepository;

    private StopConsolidationRepository stopConsolidationRepository;

    private VehicleParkingRepository vehicleParkingRepository;

    private DataImportIssueSummary dataImportIssueSummary;

    private EmissionsDataModel emissionsDataModel;

    private RouteRequest schema;

    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 timetableRepository(TimetableRepository timetableRepository) {
      this.timetableRepository = Preconditions.checkNotNull(timetableRepository);
      return this;
    }

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

    @Override
    public Builder worldEnvelopeRepository(WorldEnvelopeRepository worldEnvelopeRepository) {
      this.worldEnvelopeRepository = Preconditions.checkNotNull(worldEnvelopeRepository);
      return this;
    }

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

    @Override
    public Builder vehicleParkingRepository(VehicleParkingRepository parkingRepository) {
      this.vehicleParkingRepository = Preconditions.checkNotNull(parkingRepository);
      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 schema(RouteRequest defaultRouteRequest) {
      this.schema = Preconditions.checkNotNull(defaultRouteRequest);
      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(timetableRepository, TimetableRepository.class);
      Preconditions.checkBuilderRequirement(worldEnvelopeRepository, WorldEnvelopeRepository.class);
      Preconditions.checkBuilderRequirement(vehicleParkingRepository, VehicleParkingRepository.class);
      Preconditions.checkBuilderRequirement(dataImportIssueSummary, DataImportIssueSummary.class);
      Preconditions.checkBuilderRequirement(emissionsDataModel, EmissionsDataModel.class);
      Preconditions.checkBuilderRequirement(schema, RouteRequest.class);
      Preconditions.checkBuilderRequirement(streetLimitationParameters, StreetLimitationParameters.class);
      return new ConstructApplicationFactoryImpl(new ConstructApplicationModule(), new EmissionsServiceModule(), new GeocoderModule(), new InteractiveLauncherModule(), new RideHailingServicesModule(), new SchemaModule(), new SorlandsbanenNorwayModule(), new StopConsolidationServiceModule(), new StreetLimitationParametersServiceModule(), configModel, graph, timetableRepository, graphVisualizer, worldEnvelopeRepository, stopConsolidationRepository, vehicleParkingRepository, dataImportIssueSummary, emissionsDataModel, schema, streetLimitationParameters);
    }
  }

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

    private final Graph graph;

    private final TimetableRepository timetableRepository;

    private final WorldEnvelopeRepository worldEnvelopeRepository;

    private final VehicleParkingRepository vehicleParkingRepository;

    private final DataImportIssueSummary dataImportIssueSummary;

    private final EmissionsDataModel emissionsDataModel;

    @Nullable
    private final GraphVisualizer graphVisualizer;

    private final ConstructApplicationModule constructApplicationModule;

    private final SorlandsbanenNorwayModule sorlandsbanenNorwayModule;

    private final InteractiveLauncherModule interactiveLauncherModule;

    @Nullable
    private final StopConsolidationRepository stopConsolidationRepository;

    private final StreetLimitationParameters streetLimitationParameters;

    private final ConstructApplicationFactoryImpl constructApplicationFactoryImpl = this;

    private Provider configModelProvider;

    private Provider provideRouterConfigProvider;

    private Provider providesRaptorEnvironmentProvider;

    private Provider> providesRaptorConfigProvider;

    private Provider timetableRepositoryProvider;

    private Provider realtimeRaptorTransitDataUpdaterProvider;

    private Provider timetableSnapshotManagerProvider;

    private Provider timetableSnapshotProvider;

    private Provider defaultTransitServiceProvider;

    private Provider defaultRealtimeVehicleServiceProvider;

    private Provider defaultVehicleRentalServiceProvider;

    private Provider vehicleParkingRepositoryProvider;

    private Provider defaultVehicleParkingServiceProvider;

    private Provider> servicesProvider;

    private Provider stopConsolidationRepositoryProvider;

    private Provider serviceProvider;

    private Provider streetLimitationParametersProvider;

    private Provider provideStreetLimitationParametersServiceProvider;

    private Provider emissionsDataModelProvider;

    private Provider provideEmissionsServiceProvider;

    private Provider schemaProvider;

    private Provider provideSchemaProvider;

    private Provider luceneIndexProvider;

    private ConstructApplicationFactoryImpl(
        ConstructApplicationModule constructApplicationModuleParam,
        EmissionsServiceModule emissionsServiceModuleParam, GeocoderModule geocoderModuleParam,
        InteractiveLauncherModule interactiveLauncherModuleParam,
        RideHailingServicesModule rideHailingServicesModuleParam, SchemaModule schemaModuleParam,
        SorlandsbanenNorwayModule sorlandsbanenNorwayModuleParam,
        StopConsolidationServiceModule stopConsolidationServiceModuleParam,
        StreetLimitationParametersServiceModule streetLimitationParametersServiceModuleParam,
        ConfigModel configModelParam, Graph graphParam,
        TimetableRepository timetableRepositoryParam, GraphVisualizer graphVisualizerParam,
        WorldEnvelopeRepository worldEnvelopeRepositoryParam,
        StopConsolidationRepository stopConsolidationRepositoryParam,
        VehicleParkingRepository vehicleParkingRepositoryParam,
        DataImportIssueSummary dataImportIssueSummaryParam,
        EmissionsDataModel emissionsDataModelParam, RouteRequest schemaParam,
        StreetLimitationParameters streetLimitationParametersParam) {
      this.configModel = configModelParam;
      this.graph = graphParam;
      this.timetableRepository = timetableRepositoryParam;
      this.worldEnvelopeRepository = worldEnvelopeRepositoryParam;
      this.vehicleParkingRepository = vehicleParkingRepositoryParam;
      this.dataImportIssueSummary = dataImportIssueSummaryParam;
      this.emissionsDataModel = emissionsDataModelParam;
      this.graphVisualizer = graphVisualizerParam;
      this.constructApplicationModule = constructApplicationModuleParam;
      this.sorlandsbanenNorwayModule = sorlandsbanenNorwayModuleParam;
      this.interactiveLauncherModule = interactiveLauncherModuleParam;
      this.stopConsolidationRepository = stopConsolidationRepositoryParam;
      this.streetLimitationParameters = streetLimitationParametersParam;
      initialize(constructApplicationModuleParam, emissionsServiceModuleParam, geocoderModuleParam, interactiveLauncherModuleParam, rideHailingServicesModuleParam, schemaModuleParam, sorlandsbanenNorwayModuleParam, stopConsolidationServiceModuleParam, streetLimitationParametersServiceModuleParam, configModelParam, graphParam, timetableRepositoryParam, graphVisualizerParam, worldEnvelopeRepositoryParam, stopConsolidationRepositoryParam, vehicleParkingRepositoryParam, dataImportIssueSummaryParam, emissionsDataModelParam, schemaParam, streetLimitationParametersParam);

    }

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

    private TimetableSnapshot timetableSnapshot() {
      return TransitModule_TimetableSnapshotFactory.timetableSnapshot(timetableSnapshotManagerProvider.get());
    }

    private DefaultTransitService defaultTransitService() {
      return new DefaultTransitService(timetableRepository, timetableSnapshot());
    }

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

    private DebugUiConfig debugUiConfig() {
      return ConfigModule_ProvideDebugUiConfigFactory.provideDebugUiConfig(configModel);
    }

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

    private BuildConfig buildConfig() {
      return ConfigModule_ProvideBuildConfigFactory.provideBuildConfig(configModel);
    }

    @SuppressWarnings("unchecked")
    private void initialize(final ConstructApplicationModule constructApplicationModuleParam,
        final EmissionsServiceModule emissionsServiceModuleParam,
        final GeocoderModule geocoderModuleParam,
        final InteractiveLauncherModule interactiveLauncherModuleParam,
        final RideHailingServicesModule rideHailingServicesModuleParam,
        final SchemaModule schemaModuleParam,
        final SorlandsbanenNorwayModule sorlandsbanenNorwayModuleParam,
        final StopConsolidationServiceModule stopConsolidationServiceModuleParam,
        final StreetLimitationParametersServiceModule streetLimitationParametersServiceModuleParam,
        final ConfigModel configModelParam, final Graph graphParam,
        final TimetableRepository timetableRepositoryParam,
        final GraphVisualizer graphVisualizerParam,
        final WorldEnvelopeRepository worldEnvelopeRepositoryParam,
        final StopConsolidationRepository stopConsolidationRepositoryParam,
        final VehicleParkingRepository vehicleParkingRepositoryParam,
        final DataImportIssueSummary dataImportIssueSummaryParam,
        final EmissionsDataModel emissionsDataModelParam, final RouteRequest schemaParam,
        final StreetLimitationParameters streetLimitationParametersParam) {
      this.configModelProvider = InstanceFactory.create(configModelParam);
      this.provideRouterConfigProvider = ConfigModule_ProvideRouterConfigFactory.create(configModelProvider);
      this.providesRaptorEnvironmentProvider = DoubleCheck.provider(ConfigModule_ProvidesRaptorEnvironmentFactory.create(provideRouterConfigProvider));
      this.providesRaptorConfigProvider = DoubleCheck.provider(ConfigModule_ProvidesRaptorConfigFactory.create(provideRouterConfigProvider, providesRaptorEnvironmentProvider));
      this.timetableRepositoryProvider = InstanceFactory.create(timetableRepositoryParam);
      this.realtimeRaptorTransitDataUpdaterProvider = DoubleCheck.provider(TransitModule_RealtimeRaptorTransitDataUpdaterFactory.create(timetableRepositoryProvider));
      this.timetableSnapshotManagerProvider = DoubleCheck.provider(TransitModule_TimetableSnapshotManagerFactory.create(realtimeRaptorTransitDataUpdaterProvider, configModelProvider, timetableRepositoryProvider));
      this.timetableSnapshotProvider = TransitModule_TimetableSnapshotFactory.create(timetableSnapshotManagerProvider);
      this.defaultTransitServiceProvider = DefaultTransitService_Factory.create(timetableRepositoryProvider, timetableSnapshotProvider);
      this.defaultRealtimeVehicleServiceProvider = DoubleCheck.provider(DefaultRealtimeVehicleService_Factory.create(((Provider) defaultTransitServiceProvider)));
      this.defaultVehicleRentalServiceProvider = DoubleCheck.provider(DefaultVehicleRentalService_Factory.create());
      this.vehicleParkingRepositoryProvider = InstanceFactory.create(vehicleParkingRepositoryParam);
      this.defaultVehicleParkingServiceProvider = DoubleCheck.provider(DefaultVehicleParkingService_Factory.create(vehicleParkingRepositoryProvider));
      this.servicesProvider = DoubleCheck.provider(RideHailingServicesModule_ServicesFactory.create(rideHailingServicesModuleParam, provideRouterConfigProvider));
      this.stopConsolidationRepositoryProvider = InstanceFactory.createNullable(stopConsolidationRepositoryParam);
      this.serviceProvider = DoubleCheck.provider(StopConsolidationServiceModule_ServiceFactory.create(stopConsolidationServiceModuleParam, stopConsolidationRepositoryProvider, timetableRepositoryProvider));
      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.schemaProvider = InstanceFactory.create(schemaParam);
      this.provideSchemaProvider = DoubleCheck.provider(SchemaModule_ProvideSchemaFactory.create(schemaModuleParam, schemaProvider));
      this.luceneIndexProvider = DoubleCheck.provider(GeocoderModule_LuceneIndexFactory.create(geocoderModuleParam, timetableRepositoryProvider, serviceProvider));
    }

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

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

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

    @Override
    public TimetableRepository timetableRepository() {
      return timetableRepository;
    }

    @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 VehicleParkingRepository vehicleParkingRepository() {
      return vehicleParkingRepository;
    }

    @Override
    public VehicleParkingService vehicleParkingService() {
      return defaultVehicleParkingServiceProvider.get();
    }

    @Override
    public TimetableSnapshotManager timetableSnapshotManager() {
      return timetableSnapshotManagerProvider.get();
    }

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

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

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

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

    @Override
    public OtpServerRequestContext createServerContext() {
      return ConstructApplicationModule_ProvidesServerContextFactory.providesServerContext(constructApplicationModule, routerConfig(), debugUiConfig(), providesRaptorConfigProvider.get(), graph, defaultTransitService(), defaultWorldEnvelopeService(), defaultRealtimeVehicleServiceProvider.get(), defaultVehicleRentalServiceProvider.get(), defaultVehicleParkingServiceProvider.get(), servicesProvider.get(), viaTransferResolver(), serviceProvider.get(), provideStreetLimitationParametersServiceProvider.get(), traverseVisitorOfAnd(), provideEmissionsServiceProvider.get(), provideSchemaProvider.get(), SorlandsbanenNorwayModule_ProvidesSorlandsbanenNorwayServiceFactory.providesSorlandsbanenNorwayService(sorlandsbanenNorwayModule), InteractiveLauncherModule_RequestDecoratorFactory.requestDecorator(interactiveLauncherModule), luceneIndexProvider.get());
    }

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

    @Override
    public ViaCoordinateTransferFactory viaTransferResolver() {
      return ViaModule_ProvidesViaTransferResolverFactory.providesViaTransferResolver(buildConfig(), defaultTransitService(), graph);
    }

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

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

    @Override
    @Nullable
    public SorlandsbanenNorwayService enturSorlandsbanenService() {
      return SorlandsbanenNorwayModule_ProvidesSorlandsbanenNorwayServiceFactory.providesSorlandsbanenNorwayService(sorlandsbanenNorwayModule);
    }

    @Override
    @Nullable
    public GraphQLSchema schema() {
      return provideSchemaProvider.get();
    }

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