stateDataWrapper.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/vrfStateDataDefines.h"
#include "vrfStateData/stateData.h"
#include <vrfStateData/vrfGeometryStateComponent.h>
#include <vrfStateData/vrfStateComponent.h>
#include <vrfStateData/locationStateComponent.h>
#include <vrfStateData/entityStateComponent.h>
#include <vrfStateData/statePropertiesStateComponent.h>
#include <boost/signals2.hpp>
#include <matrix/vlVector.h>
#include <geometry/extent.h>
#include <vrfutil/rwUUID.h>
#include <vlpi/appearance.h>
#include <vlpi/disEnums.h>
#include <matrix/vlDcm.h>
#include <matrix/vlTaitBryan.h>
#include <map>
#include <list>
#include <tbb/spin_rw_mutex.h>

class DtRwProperties;

namespace makVrf
{
   class DtIffStateComponent;
   class DtLaserDesignatorStateComponent;
   class DtExternalCurrentFrameState;
   class DtStatePropertiesStateComponent;
   class DtStateData;
   class DtStateDataManager;
   class DtVrfObjectGeometry;
   class DtRwVrfKinematicState;

   class DT_DLL_vrfStateData DtStateDataWrapper
   {
   private:
      DtStateDataWrapper(const DtStateDataWrapper&);

   public:
      DtStateDataWrapper();
      explicit DtStateDataWrapper(const DtStateDataManager* simManager, const DtUUID& uuid);
      explicit DtStateDataWrapper(const DtStateDataManager* simManager, const DtEntityIdentifier& id);
      explicit DtStateDataWrapper(const DtStateDataManager* simManager, const DtExternalCurrentFrameState*);
      explicit DtStateDataWrapper(const DtStateData* sd);

      virtual ~DtStateDataWrapper();

      DtStateDataWrapper& operator=(const DtUUID&);
      DtStateDataWrapper& operator=(const DtStateDataWrapper& rhs) { return operator=(rhs.uuid()); };

      bool operator==(const DtUUID& rhs) const;
      bool operator==(const DtStateDataWrapper& rhs) const { return (*this == rhs.uuid()); };

      bool operator!=(const DtUUID& rhs) const { return !(*this == rhs); };
      bool operator!=(const DtStateDataWrapper& rhs) const { return !(*this == rhs); };

      const DtUUID& uuid() const;
      const DtString& objectName() const;
      DtString label() const;
      DtEntityType entityType() const;
      DtEntityType objectType() const { return entityType(); };
      unsigned long long userData() const;
      const DtString& extendedData(const DtString& key) const;
      std::map<DtString, DtString> extendedDataMap() const;
      std::map<std::string, std::string> extendedDataStdStringMap() const;
      bool hasExtendedData(const DtString& key) const;
      DtString overlay() const;
      DtAppearance appearance() const;
      int capabilities() const;
      DtEntityType guise() const;
      const DtRwProperties& stateProperties() const;

      bool isClutterEntity() const;

      DtVrfObjectGeometry objectGeometry() const;
      virtual Dt3dBoundingVolume boundingVolume() const;

      const DtIffStateComponent* iffStateComponent() const;
      std::vector<const DtLaserDesignatorStateComponent*> laserDesignatorStateComponents() const;

      DtString awaiting() const
      {
         return myAwaiting;
      }

      bool isSpotReport() const;
      bool isTDLReport() const;

      bool awaitingTransfer() const;

      bool isModified() const
      {
         if (myExternalCurrentFrameState)
         {
            return static_cast<const DtExternalCurrentFrameState*>(myExternalCurrentFrameState)->isModified();
         }

         return false;
      }

      template <typename T_Component>
      const T_Component* getStateComponent() const
      {
         if (myExternalCurrentFrameState)
         {
            return myExternalCurrentFrameState->getStateComponent<T_Component>();
         }

         return nullptr;
      }

      template <typename T_Component>
      std::vector<const T_Component*> getStateComponentList() const
      {
         if (myExternalCurrentFrameState)
         {
            return myExternalCurrentFrameState->getStateComponentList<T_Component>();
         }

         return std::vector<const T_Component*>();
      }

      template <typename T_Component>
      bool hasStateComponent() const
      {
         if (myExternalCurrentFrameState)
         {
            return myExternalCurrentFrameState->hasStateComponent<T_Component>();
         }

         return false;
      }

      DtRwVrfKinematicState kinematicState() const;

      const DtVector& worldPosition() const;
      const DtVector& localPosition() const;
      const DtVector& parentPosition() const;
      double distSquaredTo(const DtVector&) const;

      bool hasLocationChanged() const;

      bool objectVerticesChanged() const;

