entityStateComponent.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/stateData.h"
#include <vlpi/disEnums.h>
#include <legionStandardOM/sets/writeEntityRepository.hpp>
#include "legionStandardOM/sets/readEntityRepository.hpp"
#include "legionDataStore/view.h"
#include <tbb/spin_mutex.h>

namespace LOM
{
   class ReadEntityRepository;
}

class DtAppearance;

namespace makVrf
{
   struct DT_DLL_vrfStateData DtEntityStateComponentData
   {
      using SimStateID = unsigned long long;

      DtEntityStateComponentData()
      : myUUID(DtUUID::nullUUID())
      , myIsLocal(false)
      , myCheckForNameReservation(true)
      {};

      DtEntityStateComponentData(const DtEntityStateComponentData& orig)
      : myGlobalId(orig.myGlobalId)
      , myUUID(orig.myUUID)
      , myMarkingText(orig.myMarkingText)
      , myCallsign(orig.myCallsign)
      , myEntityId(orig.myEntityId)
      , myIsLocal(orig.myIsLocal)
      , myUserData(orig.myUserData)
      , myOrbatId(orig.myOrbatId)
      , myCheckForNameReservation(orig.myCheckForNameReservation)
      , mySimEngineAddress(orig.mySimEngineAddress)
      {
      }

      DtEntityStateComponentData& operator=(const DtEntityStateComponentData& rhs)
      {
         myGlobalId = rhs.myGlobalId;
         myUUID = rhs.myUUID;
         myEntityId = rhs.myEntityId;
         myMarkingText = rhs.myMarkingText;
         myCallsign = rhs.myCallsign;
         myIsLocal = rhs.myIsLocal;
         myOrbatId = rhs.myOrbatId;
         myUserData = rhs.myUserData;
         mySimEngineAddress = rhs.mySimEngineAddress;
         myCheckForNameReservation = rhs.myCheckForNameReservation;

         return *this;
      }

      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(DtString, callsign, Callsign)
      DEFINE_ACCESSOR_MUTATOR(bool, isLocal, IsLocal)
      DEFINE_ACCESSOR_MUTATOR(unsigned long long, userData, UserData)
      DEFINE_ACCESSOR_MUTATOR(unsigned long long, orbatId, OrbatId)
      DEFINE_ACCESSOR_MUTATOR(bool, checkForNameReservation, CheckForNameReservation)
      DEFINE_ACCESSOR_MUTATOR(DtSimulationAddress, simEngineAddress, SimEngineAddress)

   protected:
      DtString myGlobalId;
      DtString myMarkingText;
      DtString myCallsign;
      DtEntityIdentifier myEntityId;
      DtUUID myUUID;
      bool myIsLocal;
      unsigned long long myUserData = 0;
      unsigned long long myOrbatId = 0;
      bool myCheckForNameReservation;
      DtSimulationAddress mySimEngineAddress;
   };

