environmentalStateComponent.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 <legionStandardOM/sets/readEnvironmentProcessRepository.hpp>
#include <legionStandardOM/sets/writeEnvironmentProcessRepository.hpp>
#include "vrfOM/sets/writeVrfEnvironmentRecordRepository.hpp"
#include "vrfOM/sets/readVrfEnvironmentRecordRepository.hpp"
#include <boost/signals2.hpp>

#include <vlutil/vlString.h>

class DtRwIntelCollectionArea;

namespace makVrf
{
   DT_DLL_vrfStateData extern Legion::AttributeSetId theVrfEnvironmentRecordSetType;

   struct DT_DLL_vrfStateData DtEnvironmentalStateComponentData 
   {
      DtEnvironmentalStateComponentData()
      : myUUID(DtUUID::nullUUID())
      , myIsLocal(false)
      , myCheckForNameReservation(true)
      , myPhysicalLineHeight(0.)
      , myPhysicalLineWidth(0.)
      , myCeilingHeight(0.)
      , myTickPeriod(-1)
      {};

      DtEnvironmentalStateComponentData(const DtEnvironmentalStateComponentData& orig)
      {
         myPhysicalLineHeight = orig.myPhysicalLineHeight;
         myPhysicalLineWidth = orig.myPhysicalLineWidth;
         myCeilingHeight = orig.myCeilingHeight;
         myGlobalId = orig.myGlobalId;
         myUUID = orig.myUUID;
         myMarkingText = orig.myMarkingText;
         myEntityId = orig.myEntityId;
         myIsLocal = orig.myIsLocal;
         myCheckForNameReservation = orig.myCheckForNameReservation;
         myTickPeriod = orig.myTickPeriod;
      }

      DtEnvironmentalStateComponentData& operator=(const DtEnvironmentalStateComponentData& orig)
      {
         myPhysicalLineHeight = orig.myPhysicalLineHeight;
         myPhysicalLineWidth = orig.myPhysicalLineWidth;
         myGlobalId = orig.myGlobalId;
         myUUID = orig.myUUID;
         myMarkingText = orig.myMarkingText;
         myEntityId = orig.myEntityId;
         myIsLocal = orig.myIsLocal;
         myCheckForNameReservation = orig.myCheckForNameReservation;
         myCeilingHeight = orig.myCeilingHeight;
         myTickPeriod = orig.myTickPeriod;

         return *this;
      }

      DEFINE_ACCESSOR_MUTATOR(double, physicalLineHeight, PhysicalLineHeight)
      DEFINE_ACCESSOR_MUTATOR(double, physicalLineWidth, PhysicalLineWidth)
      DEFINE_ACCESSOR_MUTATOR(double, ceilingHeight, CeilingHeight)
      DEFINE_ACCESSOR_MUTATOR(DtString, globalId, GlobalId)
      DEFINE_ACCESSOR_MUTATOR(DtEntityIdentifier, entityId, EntityId)
      DEFINE_ACCESSOR_MUTATOR(DtUUID, uuid, UUID)
      DEFINE_ACCESSOR_MUTATOR(DtString, markingText, MarkingText)
      DEFINE_ACCESSOR_MUTATOR(bool, isLocal, IsLocal)
      DEFINE_ACCESSOR_MUTATOR(bool, checkForNameReservation, CheckForNameReservation)
      DEFINE_ACCESSOR_MUTATOR(int, tickPeriod, TickPeriod)

   protected:
      double myPhysicalLineHeight;
      double myPhysicalLineWidth;
      double myCeilingHeight;
      DtString myGlobalId;
      DtString myMarkingText;
      DtEntityIdentifier myEntityId;
      DtUUID myUUID;
      bool myIsLocal;
      bool myCheckForNameReservation;
      int myTickPeriod;
   };