      bool worldVerticesChanged() const;

      bool haveVerticesChanged() const;

      virtual void frameAdvanced();
      virtual void firstFrameAdvance();

      const DtStateData* stateData() const
      {
         return myStateData;
      }

      DtUUID hostGlobalId() const;
      DtString parentGlobalId() const;

      const DtTaitBryan& topographicOrientation() const;
      const DtTaitBryan&  worldOrientation() const;
      const DtTaitBryan&  localOrientation() const;
      const DtTaitBryan&  parentOrientation() const;
      const DtTaitBryan&  localOrientationWrtDatabase() const;
      const DtDcm& localOrientationMatrix() const;
      const DtDcm& parentOrientationMatrix() const;
      const DtDcm& worldOrientationMatrix() const;
      double heading() const;
      double pitch() const;
      double roll() const;

      DtForceType forceType() const;

      const DtEntityIdentifier& entityId() const;
      const DtEntityIdentifier& objectIdentifier() const
      {
         return entityId();
      }

      DtSimulationAddress simEngineAddress() const;

      bool isDestroyed() const;
      int damageState() const;

      const DtString& globalId() const;

      bool isUnit() const;

      bool isEntityOrUnit() const;
      bool isSimulatedObject() const { return isEntityOrUnit(); };

      bool isEntity() const;

      bool isEmbarked() const;

      DtUUID embarkedOn() const;
      bool isEmbarkedOn(const DtUUID&) const;

      bool isValid() const;
   
      int sessionId() const;
      bool isVrfSimulatedObject() const;
      bool isCurrentlyTasked() const;
      bool isExecutingPlan() const;
      bool hasPlan() const;
      bool independentlyTasked() const;
      bool underFire() const;
      DtString rulesOfEngagement() const;

      DtEchelonId echelonId() const;

      bool isDeleted() const;

      virtual void makeInvalid();

      const DtLocalVertexList& localVertices() const;
      std::vector<DtVector> localVertexList() const;

      const DtVertexList& worldVertices() const;
      std::vector<DtVector> worldVertexList() const;

      const DtLocalVertexList& relativeVertices() const;
      std::vector<DtVector> relativeVertexList() const;

      unsigned long long legionGlobalId() const;

      bool advancedFrame() const
      {
         return myAdvancedFrame;
      }

      DtUUID superiorUUID() const;

      bool isTopLevel() const;

      inline const DtExternalFrameStateInterface* externalCurrentFrameState() const
      {
         return myExternalCurrentFrameState;
      }

   public:
      boost::signals2::signal<void ()> signal_objectVerticesChanged;

      mutable boost::signals2::signal<void ()> signal_extendedDataUpdated;

      mutable boost::signals2::signal<void ()> signal_simObjectDeleted;

      mutable boost::signals2::signal<void (const DtString&)> signal_discoveredReference;

      mutable boost::signals2::signal<void (const DtUUID& oldUUID, const DtUUID& newUUID)> signal_uuidChanged;

      mutable boost::signals2::signal<void (const DtSimulationAddress& oldAddr, const DtSimulationAddress& newAddr)> signal_simEngineAddressChanged;

      mutable boost::signals2::signal<void (const DtString& oldName, const DtString& newName)> signal_objectRenamed;

      mutable boost::signals2::signal<void (const DtUUID& oldSuperior, const DtUUID& newSuperior)> signal_superiorChanged;

      mutable boost::signals2::signal<void()> signal_isClutterChanged;

      mutable boost::signals2::signal<void (DtStateComponent*)> signal_stateComponentAdded;
      mutable boost::signals2::signal<void (DtStateComponent*)> signal_stateComponentRemoved;

      mutable boost::signals2::signal<void ()> signal_advancedFrame;

      boost::signals2::signal<void ()> signal_firstFrameAdvance;

   public:
      inline const DtSimulatedObjectStateComponent* currentFrameSimulatedObjectStateComponent() const
      {
         if (myCurrentFrameSimulatedObjectStateComponent)
         {
            return myCurrentFrameSimulatedObjectStateComponent;
         }
         else if (!myCachedComponents && hasStateComponent<DtSimulatedObjectStateComponent>())
         {
            return getStateComponent<DtSimulatedObjectStateComponent>();
         }
         else
         {
            return nullptr;
         }
      }

      inline const DtLocationStateComponent* currentFrameLocationStateComponent() const
      {
         if (myCurrentFrameLocationStateComponent)
         {
            return myCurrentFrameLocationStateComponent;
         }
         else if (!myCachedComponents && hasStateComponent<DtLocationStateComponent>())
         {
            return getStateComponent<DtLocationStateComponent>();
         }
         else
         {
            return nullptr;
         }
      }

