spotReportStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/stateComponent.h"
#include "vrfStateData/simulatedObjectStateComponent.h"
#include "vrfStateData/doubleBufferedDataStorage.h"
#include <matrix/vlVector.h>
#include <matrix/vlTaitBryan.h>
#include <vrfutil/rwUUID.h>
#include <vrvCore/DtUniqueID.h>
#include <vrfStateData/simpleTypedDictionary.h>
#include <vlpi/entityIdentifier.h>
#include <vlpi/entityType.h>
#include <legionStandardOM/sets/writeEntityRepository.hpp>
#include "legionStandardOM/sets/readEntityRepository.hpp"

namespace makVrf
{

   struct DT_DLL_vrfStateData DtSpotReportStateComponentData
   {
      DtSpotReportStateComponentData() : myContactUUID(DtUUID::nullUUID()), myUUID(DtUUID::nullUUID())
      { myWorldPositions.push_back(DtVector::zero()); };

      DtSpotReportStateComponentData(const DtSpotReportStateComponentData& orig)
      {
         *this = orig;
      };

      DtSpotReportStateComponentData& operator=(const DtSpotReportStateComponentData& orig)
      {
         myWorldVelocity = orig.myWorldVelocity;
         myUniqueIdentifier = orig.myUniqueIdentifier;
         myObservedBy = orig.myObservedBy;
         myVisualHandlerType = orig.myVisualHandlerType;
         myDataHandlerType = orig.myDataHandlerType;
         myContactUUID = orig.myContactUUID;
         myUUID = orig.myUUID;
         myDateTimeOfReport = orig.myDateTimeOfReport;
         myIsTDLReport = orig.myIsTDLReport;
         myDictionary = orig.myDictionary;
         myWorldPositions = orig.myWorldPositions;
         myWorldOrientation = orig.myWorldOrientation;
         myGlobalId = orig.myGlobalId;
         myEntityId = orig.myEntityId;
         myUserData = orig.myUserData;
         myMarkingText = orig.myMarkingText;

         return *this;
      };

      DEFINE_ACCESSOR_MUTATOR(std::string, uniqueIdentifier, UniqueIdentifier)
      DEFINE_ACCESSOR_MUTATOR(std::string, visualHandlerType, VisualHandlerType)
      DEFINE_ACCESSOR_MUTATOR(std::string, dataHandlerType, DataHandlerType)
      DEFINE_ACCESSOR_MUTATOR(DtUUID, contactUUID, ContactUUID)
      DEFINE_ACCESSOR_MUTATOR(DtUUID, uuid, UUID)
      DEFINE_ACCESSOR_MUTATOR(bool, isTDLReport, IsTDLReport)
      DEFINE_ACCESSOR_MUTATOR(double, dateTimeOfReport, DateTimeOfReport)
      DEFINE_ACCESSOR_MUTATOR(DtTaitBryan, worldOrientation, WorldOrientation)
      DEFINE_ACCESSOR_MUTATOR(DtVector, worldVelocity, WorldVelocity)
      DEFINE_ACCESSOR_MUTATOR(DtString, globalId, GlobalId)
      DEFINE_ACCESSOR_MUTATOR(DtString, markingText, MarkingText)
      DEFINE_ACCESSOR_MUTATOR(DtEntityIdentifier, entityId, EntityId)
      DEFINE_ACCESSOR_MUTATOR(unsigned long long, userData, UserData)

      double simulationTimeSent() const
      {
         return myDictionary.doubleValue("SimulationTime");
      }

      const std::string displayType() const
      {
         std::string str = myDictionary.value("DisplayType");

         if (!str.empty())
         {
            return str;
         }
         else
         {
            return myDictionary.value("PerceivedType");
         }
      }

      int appearanceBits() const
      {
         return atoi(myDictionary.value("PerceivedAppearance").c_str());
      }

      const DtForceType forceType() const
      {
         return (DtForceType)(atoi(myDictionary.value("PerceivedForce").c_str()));
      }

      const DtEntityType entityType() const
      {
         return DtEntityType(myDictionary.value("PerceivedType").c_str());
      }

      const std::vector<DtVector>& worldPositions() const
      {
         return myWorldPositions;
      }

      std::vector<DtVector>& worldPositions()
      {
         return myWorldPositions;
      }

      DtVector worldPosition() const
      {
         if (!myWorldPositions.empty())
         {
            return myWorldPositions[0];
         }

         return DtVector::zero();
      }

      void setWorldPosition(const DtVector& v)
      {
         if (myWorldPositions.empty())
         {
            myWorldPositions.push_back(v);
         }
         else
         {
            myWorldPositions[0] = v;  
         }
      }

      DtSimpleTypedDictionary& dictionary()
      {
         return myDictionary;
      }

      const DtSimpleTypedDictionary& dictionary() const
      {
         return myDictionary;
      }

      bool addObservedBy(const makVrv::DtUniqueID& s, double simTime)
      {
         std::map<makVrv::DtUniqueID, double>::iterator iter = myObservedBy.find(s);

         if (iter == myObservedBy.end())
         {
            myObservedBy[s] = simTime;
            return true;
         }
         else
         {
            iter->second = simTime;
            return false;
         }
      }

