aerodromeStateData.h

Go to the documentation of this file.

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

#pragma once

#include "vrfutil/vrfutilDefines.h"
#include <vlpi/entityIdentifier.h>
#include <vrfExtProtocol/objectType.h>
#include <vrfutil/rwUUID.h>

#include <vlutil/vlString.h>

class DtRunwayStateComponent;

struct DT_DLL_vrfutil DtRunwayLightStateData
{
   DtRunwayLightStateData()
   : myActive(false)
   , myCenterLineLight(100)
   , myDistanceToGoLight(100)
   , myEdgeLight(100)
   , myDisplacedThresholdLight(100)
   , myRapidExitTaxiwayLight(100)
   , myRunwayExitLight(100)
   , myEndLight(100)
   , myTouchDownZoneLight(100)
   , myThresholdLightingLight(100)
   , myEndIndicatorLight(100)
   , myApproachLight(100)
   , myVGSILight(100)
   , myArrestorGear(false)
   , myTaxiwayLeadOnLight(100)
   , myTaxiwayStopBarLight(100)
   , myPrethresholdEdgeLight(100)
   {};

   DtRunwayLightStateData(const DtRunwayLightStateData& orig)
   {
      myRunwayName = orig.myRunwayName;
      myActive = orig.myActive;
      myCenterLineLight = orig.myCenterLineLight;
      myDistanceToGoLight = orig.myDistanceToGoLight;
      myEdgeLight = orig.myEdgeLight;
      myDisplacedThresholdLight = orig.myDisplacedThresholdLight;
      myRapidExitTaxiwayLight = orig.myRapidExitTaxiwayLight;
      myRunwayExitLight = orig.myRunwayExitLight;
      myTaxiwayLeadOnLight = orig.myTaxiwayLeadOnLight;
      myTaxiwayStopBarLight = orig.myTaxiwayStopBarLight;
      myPrethresholdEdgeLight = orig.myPrethresholdEdgeLight;
      myEndLight = orig.myEndLight;
      myTouchDownZoneLight = orig.myTouchDownZoneLight;
      myThresholdLightingLight = orig.myThresholdLightingLight;
      myEndIndicatorLight = orig.myEndIndicatorLight;
      myApproachLight = orig.myApproachLight;
      myVGSILight = orig.myVGSILight;
      myArrestorGear = orig.myArrestorGear;
   }

   DtRunwayLightStateData& operator=(const DtRunwayLightStateData& orig)
   {
      myRunwayName = orig.myRunwayName;
      myActive = orig.myActive;
      myCenterLineLight = orig.myCenterLineLight;
      myDistanceToGoLight = orig.myDistanceToGoLight;
      myEdgeLight = orig.myEdgeLight;
      myDisplacedThresholdLight = orig.myDisplacedThresholdLight;
      myRapidExitTaxiwayLight = orig.myRapidExitTaxiwayLight;
      myRunwayExitLight = orig.myRunwayExitLight;
      myTaxiwayLeadOnLight = orig.myTaxiwayLeadOnLight;
      myTaxiwayStopBarLight = orig.myTaxiwayStopBarLight;
      myPrethresholdEdgeLight = orig.myPrethresholdEdgeLight;
      myEndLight = orig.myEndLight;
      myTouchDownZoneLight = orig.myTouchDownZoneLight;
      myThresholdLightingLight = orig.myThresholdLightingLight;
      myEndIndicatorLight = orig.myEndIndicatorLight;
      myApproachLight = orig.myApproachLight;
      myVGSILight = orig.myVGSILight;
      myArrestorGear = orig.myArrestorGear;

      return *this;
   }

   const DtString& runwayName() const { return myRunwayName; }
   void setRunwayName(const DtString& n) { myRunwayName = n; }

   const bool& active() const { return myActive; };
   void setActive(bool b) { myActive = b; }

   unsigned char centerLineLight() const { return myCenterLineLight; }
   void setCenterLineLight(unsigned char c) { myCenterLineLight = c; }

   unsigned char approachLight() const { return myApproachLight; }
   void setApproachLight(unsigned char c) { myApproachLight = c; }