      inline const DtStatePropertiesStateComponent* currentFrameStatePropertiesStateComponent() const
      {
         if (myCurrentFrameStatePropertiesStateComponent)
         {
            return myCurrentFrameStatePropertiesStateComponent;
         }
         else if (!myCachedComponents && hasStateComponent<DtStatePropertiesStateComponent>())
         {
            return getStateComponent<DtStatePropertiesStateComponent>();
         }
         else
         {
            return nullptr;
         }
      }

      inline const DtVrfGeometryStateComponent* currentFrameVrfGeometryStateComponent() const
      {
         if (myCurrentFrameVrfGeometryStateComponent)
         {
            return myCurrentFrameVrfGeometryStateComponent;
         }
         else if (!myCachedComponents && hasStateComponent<DtVrfGeometryStateComponent>())
         {
            return getStateComponent<DtVrfGeometryStateComponent>();
         }
         else
         {
            return nullptr;
         }
      }

      inline const DtEntityStateComponent* currentFrameEntityStateComponent() const
      {
         return myCurrentFrameEntityStateComponent;
      }

      inline const DtVrfStateComponent* currentFrameVrfStateComponent() const
      {
         if (myCurrentFrameVrfStateComponent)
         {
            return myCurrentFrameVrfStateComponent;
         }
         else if (!myCachedComponents && hasStateComponent<DtVrfStateComponent>())
         {
            return getStateComponent<DtVrfStateComponent>();
         }
         else
         {
            return nullptr;
         }
      }

      std::set<int> currentFrameModifiedStateComponentTypes() const;
      std::set<int> nextFrameModifiedStateComponentTypes() const;

   protected:
      virtual const DtStateData* stateDataFor(const DtUUID& uuid) const;
      virtual void cacheComponents();
      virtual void clearCachedComponents();

      virtual void stateDataAdded(DtStateData*);
      virtual void setUUID(const DtUUID&);
      bool checkAndConnectForVrfStateComponent();

      void uuidChanged(const DtUUID&, const DtUUID&);
      virtual void objectNameChanged(const DtString& oldText, const DtString& newText);

      virtual void completeSetup();
      virtual void extendedDataUpdated();
      virtual void superiorChanged();
      virtual void isClutterChanged();

      virtual void externalFrameStateToBeDestroyed();
      virtual void slot_stateComponentAdded(DtStateComponent*);
      virtual void slot_stateComponentRemoved(DtStateComponent*);
      virtual void simEngineAddressChanged(const DtSimulationAddress& oldAddress, const DtSimulationAddress& newAddress);

   protected:
      const DtExternalFrameStateInterface* myExternalCurrentFrameState;

      boost::signals2::scoped_connection myStateComponentAddedConnection;
      boost::signals2::scoped_connection myStateComponentRemovedConnection;
      boost::signals2::scoped_connection myDeletedConnection;
      boost::signals2::scoped_connection myAddedConnection;
      boost::signals2::scoped_connection myUUIDChangedConnection;
      boost::signals2::scoped_connection myObjectNameChangedConnection;
      boost::signals2::scoped_connection myExtendedDataUpdatedConnection;
      boost::signals2::scoped_connection myFirstFrameAdvancedConnection;
      boost::signals2::scoped_connection mySuperiorChangedConnection;
      boost::signals2::scoped_connection myAdvancedFrameConnection;
      boost::signals2::scoped_connection myIsClutterChangedConnection;
      boost::signals2::scoped_connection mySimEngineAddressChangedConnection;
      
      DtString myAwaiting;

      DtUUID myUUID;
      unsigned long long myLegionGlobalId;

      bool myIsDeleted;

      mutable DtString myObjectName;
      mutable DtEntityType myEntityType;

      DtUUID mySuperiorUUID;
      bool myAdvancedFrame;

      mutable tbb::spin_rw_mutex myExternalCurrentFrameStateMutex;

      DtUUID myEmbarkedOn;

      const DtSimulatedObjectStateComponent* myCurrentFrameSimulatedObjectStateComponent;
      const DtVrfStateComponent* myCurrentFrameVrfStateComponent;
      const DtEntityStateComponent* myCurrentFrameEntityStateComponent;
      const DtLocationStateComponent* myCurrentFrameLocationStateComponent;
      const DtVrfGeometryStateComponent* myCurrentFrameVrfGeometryStateComponent;
      const DtStatePropertiesStateComponent* myCurrentFrameStatePropertiesStateComponent;

      bool myCachedComponents;

      const DtStateData* myStateData = nullptr;

   protected:
      const DtStateDataManager* myStateDataManager;
   };
}