      void removeObservedBy(const makVrv::DtUniqueID& s)
      {
         std::map<makVrv::DtUniqueID, double>::iterator iter = myObservedBy.find(s);

         if (iter != myObservedBy.end())
         {
            myObservedBy.erase(iter);
         }
      }

      bool observedBy(const makVrv::DtUniqueID& s) const
      {
         return (myObservedBy.find(s) != myObservedBy.end());
      }

      const std::map<makVrv::DtUniqueID, double>& observedBy() const
      {
         return myObservedBy;
      }

      void setProtocol(const std::string& s)
      {
         myDictionary.setValue("Protocol", s);
      }

      std::string protocol() const
      {
         return myDictionary.value("Protocol");
      }

      void setDomain(const std::string& s)
      {
         myDictionary.setValue("Domain", s);
      }

      std::string domain() const
      {
         return myDictionary.value("Domain");
      }

   protected:
      std::map<makVrv::DtUniqueID, double> myObservedBy;
      std::string myVisualHandlerType;
      std::string myDataHandlerType;
      std::string myUniqueIdentifier;
      DtUUID myContactUUID;
      DtUUID myUUID;
      double myDateTimeOfReport;
      bool myIsTDLReport = false;
      DtSimpleTypedDictionary myDictionary;
      std::vector<DtVector> myWorldPositions;
      DtVector myWorldVelocity;
      DtTaitBryan myWorldOrientation;
      DtString myGlobalId;
      DtEntityIdentifier myEntityId;
      unsigned long long myUserData = 0;
      DtString myMarkingText;
   };