   unsigned char endIndicatorLight() const { return myEndIndicatorLight; }
   void setEndIndicatorLight(unsigned char c) { myEndIndicatorLight = c; }

   unsigned char thresholdLightingLight() const { return myThresholdLightingLight; }
   void setThresholdLightingLight(unsigned char c) { myThresholdLightingLight = c; }

   unsigned char touchDownZoneLight() const { return myTouchDownZoneLight; }
   void setTouchDownZoneLight(unsigned char c) { myTouchDownZoneLight = c; }

   unsigned char VGSILight() const { return myVGSILight; }
   void setVGSILight(unsigned char c) { myVGSILight = c; }

   unsigned char endLight() const { return myEndLight; }
   void setEndLight(unsigned char c) { myEndLight = c; }

   unsigned char rapidExitTaxiwayLight() const { return myRapidExitTaxiwayLight; }
   void setRapidExitTaxiwayLight(unsigned char c) { myRapidExitTaxiwayLight = c; }

   unsigned char runwayExitLight() const { return myRunwayExitLight; }
   void setRunwayExitLight(unsigned char c) { myRunwayExitLight = c; }

   unsigned char taxiwayLeadOnLight() const { return myTaxiwayLeadOnLight; }
   void setTaxiwayLeadOnLight(unsigned char c) { myTaxiwayLeadOnLight = c; }

   unsigned char taxiwayStopBarLight() const { return myTaxiwayStopBarLight; }
   void setTaxiwayStopBarLight(unsigned char c) { myTaxiwayStopBarLight = c; }

   unsigned char prethresholdEdgeLight() const { return myPrethresholdEdgeLight; }
   void setPrethresholdEdgeLight(unsigned char c) { myPrethresholdEdgeLight = c; }

   unsigned char displacedThresholdLight() const { return myDisplacedThresholdLight; }
   void setDisplacedThresholdLight(unsigned char c) { myDisplacedThresholdLight = c; }

   unsigned char edgeLight() const { return myEdgeLight; }
   void setEdgeLight(unsigned char c) { myEdgeLight = c; }

   unsigned char distanceToGoLight() const { return myDistanceToGoLight; }
   void setDistanceToGoLight(unsigned char c) { myDistanceToGoLight = c; }

   bool arrestorGear() const { return myArrestorGear; }
   void setArrestorGear(bool c) { myArrestorGear = c; }

   DtString archive() const;
   int restoreFromArchive(int& startIndex, const std::vector<DtString>&);

   bool operator==(const DtRunwayLightStateData& rhs) const
   {
      return ((myRunwayName == rhs.myRunwayName) &&
               (myActive == rhs.myActive) &&
               (myCenterLineLight == rhs.myCenterLineLight) &&
               (myDistanceToGoLight == rhs.myDistanceToGoLight) &&
               (myEdgeLight == rhs.myEdgeLight) &&
               (myDisplacedThresholdLight == rhs.myDisplacedThresholdLight) &&
               (myEndLight == rhs.myEndLight) &&
               (myTouchDownZoneLight == rhs.myTouchDownZoneLight) &&
               (myThresholdLightingLight == rhs.myThresholdLightingLight) &&
               (myEndIndicatorLight == rhs.myEndIndicatorLight) &&
               (myApproachLight == rhs.myApproachLight) &&
               (myVGSILight == rhs.myVGSILight) &&
               (myArrestorGear == rhs.myArrestorGear) &&
               (myRunwayExitLight == rhs.myRunwayExitLight) &&
               (myTaxiwayLeadOnLight == rhs.myTaxiwayLeadOnLight) &&
               (myPrethresholdEdgeLight == rhs.myPrethresholdEdgeLight) &&
               (myTaxiwayStopBarLight == rhs.myTaxiwayStopBarLight) &&
               (myRapidExitTaxiwayLight == rhs.myRapidExitTaxiwayLight));
   }

   bool operator!=(const DtRunwayLightStateData& rhs) const
   {
      return !(*this == rhs);
   }

