DtRunwayMarkingManager.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2023 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/


#pragma once
#include <vrvCore/vrvCore.h>
#include <vrvCore/DtDe.h>
#include <vrvCore/DtModelDefinitionManager.h>
#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtRunwayData.h>
#include <vrvCore/DtRunwayStatus.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtVirtualBaseClass.h>



#include <matrix/vlVector.h>

#include <unordered_map>

#include <string>

namespace makVrv
{
   class DtRunwaySelector;
   enum class DtRunwayLightsEnum : unsigned int;
   enum class DtAerodromeLightsEnum : unsigned int;

   class DT_DLL_VRVCORE DtRunwayMarkingManager : public DtVirtualBaseClass
   {
   public:
      DtRunwayMarkingManager(DtDe& de);

      DtRunwayMarkingManager() = delete;

      DtRunwayMarkingManager(const DtRunwayMarkingManager& orig) = delete;

      DtRunwayMarkingManager& operator=(const DtRunwayMarkingManager& orig) = delete;

      virtual ~DtRunwayMarkingManager();

      virtual DtRunwaySelector* findRunwaySelector(DtElementID id);

      virtual DtRunwayData runwayData(const std::string& key) const = 0;

      virtual void updateRunwayManager(const float budget) = 0;

      //{@ \name Light Group Name Generation
      virtual std::string createLightGroupName(const std::string& airportName, const std::string& runwayName, DtRunwayLightsEnum lightType) const;
      virtual std::string createLightGroupName(const std::string& airportName, DtAerodromeLightsEnum lightType) const;
      virtual std::string createLightGroupName(const std::string& airportName, const std::string& runwayName, const std::string& lightName) const;
      virtual std::string createLightGroupName(const std::string& airportName, const std::string& runway1Name, const std::string& runway2Name, const std::string& lightName) const;

    public:
      static DtRunwayMarkingManager& instance(DtDe& de);

      static void registerInstance(DtDe& de, DtRunwayMarkingManager* anInstance);

      static std::string generateLightGroupName(const std::string& airportName, const std::string& runwayName, const std::string& lightSubGroup);

   protected:
      virtual void cleanup();

      virtual std::string runwayKey(const std::string& apt_icao, const std::string& runwayNum) const;

      virtual std::size_t hashRunwayData(const DtRunwayData& runwayData) const;

      virtual void createAndPlaceRunwaySelector(const DtRunwayData& runwayData);

      virtual void slot_runwayConditionChanged(DtUniqueID runwayId, const std::string& airportCode, const std::string& runwayName, DtRunwayCondition condition);

      virtual void slot_runwayDamageStateChanged(DtUniqueID runwayId, const std::string& airportCode, const std::string& runwayName, bool damaged);

      virtual void slot_runwayArrestorStateChanged(DtUniqueID runwayId, unsigned int runwayIndex, const std::string& airportCode, const std::string& runwayName, bool arrestorsUp);

      virtual void slot_runwayActiveStateChanged(DtUniqueID runwayId, unsigned int runwayIndex, const std::string& airportCode, const std::string& runwayName, bool isActive);

   protected:
      DtDe& myDe;

      // *** Two ways to find a selector:
      //
      // Map of element ID to runway selectors.  Note that this DtElementID is unrelated to the
      // DtUniqueID used by the aerodrome status mgr.
      std::unordered_map<DtElementID, DtRunwaySelector*> myRunwaySelectors;

      // Given a logical runway key, find the selector's DtElementID (which we can then look up in myRunwaySelectors
      std::unordered_map<std::string, DtElementID> myLogicalKeyToSelectorIdMap;


      // The std::string key is a logicalRunwayKey. This lets us find the aerodrome status mgr
      // key to myRunwayStatusMap for the status of the physical runway this logical runway is part of
      std::unordered_map<std::string, DtUniqueID> myLogicalPhysicalRunwayMap;

      // The key is the aerodrome status manager id created fpr the physical runway.  So
      // this maps from the id to the physical status (which will come from the aerodrome status mgr
      std::unordered_map<DtUniqueID, DtRunwayStatus> myRunwayStatusMap;

      // Map of runway hashes to selectors.  This is used to ensure a single selector for
      // a physical runway
      std::unordered_map<std::size_t, DtRunwaySelector*> myRunwaySelectorsCreated;

      DtSignalConnectionManager myConnections;
   };
}