   class DT_DLL_vrfStateData DtSpotReportStateComponent : public DtSimulatedObjectStateComponent
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::SpotReportStateComponent)

      DtSpotReportStateComponent(DtStateData* storage)
      : DtSimulatedObjectStateComponent(storage)
      {

      }

      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(std::string, dataHandlerType, DataHandlerType);
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(std::string, visualHandlerType, VisualHandlerType);
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtUUID, contactUUID, ContactUUID);
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(double, dateTimeOfReport, DateTimeOfReport);
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(bool, isTDLReport, IsTDLReport);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtVector, worldPosition, WorldPosition);
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtTaitBryan, worldOrientation, WorldOrientation);
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtVector, worldVelocity, WorldVelocity);
      UNDEFINED_RETURNVALUE_ACCESSOR(std::string, displayType)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(std::string, uniqueIdentifier, UniqueIdentifier);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(std::string, protocol, Protocol);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(std::string, domain, Domain);

      virtual const std::vector<DtVector>& worldPositions() const { throw DtUnimplementedMethod("The const std::vector<DtVector>& worldPositions() const method is unimplemented"); };
      virtual const DtSpotReportStateComponentData& frameState() const { throw DtUnimplementedMethod("The const DtSpotReportStateComponentData& frameState() const method is unimplemented"); };
      virtual void setFrameState(const DtSpotReportStateComponentData&) { throw DtUnimplementedMethod("The void setFrameState(const DtSpotReportStateComponentData&) method is unimplemented"); };
      virtual bool addObservedBy(const makVrv::DtUniqueID& s, double simTime) { throw DtUnimplementedMethod("The bool addObservedBy(const makVrv::DtUniqueID& s, double simTime) const method is unimplemented"); };
      virtual void removeObservedBy(const makVrv::DtUniqueID& s) { throw DtUnimplementedMethod("The removeObservedBy(const makVrv::DtUniqueID& s) const method is unimplemented"); };
      virtual bool observedBy(const makVrv::DtUniqueID& s) const { throw DtUnimplementedMethod("The bool observedBy(const makVrv::DtUniqueID& s) const method is unimplemented"); };
      virtual const std::map<makVrv::DtUniqueID, double>& observedBy() const { throw DtUnimplementedMethod("The const std::map<makVrv::DtUniqueID, double>& observedBy() const method is unimplemented"); };
      virtual const DtSimpleTypedDictionary& dictionary() const { throw DtUnimplementedMethod("The const DtSimpleTypeDictionary& dictionary() const method is unimplemented"); };
      virtual DtSimpleTypedDictionary& dictionary() { throw DtUnimplementedMethod("The const DtSimpleTypeDictionary& dictionary() const method is unimplemented"); };
   };

   class DT_DLL_vrfStateData DtSpotReportStateComponentNextFrame : public DtSpotReportStateComponent
   {
   public:
      DtSpotReportStateComponentNextFrame(DtStateData* storage);

      virtual const DtSimpleTypedDictionary& dictionary() const override;
      virtual DtSimpleTypedDictionary& dictionary() override;

      virtual const std::string displayType() const override;

      virtual const std::string protocol() const override;
      virtual void setProtocol(const std::string&) override;

      virtual const std::string domain() const override;
      virtual void setDomain(const std::string&) override;

      virtual void setWorldPosition(const DtVector&) override;
      virtual const DtVector worldPosition() const override;
      virtual const std::vector<DtVector>& worldPositions() const override;

      virtual void setWorldOrientation(const DtTaitBryan&) override;
      virtual const DtTaitBryan& worldOrientation() const override;

      virtual void setWorldVelocity(const DtVector&) override;
      virtual const DtVector& worldVelocity() const override;

      virtual void setContactUUID(const DtUUID&) override;
      virtual const DtUUID& contactUUID() const override;

      virtual void setIsTDLReport(const bool&) override;
      virtual const bool& isTDLReport() const override;

      virtual void setDateTimeOfReport(const double&) override;
      virtual const double& dateTimeOfReport() const override;

      virtual const std::string& dataHandlerType() const override;
      virtual void setDataHandlerType(const std::string&) override;

      virtual const std::string& visualHandlerType() const override;
      virtual void setVisualHandlerType(const std::string&) override;

      virtual const std::string& uniqueIdentifier() const override;
      virtual void setUniqueIdentifier(const std::string&) override;

      virtual bool addObservedBy(const makVrv::DtUniqueID& s, double simTime) override;
      virtual void removeObservedBy(const makVrv::DtUniqueID& s) override;
      virtual bool observedBy(const makVrv::DtUniqueID& s) const override;
      virtual const std::map<makVrv::DtUniqueID, double>& observedBy() const override;

      virtual const DtSpotReportStateComponentData& frameState() const override { return myData; };
      DtSpotReportStateComponentData& frameState() { markModified(); return myData; };
      virtual void setFrameState(const DtSpotReportStateComponentData&) override;

      virtual const bool& isLocal() const override;
      virtual void setIsLocal(const bool&) override;
   
      virtual const bool& checkForNameReservation() const override;
      virtual void setCheckForNameReservation(const bool&) override;
   
      virtual const DtString& globalId() const override;
      virtual void setGlobalId(const DtString&) override;

      virtual const DtUUID& uuid() const override;
      virtual void setUUID(const DtUUID& u) override;

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

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

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

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

      virtual const unsigned long long userLongLongData() const override;
      virtual void setUserLongLongData(const unsigned long long&) override;

      virtual const DtEntityIdentifier& entityId() const override;
      virtual void setEntityId(const DtEntityIdentifier&) override;
      virtual const DtSimulationAddress simEngineAddress() const override;

      virtual void makeWritable() override;

      virtual void makeReadOnly() override;

   protected:
      DtSpotReportStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtSpotReportStateComponentCurrentFrame : public DtSpotReportStateComponent
   {
   public:
      DtSpotReportStateComponentCurrentFrame(DtStateData* storage);

      virtual const std::string protocol() const override;
      virtual const std::string domain() const override;
      virtual const std::string displayType() const override;
      virtual const DtSimpleTypedDictionary& dictionary() const override;
      virtual const std::string& dataHandlerType() const override;
      virtual const std::string& visualHandlerType() const override;
      virtual const std::string& uniqueIdentifier() const override;
      virtual const DtUUID& contactUUID() const override;
      virtual const double& dateTimeOfReport() const override;
      virtual const bool& isTDLReport() const override;
      virtual const DtVector worldPosition() const override;
      virtual const std::vector<DtVector>& worldPositions() const override;
      virtual const DtTaitBryan& worldOrientation() const override;
      virtual const DtVector& worldVelocity() const override;
      virtual const bool& isLocal() const override;
   
      virtual const bool& checkForNameReservation() const override;
      virtual const DtString& globalId() const override;
      virtual const DtUUID& uuid() const override;
      virtual const DtString& markingText() const override;
      virtual const DtForceType forceType() const override;
      virtual const UInt32 appearanceBits() const override;
      virtual const DtEntityType entityType() const override { return objectType(); };
      virtual const DtEntityType objectType() const override;
      virtual const unsigned long long userLongLongData() const override;
      virtual const DtEntityIdentifier& entityId() const override;
      virtual const DtSimulationAddress simEngineAddress() const override;

      virtual bool observedBy(const makVrv::DtUniqueID& s) const override;
      virtual const std::map<makVrv::DtUniqueID, double>& observedBy() const override;

      virtual const DtSpotReportStateComponentData& frameState() const override { return myData; };
      DtSpotReportStateComponentData& frameState() { return myData; };

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

   protected:
      DtSpotReportStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtSpotReportStateComponentImplementation : public DtDoubleBufferedStateComponent<DtSpotReportStateComponent>
   {
   public:
      DtSpotReportStateComponentImplementation(DtStateData* sd);
      virtual ~DtSpotReportStateComponentImplementation() 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
      {
         if (myNextFrameState.isWritable())
         {
            myCurrentFrameState.advanceFrame(myNextFrameState.frameState());
         }

         myCurrentFrameState.emitComponentUpdated();
      }

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

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

      virtual void convertToLocal() override;
      virtual void convertToRemote() override;

   protected:
      DtSpotReportStateComponentCurrentFrame myCurrentFrameState;
      DtSpotReportStateComponentNextFrame myNextFrameState;
      LOM::WriteEntityRepository myWriteSpotReportStateRepository;
   };

   typedef DtStateComponentCreator<DtSpotReportStateComponentImplementation> DtSpotReportStateComponentCreator;
}