   unsigned char value(const DtString& value) const
   {
      if (value == "Edge")
      {
         return edgeLight();
      }
      else if (value == "ArrestorGear")
      {
         return arrestorGear();
      }
      else if (value == "Active")
      {
         return active();
      }
      else if (value == "Approach")
      {
         return approachLight();
      }
      else if (value == "CenterLine")
      {
         return centerLineLight();
      }
      else if (value == "DistanceToGo")
      {
         return distanceToGoLight();
      }
      else if (value == "TDZ")
      {
         return touchDownZoneLight();
      }
      else if (value == "DisplacedThreshold")
      {
         return displacedThresholdLight();
      }
      else if (value == "ThresholdLighting")
      {
         return thresholdLightingLight();
      }
      else if (value == "RapidExitTaxiwayLight")
      {
         return rapidExitTaxiwayLight();
      }
      else if (value == "RunwayExitLight")
      {
         return runwayExitLight();
      }
      else if (value == "TaxiwayLeadOnLight")
      {
         return taxiwayLeadOnLight();
      }
      else if (value == "TaxiwayStopBarLight")
      {
         return taxiwayStopBarLight();
      }
      else if (value == "PrethresholdEdgeLight")
      {
         return prethresholdEdgeLight();
      }
      else if (value == "REILS")
      {
         return endIndicatorLight();
      }
      else if (value == "RunwayEndLight")
      {
         return endLight();
      }
      else if (value == "VSGI")
      {
         return VGSILight();
      }
      else if (value == "All")
      {
         return -1;
      }

      return 0;
   }

   void setValue(const DtString& value, unsigned char v)
   {
      if ((value == "All") || (value == "Edge"))
      {
         setEdgeLight(v);
      }
      
      if ((value == "All") || (value == "Approach"))
      {
         setApproachLight(v);
      }
      
      if ((value == "All") || (value == "CenterLine"))
      {
         setCenterLineLight(v);
      }
      
      if ((value == "All") || (value == "DistanceToGo"))
      {
         setDistanceToGoLight(v);
      }
      
      if ((value == "All") || (value == "TDZ"))
      {
         setTouchDownZoneLight(v);
      }

      if ((value == "All") || (value == "DisplacedThreshold"))
      {
         setDisplacedThresholdLight(v);
      }
      
      if ((value == "All") || (value == "ThresholdLighting"))
      {
         setThresholdLightingLight(v);
      }
      
      if ((value == "All") || (value == "RapidExitTaxiwayLight"))
      {
         setRapidExitTaxiwayLight(v);
      }
      
      if ((value == "All") || (value == "RunwayExitLight"))
      {
         setRunwayExitLight(v);
      }
      
      if ((value == "All") || (value == "TaxiwayLeadOnLight"))
      {
         setTaxiwayLeadOnLight(v);
      }
      
      if ((value == "All") || (value == "TaxiwayStopBarLight"))
      {
         setTaxiwayStopBarLight(v);
      }
      
      if ((value == "All") || (value == "PrethresholdEdgeLight"))
      {
         setPrethresholdEdgeLight(v);
      }
      
      if ((value == "All") || (value == "REILS"))
      {
         setEndIndicatorLight(v);
      }
      
      if ((value == "All") || (value == "RunwayEndLight"))
      {
         setEndLight(v);
      }
      
      if ((value == "All") || (value == "VSGI"))
      {
         setVGSILight(v);
      }

      if (value == "ArrestorGear")
      {
         setArrestorGear(v == 1);
      }
      else if (value == "Active")
      {
         setActive(v == 1);
      }
   }

protected:
   DtString myRunwayName;
   bool myActive;
   bool myArrestorGear;
   unsigned char myCenterLineLight;
   unsigned char myDistanceToGoLight;
   unsigned char myEdgeLight;
   unsigned char myDisplacedThresholdLight;
   unsigned char myEndLight;
   unsigned char myTouchDownZoneLight;
   unsigned char myThresholdLightingLight;
   unsigned char myEndIndicatorLight;
   unsigned char myApproachLight;
   unsigned char myVGSILight;
   unsigned char myRapidExitTaxiwayLight;
   unsigned char myRunwayExitLight;
   unsigned char myTaxiwayLeadOnLight;
   unsigned char myTaxiwayStopBarLight;
   unsigned char myPrethresholdEdgeLight;
};