   class DT_DLL_vrfStateData DtEntityStateComponent : public DtSimulatedObjectStateComponent
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::EntityStateComponent)

      DtEntityStateComponent(DtStateData* storage)
      : DtSimulatedObjectStateComponent(storage)
      , myUUIDColumn(0xFFFFFFFF)
      , myIsClutterEntityColumn(0xFFFFFFFF)
      {
      }

      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, isClutterEntity, IsClutterEntity)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(UInt32, capabilities, Capabilities)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtEntityType, guise, Guise)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtUUID, superior, Superior)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtString, callsign, Callsign)

      virtual const std::set<DtUUID> attachments() const { throw DtUnimplementedMethod("std::set<DtUUID> attachments() is not implemented for this class."); };
      virtual void setEntityType(const DtEntityType& ot) override { throw DtUnimplementedMethod("void setEntityType(const DtEntityType& ot) is not implemented for this class."); };
      virtual void addAttachment(const DtUUID&) { throw DtUnimplementedMethod("void addAttachment(const DtUUID&) is not implemented for this class."); };
      virtual void removeAttachment(const DtUUID&) { throw DtUnimplementedMethod("void removeAttachment(const DtUUID&) is not implemented for this class."); };

      mutable boost::signals2::signal<void (int oldState, int newState, makVrf::SimStateID)> signal_damageStateChanged;
      mutable boost::signals2::signal<void (const DtFrameStateInterface*)> signal_attachmentsChanged;
      mutable boost::signals2::signal<void(const DtUUID& oldSuperior, const DtUUID& newSuperior)> signal_superiorChanged;
      mutable boost::signals2::signal<void(bool oldIsClutter, bool newIsClutter)> signal_isClutterChanged;
      mutable boost::signals2::signal<void(const DtString&, const DtString&, makVrf::SimStateID)> signal_callsignChanged;

   protected:
      UInt32 myUUIDColumn;
      UInt32 myIsClutterEntityColumn;
   };

   template <typename T_BaseComponent>
   class DtEntityStateComponentNextFrameTemplate : public T_BaseComponent
   {
   public:
      DtEntityStateComponentNextFrameTemplate(DtStateData*);
      virtual ~DtEntityStateComponentNextFrameTemplate();

      const DtEntityStateComponentData& frameState() const { return this->myData; };
      DtEntityStateComponentData& frameState() { return this->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 bool isClutterEntity() const;
      void setIsClutterEntity(const bool&);

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

      const DtString& callsign() const;
      void setCallsign(const DtString&);

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

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

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

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

      const UInt32 capabilities() const;
      void setCapabilities(const UInt32&);

      const DtEntityType guise() const;
      void setGuise(const DtEntityType&);

      const DtUUID& superior() const;
      void setSuperior(const DtUUID&);

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

      const unsigned long long orbatId() const;
      void setOrbatId(const unsigned long long&);

      const DtSimulationAddress simEngineAddress() const override;
      void setSimEngineAddress(const DtSimulationAddress&) override;

      virtual void setAppearance(const DtAppearance& app);

      virtual void makeWritable();

      virtual void makeReadOnly();

   protected:
      LOM::WriteEntityRepository myWriteEntityStateRepository;
      DtUUID mySuperior;
      mutable DtEntityStateComponentData myData;
   };

   using DtEntityStateComponentNextFrame = DtEntityStateComponentNextFrameTemplate<DtEntityStateComponent>;

   template <typename T_BaseComponent>
   class DtEntityStateComponentCurrentFrameTemplate : public T_BaseComponent
   {
   public:
      DtEntityStateComponentCurrentFrameTemplate(DtStateData*);
      virtual ~DtEntityStateComponentCurrentFrameTemplate();

      const DtEntityStateComponentData& frameState() const { return this->myData; };
   
      const bool& isLocal() const;
      const bool& checkForNameReservation() const;
      const DtString& globalId() const;
      const DtUUID& uuid() const;
      const DtString& markingText() const;
      const DtString& callsign() const;
      const DtForceType forceType() const;
      const DtEntityType entityType() const { return DtEntityType(objectType()); };
      const DtEntityType objectType() const;
      const DtEntityIdentifier& entityId() const;
      const UInt32 appearanceBits() const;
      const bool isClutterEntity() const;
      const UInt32 capabilities() const;
      const DtEntityType guise() const;
      const unsigned long long userLongLongData() const;
      const unsigned long long orbatId() const;
      const DtSimulationAddress simEngineAddress() const override;

      const DtUUID& superior() const;

      void addAttachment(const DtUUID&);
      void removeAttachment(const DtUUID&);
      const std::set<DtUUID> attachments() const;

      bool checkForUpdatedItems();

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

      bool checkEntityIdChanged();
      bool checkUUIDChanged();
      bool checkForceChanged();
      bool checkMarkingTextChanged();
      bool checkDamageStateChanged();
      bool checkIsClutterChanged();

      void handleDataUpdated(const std::vector<UInt32>& attributesUpdated);
      void completeSetup();

      friend class DtEntityStateComponentImplementation;
      void advanceFrame(const DtEntityStateComponentData& data)
      {
         this->myData = data;
      }

   protected:
      friend class DtStateDataManager;
      void setSuperior(const DtUUID&);

   protected:
      LOM::ReadEntityRepository myReadEntityStateRepository;
      DtUUID mySuperior;
      int myForceId;
      std::string myMarkingText;
      int myDamageState;
      unsigned int myCallbackHandle;
      bool myIsClutterEntity;

      std::set<DtUUID> myAttachments;
      mutable tbb::spin_rw_mutex myAttachmentsMutex;
      boost::signals2::scoped_connection myCompleteSetupConnection;
      tbb::spin_mutex myCompleteSetupMutex;
      DtEntityStateComponentData myData;
   };

   using DtEntityStateComponentCurrentFrame = DtEntityStateComponentCurrentFrameTemplate<DtEntityStateComponent>;

   class DT_DLL_vrfStateData DtEntityStateComponentImplementation : public DtDoubleBufferedStateComponent<DtEntityStateComponent>
   {
   public:
      DtEntityStateComponentImplementation(DtStateData* sd);
      virtual ~DtEntityStateComponentImplementation() 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);
      }

      static void addAdditionalTableColumns(Legion::SimulationDatabase*);

      virtual void initializeFromParameters(const DtVrfObjectParameters* params) override;

      virtual Legion::WriteStateInstance writeStateInstance() override { return myWriteEntityStateRepository; };

      virtual void convertToRemote() override;

      virtual void convertToLocal() override;

      virtual void addAdditionalStateComponents() override;

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

   protected:
      DtEntityStateComponentCurrentFrame myCurrentFrameState;
      DtEntityStateComponentNextFrame myNextFrameState;
      LOM::WriteEntityRepository myWriteEntityStateRepository;
   };

   typedef DtStateComponentCreator<DtEntityStateComponentImplementation> DtEntityStateComponentCreator;
}

#define _ENTITY_STATE_COMPONENT 1
#include "vrfStateData/entityStateComponent.inl"