aerodromeStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/simulatedObjectStateComponent.h"
#include "vrfStateData/doubleBufferedDataStorage.h"
#include "vrfutil/aerodromeStateData.h"
#include "legionDataStore/writeStateInstance.h"
#include <boost/signals2.hpp>

#include <vlutil/vlString.h>

namespace makVrf
{
   class DT_DLL_vrfStateData DtAerodromeStateComponent : public DtSimulatedObjectStateComponent
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::AerodromeStateComponent)

      DtAerodromeStateComponent(DtStateData* storage)
      : DtSimulatedObjectStateComponent(storage)
      {
      }

      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtString, airportCode, AirportCode)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(bool, active, Active)
      virtual DtRunwayStateData& addRunway() { throw DtUnimplementedMethod("The DtRunwayStateData addRunway() method is unimplemented"); };
      virtual void removeRunway(const DtUUID&) { throw DtUnimplementedMethod("The void removeRunway(const DtUUID&) method is unimplemented"); };
      virtual DtRunwayStateData& runway(const DtUUID&) { throw DtUnimplementedMethod("DtRunwayStateData& runway(const DtUUID&) method is unimplemented"); };
      virtual DtRunwayStateData& runway(const std::string&) { throw DtUnimplementedMethod("DtRunwayStateData& runway(const std::string&) method is unimplemented"); };
      virtual const DtRunwayStateData& runway(const DtUUID&) const { throw DtUnimplementedMethod("The const DtRunwayStateData& runway(const DtUUID&) const method is unimplemented"); };
      virtual const DtRunwayStateData& runway(const std::string&) const { throw DtUnimplementedMethod("The const DtRunwayStateData& runway(const std::string&) const method is unimplemented"); };
      virtual const DtRunwayLightStateData& runwayState(const std::string&) const { throw DtUnimplementedMethod("The const DtRunwayLightStateData& runwayState(const std::string&) const method is unimplemented"); };
      virtual const std::map<DtUUID, DtRunwayStateData>& runways() const { throw DtUnimplementedMethod("The std::map<DtUUID, DtRunwayStateData> runways() const  method is unimplemented"); };
      virtual void setRunways(const std::map<DtUUID, DtRunwayStateData>&) { throw DtUnimplementedMethod("The void setRunways(const std::map<DtUUID, DtRunwayStateData>&)  method is unimplemented"); };
      virtual std::vector<DtString> runwaysArchived() const { throw DtUnimplementedMethod("The std::vector<DtString> runwaysArchived() const  method is unimplemented"); };
      virtual void restoreRunwaysFromArchive(const std::vector<DtString>&) { throw DtUnimplementedMethod("The void restoreRunwaysFromArchive(const std::vector<DtString>&)  method is unimplemented"); };
      virtual unsigned char runwayValue(const DtString&, const DtString& runwayName) const { throw DtUnimplementedMethod("The unsigned char runwayValue(const DtString&, const DtString& runwayName) const  method is unimplemented"); };
      virtual void setRunwayValue(const DtString&, unsigned char, const DtString& runwayName) { throw DtUnimplementedMethod("The void setRunwayValue(const DtString&, unsigned char, const DtString& runwayName) const  method is unimplemented"); };
      virtual unsigned char value(const DtString&) const { throw DtUnimplementedMethod("The unsigned char value(const DtString&) const  method is unimplemented"); };
      virtual void setValue(const DtString&, unsigned char) { throw DtUnimplementedMethod("The void setValue(const DtString&, unsigned char) const  method is unimplemented"); };
      virtual void restoreFromArchive(const DtString&) { throw DtUnimplementedMethod("The void restoreFromArchive(const DtString&) const  method is unimplemented"); };
      UNDEFINED_RETURNREF_ACCESSOR(DtAerodromeStateData, frameState)

   };

   class DT_DLL_vrfStateData DtAerodromeStateComponentNextFrame : public DtAerodromeStateComponent
   {
   public:
      DtAerodromeStateComponentNextFrame( DtStateData*);
      virtual ~DtAerodromeStateComponentNextFrame();

      const DtAerodromeStateData& frameState() const { return myData; };
      DtAerodromeStateData& frameState() { return myData; };

      const bool& isLocal() const;
      void setIsLocal(const bool&);

      const bool& active() const;
      void setActive(const bool&);

      const DtString& globalId() const;
      void setGlobalId(const DtString&);

      const DtUUID& uuid() const;
      void setUUID(const DtUUID&);

      const DtString& airportCode() const;
      void setAirportCode(const DtString&);

      unsigned char value(const DtString&) const;
      void setValue(const DtString&, unsigned char);
      void restoreFromArchive(const DtString&);

      unsigned char runwayValue(const DtString&, const DtString& runwayName) const;
      void setRunwayValue(const DtString&, unsigned char, const DtString& runwayName);

      std::vector<DtString> runwaysArchived() const;

      const DtString& markingText() const
      {
         return airportCode();
      }

      void setMarkingText(const DtString& t)
      {
         setAirportCode(t);
      }

      const DtForceType forceType() const;
      void setForceType(const DtForceType&);

      const UInt32 appearanceBits() const;
      void setAppearanceBits(const UInt32&);

      const DtEntityType entityType() const { return DtEntityType(objectType()); };
      const DtObjectType objectType() const;
      void setEntityType(const DtEntityType& t);

      const DtEntityIdentifier& entityId() const;
      void setEntityId(const DtEntityIdentifier&);

      DtRunwayStateData& addRunway();
      void removeRunway(const DtUUID&);
      DtRunwayStateData& runway(const DtUUID&);
      DtRunwayStateData& runway(const std::string&);
      const DtRunwayStateData& runway(const DtUUID&) const;
      const DtRunwayStateData& runway(const std::string&) const;
      const DtRunwayLightStateData& runwayState(const std::string&) const;
      const std::map<DtUUID, DtRunwayStateData>& runways() const;
      void setRunways(const std::map<DtUUID, DtRunwayStateData>&);

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

   protected:
      DtStateData* myStateData;
      mutable DtAerodromeStateData myData;
   };

   class DT_DLL_vrfStateData DtAerodromeStateComponentCurrentFrame : public DtAerodromeStateComponent
   {
   public:
      DtAerodromeStateComponentCurrentFrame(DtStateData*);
      virtual ~DtAerodromeStateComponentCurrentFrame();

      const DtAerodromeStateData& frameState() const { return myData; };

      const bool& isLocal() const;
      const bool& active() const;
      const DtString& globalId() const;
      const DtUUID& uuid() const;
      const DtString& airportCode() const;
      const DtString& markingText() const
      {
         return airportCode();
      }

      const UInt32 appearanceBits() const;
      const DtEntityType entityType() const { return DtEntityType(objectType()); };
      const DtObjectType objectType() const;
      const DtEntityIdentifier& entityId() const;
      std::vector<DtString> runwaysArchived() const;
      unsigned char value(const DtString&) const;
      unsigned char runwayValue(const DtString&, const DtString& runwayName) const;

      const DtForceType forceType() const;
      const DtRunwayStateData& runway(const DtUUID&) const;
      const DtRunwayStateData& runway(const std::string&) const;
      const DtRunwayLightStateData& runwayState(const std::string&) const;
      const std::map<DtUUID, DtRunwayStateData>& runways() const;

   protected:
      friend class DtAerodromeStateComponentImplementation;
      void advanceFrame(const DtAerodromeStateData& data)
      {
         myData = data;
      }

   protected:
      DtStateData* myStateData;
      DtAerodromeStateData myData;
   };

   class DT_DLL_vrfStateData DtAerodromeStateComponentImplementation : public DtDoubleBufferedStateComponent<DtAerodromeStateComponent>
   {
   public:
      DtAerodromeStateComponentImplementation(DtStateData* sd);
      virtual ~DtAerodromeStateComponentImplementation();

      bool isDoubleBuffered() { return true; };
      const DtFrameStateInterface* currentFrameState() const { return &myCurrentFrameState; }
      virtual DtFrameStateInterface* nextFrameState() { return &myNextFrameState; };
      virtual const DtFrameStateInterface* nextFrameState() const { return &myNextFrameState; };

      void updateDataStorage()
      {
         if (myNextFrameState.isWritable())
         {
            myCurrentFrameState.advanceFrame(myNextFrameState.frameState());
         }

         myCurrentFrameState.emitComponentUpdated();
      }

      void updateStateData(DtStateData* sd)
      {
         myCurrentFrameState.updateStateData(sd);
         myNextFrameState.updateStateData(sd);
      }

      virtual void aboutToBeDeleted() override
      {
         DtDoubleBufferedStateComponent<DtAerodromeStateComponent>::aboutToBeDeleted();
         myCurrentFrameState.aboutToBeDeleted();
         myNextFrameState.aboutToBeDeleted();
      }

      virtual void addAdditionalStateComponents() override;
      Legion::WriteStateInstance writeStateInstance() override { return myWriteStateInstance; };

      virtual void convertToRemote();

      virtual void convertToLocal();

   protected:
      DtAerodromeStateComponentCurrentFrame myCurrentFrameState;
      DtAerodromeStateComponentNextFrame myNextFrameState;
      Legion::WriteStateInstance myWriteStateInstance;
   };

   typedef DtStateComponentCreator<DtAerodromeStateComponentImplementation> DtAerodromeStateComponentCreator;
}