struct DT_DLL_vrfutil DtRunwayStateData
{
public:
   DtRunwayStateData()
   : myDamaged(false)
   , myCondition(1)
   , myGuardLight(100)
   {
      myRunwayLightState.resize(2);
   };

   DtRunwayStateData(const DtRunwayStateData& orig)
   {
      myUUID = orig.myUUID;
      myDamaged = orig.myDamaged;
      myCondition = orig.myCondition;
      myGuardLight = orig.myGuardLight;
      myRunwayLightState = orig.myRunwayLightState;
      myRunwayPoints = orig.myRunwayPoints;
   }

   DtRunwayStateData& operator=(const DtRunwayStateData& orig)
   {
      myUUID = orig.myUUID;
      myDamaged = orig.myDamaged;
      myCondition = orig.myCondition;
      myGuardLight = orig.myGuardLight;
      myRunwayLightState = orig.myRunwayLightState;
      myRunwayPoints = orig.myRunwayPoints;

      return *this;
   }

   bool operator==(const DtRunwayStateData& rhs) const
   {
      return ((myUUID == rhs.myUUID) &&
               (myDamaged == rhs.myDamaged) &&
               (myCondition == rhs.myCondition) &&
               (myGuardLight == rhs.myGuardLight) &&
               (myRunwayPoints == rhs.myRunwayPoints) &&
               (myRunwayLightState == rhs.myRunwayLightState));
   }

   bool operator!=(const DtRunwayStateData& rhs) const
   {
      return !(*this == rhs);
   }

   bool isLightState(const DtString& value) const
   {
      if ((value == "RunwayGuard") ||
          (value == "Condition") ||
          (value == "Active") ||
          (value == "Damaged"))
      {
         return false;
      }

      return true;
   }

   unsigned char value(const DtString& value) const
   {
      if (value == "RunwayGuard")
      {
         return guardLight();
      }
      else if (value == "Condition")
      {
         return condition();
      }
      else if (value == "Active")
      {
         return active();
      }
      else if (value == "Damaged")
      {
         return damaged();
      }
      else if (value == "All")
      {
         return -1;
      }

      return 0;
   }

   void setValue(const DtString& value, unsigned char v)
   {
      if ((value == "All") || (value == "RunwayGuard"))
      {
         return setGuardLight(v);
      }
      
      if (value == "Condition")
      {
         return setCondition(v);
      }
      else if (value == "Active")
      {
         return setActive(v == 1);
      }
      else if (value == "Damaged")
      {
         return setDamaged(v == 1);
      }
   }

   bool active() const { return (myRunwayLightState[0].active() || myRunwayLightState[1].active()); };
   void setActive(bool b) { myRunwayLightState[0].setActive(b); myRunwayLightState[1].setActive(b); };

   const DtUUID& uuid() const { return myUUID; }
   void setUUID(const DtUUID& u) { myUUID = u; }

   bool damaged() const { return myDamaged; }
   void setDamaged(bool b) { myDamaged = b; };

   unsigned char condition() const { return myCondition; }
   void setCondition(unsigned char  c) { myCondition = c; }

   unsigned char guardLight() const { return myGuardLight; }
   void setGuardLight(unsigned char  c) { myGuardLight= c; }

   std::vector<DtRunwayLightStateData>& runwayLightState() { return myRunwayLightState; };
   const std::vector<DtRunwayLightStateData>& runwayLightState() const { return myRunwayLightState; };

   DtString archive() const;
   void restoreRunwayFromArchive(const DtString&);

   const std::vector<DtVector>& runwayPoints() const { return myRunwayPoints; };
   void setRunwayPoints(const std::vector<DtVector>& runwayPoints) { myRunwayPoints = runwayPoints; };

