afactory.h

Go to the documentation of this file.

/********************************************************************************
 * Copyright (C) 2017-2023 German Aerospace Center (DLR). 
 * Eclipse ADORe, Automated Driving Open Research https://eclipse.org/adore
 *
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0 
 *
 * Contributors: 
 *   Daniel Heß - initial API and implementation
 ********************************************************************************/
 
#pragma once
 
#include <adore/mad/com_patterns.h>
#include <adore/view/navigationgoal.h>
#include <adore/fun/setpointrequest.h>
#include <adore/fun/terminalrequest.h>
#include <adore/fun/motioncommand.h>
#include <adore/fun/gearselectioncommand.h>
#include <adore/fun/indicatorcommand.h>
#include <adore/fun/vehiclemotionstate9d.h>
#include <adore/fun/vehicleextendedstate.h>
#include <adore/sim/resetvehiclepose.h>
#include <adore/sim/resetvehicletwist.h>
#include <adore/sim/resetvehicledimensions.h>
#include <adore/env/traffic/participant.h>
 
#include <adore/env/tcd/trafficlight.h>
 
namespace adore 
{
    namespace sim
    {
        class AFactory
        {
        public:
            typedef adore::mad::AReader<adore::fun::MotionCommand> TMotionCommandReader;
            typedef adore::mad::AReader<adore::fun::GearSelectionCommand> TGearSelectionCommandReader;
            typedef adore::mad::AReader<adore::fun::IndicatorCommand> TIndicatorCommandReader;
            typedef adore::mad::AReader<double> TSimulationTimeReader;
            typedef adore::mad::AWriter<double> TSimulationTimeWriter;
            typedef adore::mad::AWriter<adore::fun::VehicleMotionState9d> TVehicleMotionStateWriter;
            typedef adore::mad::AReader<adore::fun::VehicleMotionState9d> TVehicleMotionStateReader;
            typedef adore::mad::AWriter<adore::fun::VehicleExtendedState> TVehicleExtendedStateWriter;
            typedef adore::mad::AFeed<adore::sim::ResetVehiclePose> TVehiclePoseResetFeed;
            typedef adore::mad::AFeed<adore::sim::ResetVehicleTwist> TVehicleTwistResetFeed;
            typedef adore::mad::AWriter<adore::sim::ResetVehiclePose> TVehiclePoseResetWriter;
            typedef adore::mad::AWriter<adore::sim::ResetVehicleTwist> TVehicleTwistResetWriter;
            typedef adore::mad::AFeed<int64_t> TSimulationIDResetFeed;
            typedef adore::mad::AFeed<int64_t> TV2XStationIDResetFeed;
            typedef adore::mad::AWriter<adore::sim::ResetVehicleDimensions> TVehicleDimensionsResetWriter;
            typedef adore::mad::AFeed<adore::sim::ResetVehicleDimensions> TVehicleDimensionsResetFeed;
            typedef adore::mad::AWriter<adore::env::traffic::TParticipantSet> TParticipantSetWriter;
            typedef adore::mad::AWriter<adore::env::traffic::Participant> TParticipantWriter;
            typedef adore::mad::AFeed<adore::env::traffic::Participant> TParticipantFeed;
            typedef adore::mad::AWriter<std::pair<uint32_t,uint32_t>> TClockTimeWriter;
            typedef adore::mad::AWriter<adore::env::SimTrafficLight> TSimTrafficLightWriter;
            typedef adore::mad::AReader<adore::env::SimTrafficLightMap> TSimTrafficLightReader;
            typedef adore::mad::AFeedWithCallback<std::string> TSimulationCoordinationFeed;
            typedef adore::mad::AWriter<std::string> TSimulationCoordinationWriter;
 
 
            virtual TMotionCommandReader* getMotionCommandReader()=0;
            virtual TGearSelectionCommandReader* getGearSelectionCommandReader()=0;
            virtual TIndicatorCommandReader* getIndicatorCommandReader()=0;
            virtual TSimulationTimeReader* getSimulationTimeReader()=0;
            virtual TSimulationTimeWriter* getSimulationTimeWriter()=0;
            virtual TVehicleMotionStateWriter* getVehicleMotionStateWriter()=0;
            virtual TVehicleMotionStateWriter* getOdometryEstimatedVehicleStateWriter()=0;
            virtual TVehicleMotionStateWriter* getLocalizationEstimatedVehicleStateWriter()=0;
            virtual TVehicleMotionStateReader* getVehicleMotionStateReader()=0;
            virtual TVehicleExtendedStateWriter* getVehicleExtendedStateWriter()=0;
            virtual TVehiclePoseResetFeed* getVehiclePoseResetFeed()=0;
            virtual TVehicleTwistResetFeed* getVehicleTwistResetFeed()=0;
            //send simulation commands for vehicle position and orientation resetting
            virtual TVehiclePoseResetWriter* getVehiclePoseResetWriter()=0;
            virtual TVehicleTwistResetWriter* getVehicleTwistResetWriter()=0;
            virtual TSimulationIDResetFeed* getSimulationIDResetFeed() = 0;
            virtual TV2XStationIDResetFeed* getV2XStationIDResetFeed() = 0;
            virtual TVehicleDimensionsResetWriter* getVehicleDimensionsResetWriter(std::string ns) = 0;
            virtual TVehicleDimensionsResetFeed* getVehicleDimensionsResetFeed() = 0;
            virtual TParticipantSetWriter* getParticipantSetWriter()=0;
            virtual TParticipantWriter* getParticipantWriter()=0;
            virtual TParticipantFeed* getParticipantFeed()=0;
            virtual TClockTimeWriter* getClockTimeWriter()=0;
            virtual TSimTrafficLightWriter* getTrafficLightWriter()=0;
            virtual TSimTrafficLightReader* getTrafficLightReader()=0;
            virtual adore::mad::AWriter<int64_t>* getTransformIDtoAdoreWriter()=0;
        };
 
        class SimFactoryInstance final
        {
          private:
            adore::sim::AFactory* factory_ = 0;
 
            static SimFactoryInstance& getInstance()
            {
                static SimFactoryInstance instance;
                return instance;
            }
 
          public:
            static adore::sim::AFactory* get()
            {
              if (getInstance().factory_ == nullptr)
              {
                std::cerr << " WARNING Accessing singleton simFactory instance without ever running init()" 
                      << std::endl;
              }
              return getInstance().factory_;
            }
 
            static void init(adore::sim::AFactory* factory)
            {
                auto& instance = getInstance();
                instance.factory_ = factory;    
            }
 
          private:
            SimFactoryInstance() = default;
            ~SimFactoryInstance() = default;
 
            SimFactoryInstance(const SimFactoryInstance&) = delete;
            SimFactoryInstance& operator=(const SimFactoryInstance&) = delete;
            SimFactoryInstance(SimFactoryInstance&&) = delete;
            SimFactoryInstance& operator=(SimFactoryInstance&&) = delete;
        };
    }
}