   class DT_DLL_vrfStateData DtEnvironmentalStateComponent : public DtSimulatedObjectStateComponent
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::EnvironmentalStateComponent)

      DtEnvironmentalStateComponent(DtStateData* storage)
      : DtSimulatedObjectStateComponent(storage)
      , myUUIDColumn(0xFFFFFFFF)
      , myMarkingTextColumn(0xFFFFFFFF)
      , myForceTypeColumn(0xFFFFFFFF)
      , myEntityIdColumn(0xFFFFFFFF)
      , myAppearanceBitsColumn(0xFFFFFFFF)
      , myObjectTypeColumn(0xFFFFFFFF)
      {
      }

      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, tickPeriod, TickPeriod)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, color, Color)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtString, userData, UserData)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(double, physicalLineHeight, PhysicalLineHeight)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(double, physicalLineWidth, PhysicalLineWidth)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(double, ceilingHeight, CeilingHeight)

      virtual double intelAreaModifierForForce(int forceType) const { throw DtUnimplementedMethod("intelAreaModifierForForce(int) is not implemented for this class"); };

      virtual int recordCount() const { throw DtUnimplementedMethod("recordCount is not implemented for this class."); };
      
      virtual std::vector<UInt64> records() const { throw DtUnimplementedMethod("records is not implemented for this class."); };

      virtual void addRecord(Legion::WriteStateInstance) { throw DtUnimplementedMethod("addRecord is not implemented for this class."); };

      virtual void removeRecord(Legion::WriteStateInstance) { throw DtUnimplementedMethod("addRecord is not implemented for this class."); };

      virtual UInt64 instanceHandle() const { throw DtUnimplementedMethod("instanceHandle is not implemented for this class."); };

   protected:
      UInt32 myUUIDColumn;
      UInt32 myMarkingTextColumn;
      UInt32 myForceTypeColumn;
      UInt32 myEntityIdColumn;
      UInt32 myAppearanceBitsColumn;
      UInt32 myObjectTypeColumn;
   };

   class DT_DLL_vrfStateData DtEnvironmentalStateComponentNextFrame : public DtEnvironmentalStateComponent
   {
   public:
      DtEnvironmentalStateComponentNextFrame( DtStateData*);
      virtual ~DtEnvironmentalStateComponentNextFrame();

      const DtEnvironmentalStateComponentData& frameState() const { return myData; };
      DtEnvironmentalStateComponentData& frameState() { return myData; };
   
      const bool& isLocal() const;
      void setIsLocal(const bool&);
   
      const bool& checkForNameReservation() const;
      void setCheckForNameReservation(const bool&);
   
      const DtString& globalId() const;
      void setGlobalId(const DtString&);

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

      const DtString& markingText() const;
      void setMarkingText(const DtString&);

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

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

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

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

      const int tickPeriod() const;
      void setTickPeriod(const int&);

      const int color() const;
      void setColor(const int&);

      const DtString userData() const;
      void setUserData(const DtString&);

      const double& physicalLineHeight() const;
      void setPhysicalLineHeight(const double&);

      const double& ceilingHeight() const;
      void setCeilingHeight(const double&);

      const double& physicalLineWidth() const;
      void setPhysicalLineWidth(const double&);

      double floor() const;

      virtual void makeWritable();

      virtual void makeReadOnly();

      int recordCount() const;
      
      std::vector<UInt64> records() const;

      void addRecord(Legion::WriteStateInstance);

      void removeRecord(Legion::WriteStateInstance);

      UInt64 instanceHandle() const;

      void updateVrfStateComponentParameters();

   protected:
      void updatePhysicalLineHeightInformation();
      void updateCeilingInformation();
      void updatePhysicalLineWidthInformation();

   protected:
      LOM::WriteEnvironmentProcessRepository myWriteEnvironmentProcessRepository;
      VRF::WriteVrfEnvironmentRecordRepository myWriteVrfEnvironmentRecordRepository;
      DtStateData* myStateData;
      mutable DtEnvironmentalStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtEnvironmentalStateComponentCurrentFrame : public DtEnvironmentalStateComponent
   {
   public:
      DtEnvironmentalStateComponentCurrentFrame(DtStateData*);
      virtual ~DtEnvironmentalStateComponentCurrentFrame();

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

      const bool& isLocal() const;
      const bool& checkForNameReservation() const;
      const DtString& globalId() const;
      const DtUUID& uuid() const;
      const DtString& markingText() const;
      const DtForceType forceType() const;
      const DtEntityType entityType() const { return DtEntityType(objectType()); };
      const DtObjectType objectType() const;
      const DtEntityIdentifier& entityId() const;
      const UInt32 appearanceBits() const;
      const int tickPeriod() const;
      const int color() const;
      const DtString userData() const;
      const double& physicalLineHeight() const;
      const double& physicalLineWidth() const;
      const double& ceilingHeight() const;
      double intelAreaModifierForForce(int forceType) const;

      bool readComponentValid() const;

      bool findReadComponent();

      virtual int recordCount() const;
      
      virtual std::vector<UInt64> records() const;

      UInt64 instanceHandle() const;

      bool checkForUpdatedItems();

   protected:
      const DtUUID _uuid() const;
      const DtString _markingText() const;
      const DtEntityIdentifier _entityId() const;

      void completeSetup();
      void updateVrfStateComponentParameters();

      void updatePhysicalLineHeightInformation();
      void updateCeilingInformation();
      void updatePhysicalLineWidthInformation();

      void handleDataUpdated(const std::vector<UInt32>& attributesUpdated);
      bool checkUUIDChanged();
      bool checkForceChanged();
      bool checkMarkingTextChanged();
      bool checkEntityIdChanged();

      friend class DtEnvironmentalStateComponentImplementation;
      void advanceFrame(const DtEnvironmentalStateComponentData& data)
      {
         myData = data;
      }

   protected:
      boost::signals2::scoped_connection myVrfStateComponentChangedConnection;
      DtRwIntelCollectionArea* myIntelCollectionAreaInformation;
      LOM::ReadEnvironmentProcessRepository myReadEnvironmentProcessRepository;
      VRF::ReadVrfEnvironmentRecordRepository myReadVrfEnvironmentRecordRepository;
      unsigned int myCallbackHandle;
      unsigned int myDataCallbackHandle;
      UInt32 myCenterPointColumn;
      UInt32 myOrientationColumn;
      int myForceId;
      std::string myMarkingText;

      DtStateData* myStateData;
      DtEnvironmentalStateComponentData myData;
   };

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

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

      virtual bool forceAdvance();
      static void addAdditionalTableColumns(Legion::SimulationDatabase* db);

      void updateDataStorage()
      {
         if (!myFoundComponent)
         {
            myFoundComponent = myCurrentFrameState.findReadComponent();
         }

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

         myCurrentFrameState.checkForUpdatedItems();
         myCurrentFrameState.emitComponentUpdated();
      }

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

      virtual void convertToRemote();

      virtual void convertToLocal();

      Legion::WriteStateInstance writeStateInstance() override { return myWriteEnvironmentProcessRepository; };

      virtual void addAdditionalStateComponents() override;

      virtual void firstFrameAdvance() override;

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

   protected:
      DtEnvironmentalStateComponentCurrentFrame myCurrentFrameState;
      DtEnvironmentalStateComponentNextFrame myNextFrameState;
      LOM::WriteEnvironmentProcessRepository myWriteEnvironmentProcessRepository;
      bool myFoundComponent;
      bool myCheckedForVrfStateComponent;
      boost::signals2::scoped_connection myVrfStateComponentChangedConnection;
   };

   typedef DtStateComponentCreator<DtEnvironmentalStateComponentImplementation> DtEnvironmentalStateComponentCreator;
}