   DtString name() const { return myRunwayLightState[0].runwayName() + "/" + myRunwayLightState[1].runwayName(); };

protected:
   DtUUID myUUID;
   bool myDamaged;
   unsigned char myCondition;
   unsigned char myGuardLight;
   std::vector<DtRunwayLightStateData> myRunwayLightState;
   std::vector<DtVector> myRunwayPoints;
};

struct DT_DLL_vrfutil DtAerodromeStateData 
{
   DtAerodromeStateData()
   : myUUID(DtUUID::nullUUID())
   , myIsLocal(false)
   , myCheckForNameReservation(true)
   , myForceType(0)
   , myAppearance(0)
   , myActive(true)
   , myApronLight(100)
   , myApronFloodLight(100)
   , myClearanceBarLight(100)
   , myTaxiwayCentreLight(100)
   , myTaxiwayEdgeLight(100)
   , myTaxiwayIdentifierMarkerBoardLight(100)
   , myUndercarriageInspectionSystem(0)
   {};

   DtAerodromeStateData(const DtAerodromeStateData& orig)
   {
      myUUID = orig.myUUID;
      myIsLocal = orig.myIsLocal;
      myCheckForNameReservation = orig.myCheckForNameReservation;
      myForceType = orig.myForceType;
      myAirportCode = orig.myAirportCode;
      myRunways = orig.myRunways;
      myGlobalId = orig.myGlobalId;
      myObjectType = orig.myObjectType;
      myEntityIdentifier = orig.myEntityIdentifier;
      myAppearance = orig.myAppearance;
      myActive = orig.myActive;
      myApronLight = orig.myApronLight;
      myApronFloodLight = orig.myApronFloodLight;
      myClearanceBarLight = orig.myClearanceBarLight;
      myTaxiwayCentreLight = orig.myTaxiwayCentreLight;
      myTaxiwayEdgeLight = orig.myTaxiwayEdgeLight;
      myTaxiwayIdentifierMarkerBoardLight = orig.myTaxiwayIdentifierMarkerBoardLight;
      myUndercarriageInspectionSystem = orig.myUndercarriageInspectionSystem;
   }

   DtAerodromeStateData& operator=(const DtAerodromeStateData& orig)
   {
      myUUID = orig.myUUID;
      myIsLocal = orig.myIsLocal;
      myCheckForNameReservation = orig.myCheckForNameReservation;
      myForceType = orig.myForceType;
      myAirportCode = orig.myAirportCode;
      myRunways = orig.myRunways;
      myGlobalId = orig.myGlobalId;
      myObjectType = orig.myObjectType;
      myEntityIdentifier = orig.myEntityIdentifier;
      myAppearance = orig.myAppearance;
      myActive = orig.myActive;
      myApronLight = orig.myApronLight;
      myApronFloodLight = orig.myApronFloodLight;
      myClearanceBarLight = orig.myClearanceBarLight;
      myTaxiwayCentreLight = orig.myTaxiwayCentreLight;
      myTaxiwayEdgeLight = orig.myTaxiwayEdgeLight;
      myTaxiwayIdentifierMarkerBoardLight = orig.myTaxiwayIdentifierMarkerBoardLight;
      myUndercarriageInspectionSystem = orig.myUndercarriageInspectionSystem;

      return *this;
   }

   bool operator==(const DtAerodromeStateData& rhs) const
   {
      return ((myUUID == rhs.myUUID) &&
               (myIsLocal == rhs.myIsLocal) &&
               (myForceType == rhs.myForceType) &&
               (myAirportCode == rhs.myAirportCode) &&
               (myRunways == rhs.myRunways) &&
               (myGlobalId == rhs.myGlobalId) &&
               (myObjectType == rhs.myObjectType) &&
               (myEntityIdentifier == rhs.myEntityIdentifier) &&
               (myAppearance == rhs.myAppearance) &&
               (myApronLight == rhs.myApronLight) &&
               (myApronFloodLight == rhs.myApronFloodLight) &&
               (myClearanceBarLight == rhs.myClearanceBarLight) &&
               (myTaxiwayCentreLight == rhs.myTaxiwayCentreLight) &&
               (myTaxiwayEdgeLight == rhs.myTaxiwayEdgeLight) &&
               (myTaxiwayIdentifierMarkerBoardLight == rhs.myTaxiwayIdentifierMarkerBoardLight) &&
               (myUndercarriageInspectionSystem == rhs.myUndercarriageInspectionSystem) &&
               (myActive == rhs.myActive));
   };

