vrfStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/doubleBufferedDataStorage.h"
#include "vrfStateData/stateComponent.h"
#include <vrfutil/extendedDataKeywords.h>
#include <vrfutil/rwUUID.h>
#include "vrfutil/echelonId.h"
#include <vlutil/vlTime.h>
#include "legionDataStore/writeStateInstance.h"
#include "legionDataStore/readStateInstance.h"
#include "legionDataStore/view.h"
#include "vrfOM/sets/readVrfStateComponentRepository.hpp"
#include "vrfOM/sets/writeVrfStateComponentRepository.hpp"
#include <tbb/spin_mutex.h>

namespace makVrf
{
   class DtVrfStateComponentDataStore;

   static tbb::spin_mutex theEchelonIdMutex;

   struct DT_DLL_vrfStateData DtVrfStateComponentData
   {
      DtVrfStateComponentData()
      : myIsRemoteAttachedObject(false)
      {
      }

      DtVrfStateComponentData(const DtVrfStateComponentData& orig)
      : myIsRemoteAttachedObject(orig.myIsRemoteAttachedObject)
      , myEchelonId(orig.myEchelonId)
      {
      }

      DtVrfStateComponentData& operator=(const DtVrfStateComponentData& rhs)
      {
         myIsRemoteAttachedObject = rhs.myIsRemoteAttachedObject;

         {
            tbb::spin_mutex::scoped_lock lock(theEchelonIdMutex);
            myEchelonId = rhs.myEchelonId;
         }

         return *this;
      }

      DEFINE_ACCESSOR_MUTATOR(bool, isRemoteAttachedObject, IsRemoteAttachedObject)
      DEFINE_ACCESSOR_MUTATOR(DtEchelonId, echelonId, EchelonId)

   protected:
      bool myIsRemoteAttachedObject;
      DtEchelonId myEchelonId;
   };

   class DT_DLL_vrfStateData DtVrfStateComponent : public DtFrameStateInterface
   {
   public:
      typedef std::map<DtString, DtString> ExtendedData;
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::VrfStateComponent)

