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"); };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      bool activated() const;

      virtual void makeWritable();

      virtual void makeReadOnly();

      bool extendedDataModified() const
      {
         return myExtendedDataModified;
      }

      void clearExtendedDataModified()
      {
         myExtendedDataModified = false;
      }

      ExtendedData extendedDataMap() const;

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

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

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

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

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

      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;
      DtStateData* myStateData;
      DtVrfStateComponentData myData;
   };

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

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

      void updateDataStorage();

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

      virtual bool forceAdvance();

      virtual void firstFrameAdvance() override;

      virtual void addAdditionalStateComponents() override;

      virtual void initializeFromParameters(const DtVrfObjectParameters* params);

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

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

   typedef DtStateComponentCreator<DtVrfStateComponentImplementation, false> DtVrfStateComponentCreator;
}