   bool operator!=(const DtAerodromeStateData& rhs) const
   {
      return !(*this == rhs);
   }

   DtRunwayStateData& addRunway()
   {
      DtRunwayStateData sd;

      myRunways[sd.uuid()] = sd;

      return myRunways[sd.uuid()];
   }

   bool removeRunway(const DtUUID& u)
   {
      std::map<DtUUID, DtRunwayStateData>::iterator iter = myRunways.find(u);

      if (iter != myRunways.end())
      {
         myRunways.erase(iter);
         return true;
      }

      return false;
   }

   DtRunwayStateData& runway(const DtUUID& u)
   {
      std::map<DtUUID, DtRunwayStateData>::iterator iter = myRunways.find(u);

      if (iter != myRunways.end())
      {
         return iter->second;
      }

      static DtRunwayStateData theDefaultRunwayStateData;
      return theDefaultRunwayStateData;
   }

   DtRunwayStateData& runway(const std::string& u)
   {
      for (auto& runway : myRunways)
      {
         if ((runway.second.name() == u) || (runway.second.runwayLightState()[0].runwayName() == u) || (runway.second.runwayLightState()[1].runwayName() == u))
         {
            return runway.second;
         }
      }

      static DtRunwayStateData theDefaultRunwayStateData;
      return theDefaultRunwayStateData;
   }

   const DtRunwayStateData& runway(const DtUUID& u) const
   {
      std::map<DtUUID, DtRunwayStateData>::const_iterator iter = myRunways.find(u);

      if (iter != myRunways.end())
      {
         return iter->second;
      }

      static DtRunwayStateData theDefaultRunwayStateData;
      return theDefaultRunwayStateData;
   }

   const DtRunwayStateData& runway(const std::string& u) const
   {
      for (auto& runway : myRunways)
      {
         if ((runway.second.name() == u) || (runway.second.runwayLightState()[0].runwayName() == u) || (runway.second.runwayLightState()[1].runwayName() == u))
         {
            return runway.second;
         }
      }

      static DtRunwayStateData theDefaultRunwayStateData;
      return theDefaultRunwayStateData;
   }

   const std::map<DtUUID, DtRunwayStateData>& runways() const
   {
      return myRunways;
   }

   std::map<DtUUID, DtRunwayStateData>& runways()
   {
      return myRunways;
   }

   const DtString& airportCode() const { return myAirportCode; }
   void setAirportCode(const DtString& c) { myAirportCode = c; }

   const DtString& globalId() const { return myGlobalId; }
   void setGlobalId(const DtString& c) { myGlobalId = c; }

   int forceType() const { return myForceType; }
   void setForceType(int c) { myForceType = c; }

   const DtUUID& uuid() const { return myUUID; }
   void setUUID(const DtUUID& u) { myUUID = u; }
   
   const DtObjectType& objectType() const { return myObjectType; }
   void setObjectType(const DtObjectType& o) { myObjectType = o; }

   const DtEntityIdentifier& entityIdentifier() const { return myEntityIdentifier; }
   void setEntityIdentifier(const DtEntityIdentifier& c) { myEntityIdentifier= c; }

   unsigned int appearance() const { return myAppearance; }
   void setAppearance(unsigned int c) { myAppearance = c; }

   const bool& isLocal() const { return myIsLocal; }
   void setIsLocal(bool b) { myIsLocal = b; };

   const bool& checkForNameReservation() const { return myCheckForNameReservation; }
   void setCheckForNameReservation(bool b) { myCheckForNameReservation = b; };

   const bool& active() const { return myActive; }
   void setActive(bool b) { myActive = b; };

   unsigned char apronLight() const { return myApronLight; }
   void setApronLight(unsigned char c) { myApronLight = c; }