      DtVrfStateComponent(DtStateData* storage)
      : DtFrameStateInterface(storage)
      {
      }

      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(bool, isRemoteAttachedObject, IsRemoteAttachedObject)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, isVrfSimulatedObject, IsVrfSimulatedObject)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtString, label, Label)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtString, overlay, Overlay)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, independentlyTasked, IndependentlyTasked)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtString, engagementRules, EngagementRules)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, isSubordinateOfForceLevel, IsSubordinateOfForceLevel)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, isTasked, IsTasked)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, underFire, UnderFire)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, executingPlan, ExecutingPlan)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, hasPlan, HasPlan)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, sensorsKilled, SensorsKilled)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, sessionId, SessionId)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, vrfMessageVersionSupported, VrfMessageVersionSupported)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtEchelonId, echelonId, EchelonId)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(ExtendedData, extendedData, ExtendedData)
      UNDEFINED_CONST_METHOD(bool, activated)

      virtual void setExtendedData(const DtString& key, const DtString& value) { throw DtUnimplementedMethod("setExtendedData(const DtString& key, const DtString& value) is not implemented for this class"); };
      virtual const DtString& extendedData(const DtString& key) const { throw DtUnimplementedMethod("extendedData(const DtString& key) is not implemented for this class"); };
      virtual void clearExtendedData() { throw DtUnimplementedMethod("clearExtendedData() is not implemented for this class"); };
      virtual void removeExtendedData(const DtString& key) { throw DtUnimplementedMethod("removeExtendedData(const DtString& key) is not implemented for this class"); };
      virtual ExtendedData extendedDataMap() const { throw DtUnimplementedMethod("extendedDataMap() is not implemented for this class"); };
      virtual bool hasExtendedData(const DtString&) const { throw DtUnimplementedMethod("hasExtendedData(const DtString&) const is not implemented for this class"); };

      mutable boost::signals2::signal<void (const DtFrameStateInterface*)> signal_extendedDataModified{};
   };

   class DT_DLL_vrfStateData DtVrfStateComponentNextFrame : public DtVrfStateComponent
   {
   public:
      DtVrfStateComponentNextFrame(DtStateData*);
      virtual ~DtVrfStateComponentNextFrame() override;

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

      virtual const bool isVrfSimulatedObject() const override;
      virtual void setIsVrfSimulatedObject(const bool&) override;

      virtual const DtString label() const override;
      virtual void setLabel(const DtString&) override;

      virtual const DtString overlay() const override;
      virtual void setOverlay(const DtString&) override;

      virtual const bool independentlyTasked() const override;
      virtual void setIndependentlyTasked(const bool&) override;

      virtual const bool& isRemoteAttachedObject() const override;
      virtual void setIsRemoteAttachedObject(const bool&) override;

      virtual const DtString engagementRules() const override;
      virtual void setEngagementRules(const DtString&) override;

      virtual const bool isSubordinateOfForceLevel() const override;
      virtual void setIsSubordinateOfForceLevel(const bool&) override;

      virtual const bool isTasked() const override;
      virtual void setIsTasked(const bool&) override;

      virtual const bool underFire() const override;
      virtual void setUnderFire(const bool&) override;

      virtual const bool executingPlan() const override;
      virtual void setExecutingPlan(const bool&) override;

      virtual const bool hasPlan() const override;
      virtual void setHasPlan(const bool&) override;

      virtual const bool sensorsKilled() const override;
      virtual void setSensorsKilled(const bool&) override;

      virtual const DtEchelonId& echelonId() const override;
      virtual void setEchelonId(const DtEchelonId&) override;

      virtual const int sessionId() const override;
      virtual void setSessionId(const int&) override;

      virtual const int vrfMessageVersionSupported() const override;
      virtual void setVrfMessageVersionSupported(const int&) override;

      virtual const ExtendedData& extendedData() const override;
      virtual void setExtendedData(const ExtendedData&) override;
      virtual void setExtendedData(const DtString& key, const DtString& value) override;
      virtual const DtString& extendedData(const DtString& key) const override;

      virtual void clearExtendedData() override;
      void updateExtendedData();
      virtual void removeExtendedData(const DtString& key) override;

      virtual bool activated() const override;

      virtual void makeWritable() override;

      virtual void makeReadOnly() override;

      bool extendedDataModified() const
      {
         return myExtendedDataModified;
      }

      void clearExtendedDataModified()
      {
         myExtendedDataModified = false;
      }

      virtual ExtendedData extendedDataMap() const override;
      virtual bool hasExtendedData(const DtString&) const override;

   protected:
      VRF::WriteVrfStateComponentRepository myWriteVrfStateComponentRepository;
      ExtendedData myExtendedData;
      DtEchelonId myEchelonId;
      bool myExtendedDataModified;
      DtVrfStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtVrfStateComponentCurrentFrame : public DtVrfStateComponent
   {
   public:
      DtVrfStateComponentCurrentFrame(DtStateData*);
      virtual ~DtVrfStateComponentCurrentFrame() override;

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

      virtual const bool isVrfSimulatedObject() const override;
      virtual const DtString label() const override;
      virtual const DtString overlay() const override;
      virtual const bool independentlyTasked() const override;
      virtual const bool& isRemoteAttachedObject() const override;
      virtual const DtString engagementRules() const override;
      virtual const bool isSubordinateOfForceLevel() const override;
      virtual const bool isTasked() const override;
      virtual const bool underFire() const override;
      virtual const bool executingPlan() const override;
      virtual const bool hasPlan() const override;
      virtual const bool sensorsKilled() const override;
      virtual const DtEchelonId& echelonId() const override;
      virtual const int sessionId() const override;
      virtual const int vrfMessageVersionSupported() const override;
      virtual const ExtendedData& extendedData() const override;
      virtual bool activated() const override;
      bool readComponentValid() const;
      virtual ExtendedData extendedDataMap() const override;
      virtual bool hasExtendedData(const DtString&) const override;

      virtual const DtString& extendedData(const DtString& key) const override;

      virtual bool findReadComponent();
      void handleExtendedDataUpdated(const std::vector<UInt32>& attributesUpdated);

   private:
      friend class DtVrfStateComponentImplementation;
      void updateExtendedData(const ExtendedData&);
      void advanceFrame(const DtVrfStateComponentData& data)
      {
         myData = data;
      }

   protected:
      VRF::ReadVrfStateComponentRepository myReadVrfStateComponentRepository;
      ExtendedData myExtendedData;
      unsigned int myCallbackHandle;
      DtVrfStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtVrfStateComponentImplementation : public DtDoubleBufferedStateComponent<DtVrfStateComponent>
   {
   public:
      DtVrfStateComponentImplementation(DtStateData* sd);
      virtual ~DtVrfStateComponentImplementation() override;

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

      virtual void updateDataStorage() override;

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

      virtual bool forceAdvance() override;

      virtual void firstFrameAdvance() override;

      virtual void addAdditionalStateComponents() override;

      virtual void initializeFromParameters(const DtVrfObjectParameters* params) override;

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

   protected:
      DtVrfStateComponentCurrentFrame myCurrentFrameState;
      DtVrfStateComponentNextFrame myNextFrameState;
      bool myFoundComponent;
   };

   using DtVrfStateComponentCreator = DtStateComponentCreator<DtVrfStateComponentImplementation, false>;
}