   unsigned char apronFloodLight() const { return myApronFloodLight; }
   void setApronFloodLight(unsigned char c) { myApronFloodLight = c; }

   unsigned char clearanceBarLight() const { return myClearanceBarLight; }
   void setClearanceBarLight(unsigned char c) { myClearanceBarLight = c; }

   unsigned char taxiwayCentreLight() const { return myTaxiwayCentreLight; }
   void setTaxiwayCentreLight(unsigned char c) { myTaxiwayCentreLight = c; }

   unsigned char taxiwayEdgeLight() const { return myTaxiwayEdgeLight; }
   void setTaxiwayEdgeLight(unsigned char c) { myTaxiwayEdgeLight = c; }

   unsigned char taxiwayIdentifierMarkerBoardLight() const { return myTaxiwayIdentifierMarkerBoardLight; }
   void setTaxiwayIdentifierMarkerBoardLight(unsigned char c) { myTaxiwayIdentifierMarkerBoardLight = c; }

   void setUndercarriageInspectionSystem( bool onOff ) { myUndercarriageInspectionSystem = (onOff ? 1 : 0); };
   bool undercarriageInspectionSystem() const { return (myUndercarriageInspectionSystem == 1); };

   void setValue(const DtString& s, unsigned char v)
   {
      if ((s == "All") || (s == "ApronLight"))
      {
         setApronLight(v);
      }

      if ((s == "All") || (s == "ApronFloodLight"))
      {
         setApronFloodLight(v);
      }

      if ((s == "All") || (s == "ClearanceBarLight"))
      {
         setClearanceBarLight(v);
      }

      if ((s == "All") || (s == "TaxiwayCentreLight"))
      {
         setTaxiwayCentreLight(v);
      }

      if ((s == "All") || (s == "TaxiwayEdgeLight"))
      {
         setTaxiwayEdgeLight(v);
      }

      if ((s == "All") || (s == "TaxiwayIdentifierMarkerBoardLight"))
      {
         setTaxiwayIdentifierMarkerBoardLight(v);
      }

      if (s == "Undercarriage")
      {
         setUndercarriageInspectionSystem(v == 1);
      }
   }

   unsigned char value(const DtString& s) const
   {
      if (s == "ApronLight")
      {
         return apronLight();
      }
      else if (s == "ApronFloodLight")
      {
         return apronFloodLight();
      }
      else if (s == "ClearanceBarLight")
      {
         return clearanceBarLight();
      }
      else if (s == "TaxiwayCentreLight")
      {
         return taxiwayCentreLight();
      }
      else if (s == "TaxiwayEdgeLight")
      {
         return taxiwayEdgeLight();
      }
      else if (s == "TaxiwayIdentifierMarkerBoardLight")
      {
         return taxiwayIdentifierMarkerBoardLight();
      }
      else if (s == "Undercarriage")
      {
         return undercarriageInspectionSystem();
      }
      else if (s == "All")
      {
         return -1;
      }

      return 0;
   }

   std::vector<DtString> runwaysArchived() const;
   void restoreRunwaysFromArchive(const std::vector<DtString>&);

   DtString archive() const;
   void restoreFromArchive(const DtString&);

protected:
   DtString myAirportCode;
   DtString myGlobalId;
   DtUUID myUUID;
   bool myIsLocal;
   bool myCheckForNameReservation;
   bool myActive;
   int myForceType;
   unsigned int myAppearance;
   DtEntityIdentifier myEntityIdentifier;
   DtObjectType myObjectType;

   unsigned char myApronLight;
   unsigned char myApronFloodLight;
   unsigned char myClearanceBarLight;
   unsigned char myObstructionLight;
   unsigned char myTaxiwayCentreLight;
   unsigned char myTaxiwayEdgeLight;
   unsigned char myTaxiwayGuardLight;
   unsigned char myTaxiwayIdentifierMarkerBoardLight;
   unsigned char myUndercarriageInspectionSystem;

   std::map<DtUUID, DtRunwayStateData> myRunways;
};