stateData.h

Go to the documentation of this file.

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

//
//
#pragma once


#include "vrfStateData/vrfStateDataDefines.h"
#include <vrfStateData/stateDataTypes.h>
#include "vrfStateData/stateComponent.h"
#include "vrfStateData/stateComponentFactory.h"
#include "vrfStateData/simulatedObjectStateComponent.h"
#include <vrfExtProtocol/objectType.h>
#include <vrfutil/rwUUID.h>
#include <legionDataStore/simulationDatabase.h>
#include <legionDataStore/writeStateInstance.h>
#include <legionDataStore/readStateInstance.h>
#include "legionDataStore/view.h"

#include <vlutil/vlString.h>
#include <vlpi/disEnums.h>
#include <tbb/spin_rw_mutex.h>
#include <tbb/spin_mutex.h>
#include <tbb/mutex.h>
#include <set>
#include <boost/signals2.hpp>

namespace LOM
{
   class WriteEntityRepository;
   class ReadEntityRepository;
}

namespace Legion
{
   class SimulationDatabase;
   class WriteStateInstance;
}

class DtAppearance;
class DtVrfObjectParameters;

namespace makVrf
{
   class DtStateDataManager;
   class DtLaserDesignatorStateComponent;
   class DtIffStateComponent;
   class DtActiveSonarStateComponent;
   class DtTaskVisualizationStateComponent;
   class DtRadioTransmitterStateComponent;
   class DtNavAidRadioTransmitterStateComponent;
   class DtUnderwaterAcousticsStateComponent;
   class DtEmitterSystemStateComponent;
   class DtRadioReceiverStateComponent;
   class DtSimulatedObjectStateComponent;
   class DtLocationStateComponent;
   class DtAisDataStateComponent;
   class DtAircraftLightingStateComponent;
   class DtGroundVehicleLightingStateComponent;

   class DT_DLL_vrfStateData DtExternalFrameStateInterface
   {
   private:
      DtExternalFrameStateInterface(const DtExternalFrameStateInterface&);
      DtExternalFrameStateInterface& operator=(const DtExternalFrameStateInterface&);
      DtExternalFrameStateInterface();

   public:
      DtExternalFrameStateInterface(DtStateData* sd);
      virtual ~DtExternalFrameStateInterface();

      template <typename T_Component>
      bool hasStateComponent() const
      {
         if (hasStateComponentType(T_Component::ComponentType()))
         {
            return (dynamic_cast<const T_Component*>(getStateComponent(T_Component::ComponentType())) != nullptr);
         }

         return false;
      }

      virtual bool hasStateComponentType(DtStateComponent::StateComponentType) const = 0;
      virtual const DtFrameStateInterface* getStateComponent(DtStateComponent::StateComponentType, int index = 0) const = 0;
      virtual void aboutToBeDeleted();

      unsigned long long legionGlobalId() const;
      mutable boost::signals2::signal<void (const DtExternalFrameStateInterface*)> signal_externalFrameStateToBeDestroyed;

   protected:
      friend class DtExternalNextFrameState;

      virtual void removeStateComponent(const DtFrameStateInterface* fc = 0) = 0;
      virtual void addStateComponent(const DtFrameStateInterface* comp) = 0;
      virtual void addStateComponent(DtFrameStateInterface*) { throw DtUnimplementedMethod("The addStateComponent() method is not implemented for this class."); };

      virtual const DtString& markingText() const { throw DtUnimplementedMethod("The const DtString markingText() const is unimplmented for this class."); };

   protected:
      DtStateData* myStateData;
      bool myCleared;
   };

   class DT_DLL_vrfStateData DtExternalNextFrameState : public DtExternalFrameStateInterface
   {
   public:
      DtExternalNextFrameState(DtStateData* sd)
      : DtExternalFrameStateInterface(sd)
      {
      }

      virtual ~DtExternalNextFrameState();

      DtFrameStateInterface* addStateComponent(DtStateComponent::StateComponentType type, const DtVrfObjectParameters* = 0);

      template <typename T_Component>
      T_Component* addStateComponent(bool checkWritable = false, bool isRemote = false);

      void nextFrameRemoveStateComponent(const DtFrameStateInterface* component);

      template <typename T_Component>
      void removeStateComponents();

      template <typename T_Component>
      const T_Component* getStateComponent(int index = 0) const
      {
         DtStateComponent::StateComponentType scType = T_Component::ComponentType();

         const T_Component* comp = dynamic_cast<const T_Component*>(getStateComponent(scType, index));

         if (!comp)
         {
            throw DtUnknownStateComponent(T_Component::StringType());
         }

         return comp;
      }

      template <typename T_Component>
      std::vector<T_Component*> getStateComponentList() const
      {
         DtStateComponent::StateComponentType scType = T_Component::ComponentType();
         std::vector<T_Component*> results;

         if (scType < myFrameState.size())
         {
            std::vector<DtFrameStateInterface*>::const_iterator iter = myFrameState[scType].begin();
            std::vector<DtFrameStateInterface*>::const_iterator end = myFrameState[scType].end();
            while (iter != end)
            {
               results.push_back(dynamic_cast<T_Component*>(*iter));
               ++iter;
            }
         }

         return results;
      }

      const DtFrameStateInterface* getStateComponent(DtStateComponent::StateComponentType scType, int index = 0) const
      {
         if (scType < myFrameState.size())
         {
            if (index < myFrameState[scType].size())
            {
               return myFrameState[scType][index];
            }
         }

         return 0;
      }

      DtFrameStateInterface* getStateComponent(DtStateComponent::StateComponentType scType, int index = 0)
      {
         if (scType < myFrameState.size())
         {
            if (index < myFrameState[scType].size())
            {
               return myFrameState[scType][index];
            }
         }

         return 0;
      }

      bool hasStateComponentType(DtStateComponent::StateComponentType scType) const;
      void addStateComponent(const DtFrameStateInterface* comp);
      void addStateComponent(DtFrameStateInterface* comp);

      template <typename T_Component>
      bool isWritable()
      {
         T_Component* comp = getStateComponent<T_Component>(0, false);

         return (comp && comp->isWritable());
      }

      template <typename T_Component>
      T_Component* getStateComponent(int index = 0, bool checkWritable = true)
      {
         DtStateComponent::StateComponentType scType = T_Component::ComponentType();

         if (scType < myFrameState.size())
         {
            if (index < myFrameState[scType].size())
            {
               DtFrameStateInterface* sc = myFrameState[scType][index];

               if (sc)
               {
                  T_Component* comp = dynamic_cast<T_Component*>(sc);

                  if (comp && (!checkWritable || comp->isWritable()))
                  {
                     return comp;
                  }
                  else
                  {
                     throw DtUnknownStateComponent("This object cannot have state written to it.");
                  }
               }
            }
         }

         throw DtUnknownStateComponent(T_Component::StringType());
      }

      void takeControlOfComponent(DtStateComponent*);

      const DtString& markingText() const;

      int numberOfFrameStates() const
      {
         return myFrameState.size();
      }

   protected:
      friend class DtStateData;

      void removeStateComponent(const DtFrameStateInterface* component);

   protected:
      std::vector<std::vector<DtFrameStateInterface*> > myFrameState;
   };

   class DT_DLL_vrfStateData DtExternalCurrentFrameState : public DtExternalFrameStateInterface
   {
   public:
      DtExternalCurrentFrameState(DtStateData* sd)
      : DtExternalFrameStateInterface(sd)
      {
      }

      virtual ~DtExternalCurrentFrameState();

      bool isValid() const;

      template <typename T_Component>
      const T_Component* getStateComponent(int index = 0) const;

      const DtFrameStateInterface* getStateComponent(DtStateComponent::StateComponentType, int index = 0) const;

      template <typename T_Component>
      std::vector<const T_Component*> getStateComponentList() const
      {
         DtStateComponent::StateComponentType scType = T_Component::ComponentType();
         std::vector<const T_Component*> results;

         if (scType < myFrameState.size())
         {
            std::vector<const DtFrameStateInterface*>::const_iterator iter = myFrameState[scType].begin();
            std::vector<const DtFrameStateInterface*>::const_iterator end = myFrameState[scType].end();
            while (iter != end)
            {
               results.push_back(dynamic_cast<const T_Component*>(*iter));
               ++iter;
            }
         }

         return results;
      }

      void addStateComponent(const DtFrameStateInterface* comp);

      bool hasStateComponentType(DtStateComponent::StateComponentType scType) const;

      const DtString& markingText() const;

      int numberOfFrameStates() const
      {
         return myFrameState.size();
      }

      bool advancedFrame() const;

   protected:
      friend class DtStateData;

      void removeStateComponent(const DtFrameStateInterface* component);

   protected:
      std::vector<std::vector<const DtFrameStateInterface*> > myFrameState;
   };

   class DT_DLL_vrfStateData DtStateData
   {
   public:
      typedef unsigned long long SimStateID;
      enum PublishFlag
      {
         DoNotPublish,
         PublishAll,
         PublishComponentsOnly
      };

   public:

      DtStateData(SimStateID, Legion::SimulationDatabase*, DtStateDataManager*);
      DtStateData(SimStateID, makVrf::UInt64, Legion::SimulationDatabase*, DtStateDataManager*);

      virtual ~DtStateData();

      virtual void invalidate();
      virtual bool isValid() const;
      virtual bool isWritable() const;

      template <typename T_Component>
      int getNextFrameNumberOfLegionComponents()
      {
         if (myWriteStateInstance.isValid())
         {
            return myWriteStateInstance.typeExtensionCount<T_Component>();
         }
         else
         {
            return getCurrentFrameNumberOfLegionComponents<T_Component>();
         }
      }

      template <typename T_Component>
      int getCurrentFrameNumberOfLegionComponents() const
      {
         if (myReadStateInstance && myReadStateInstance->isValid())
         {
            return myReadStateInstance->typeExtensionCount<T_Component>();
         }
         else
         {
            return 0;
         }
      }

      template <typename T_Component>
      unsigned int componentCount() const
      {
         if (myWriteStateInstance.isValid())
         {
            return myWriteStateInstance.typeExtensionCount<T_Component>();
         }
         else if (myReadStateInstance && myReadStateInstance->isValid())
         {
            return myReadStateInstance->typeExtensionCount<T_Component>();
         }

         return 0;
      }

      template <typename T_Component>
      T_Component findNextFrameLegionComponent(int index = 0)
      {
         if (myWriteStateInstance.isValid())
         {
            return myWriteStateInstance.findTypeExtension<T_Component>(std::max(0, index));
         }
         else
         {
            return findCurrentFrameLegionComponent<T_Component>(index);
         }
      }

      template <typename T_Component>
      T_Component findCurrentFrameLegionComponent(int index = 0) const
      {
         if (myReadStateInstance && myReadStateInstance->isValid())
         {
            if (T_Component::isType(myReadStateInstance->instanceHandle()))
            {
               return T_Component(myReadStateInstance->instanceHandle());
            }

            return myReadStateInstance->findTypeExtension<T_Component>(std::max(0, index));
         }
         else
         {
            return T_Component();
         }
      }

      bool advancedFrame() const
      {
         return myAdvancedFrame;
      }

      bool advancingFrame() const
      {
         return myAdvancingFrame;
      }

      DtExternalNextFrameState* nextFrameState()
      {
         return &myNextFrameState;
      }

      const DtExternalCurrentFrameState* currentFrameState() const
      {
         return &myCurrentFrameState;
      }

      virtual DtStateComponent* createStateComponent(DtStateComponent::StateComponentType t);

      template <typename T_Component>
      T_Component* addStateComponent(bool checkWritable = false, bool isRemote = false)
      {
         return myNextFrameState.addStateComponent<T_Component>(checkWritable, isRemote);
      }

      template <typename T_Component>
      bool isWritable()
      {
         return myNextFrameState.isWritable<T_Component>();
      }

      void destroyMainInstance()
      {
         if (myDatabase && myWriteStateInstance.isValid())
         {
            destroyInstance(myWriteStateInstance);
            myWriteStateInstance = Legion::WriteStateInstance();
            delete myReadStateInstance;
            myReadStateInstance = nullptr;
         }
      }

      void destroyInstance(const Legion::WriteStateInstance& wsi)
      {
         tbb::mutex::scoped_lock lock(theCreateInstanceMutex);
         database()->destroyInstance(wsi);
      }

      virtual void createAndInitializeMainInstance();

      template <typename T_Component>
      T_Component createMainInstance()
      {
         tbb::mutex::scoped_lock lock(theCreateInstanceMutex);
         myWriteStateInstance = myDatabase->createInstance<T_Component>();
         lock.release();

         return T_Component(myWriteStateInstance.instanceHandle());
      }

      template <typename T_Component>
      T_Component createUnattachedInstance()
      {
         if (!myWriteStateInstance.isValid())
         {
            throw DtUnknownStateComponent("Cannot create a write Legion component on this object.");
         }
         else if (myDatabase)
         {
            tbb::mutex::scoped_lock lock(theCreateInstanceMutex);
            T_Component comp = myDatabase->createInstance<T_Component>();
            lock.release();

            return comp;
         }

         return T_Component();
      }

      template <typename T_Component>
      T_Component createInstance()
      {
         if (!myWriteStateInstance.isValid())
         {
            throw DtUnknownStateComponent("Cannot create a write Legion component on this object.");
         }
         else if (myDatabase)
         {
            tbb::mutex::scoped_lock lock(theCreateInstanceMutex);
            T_Component comp = myDatabase->createInstance<T_Component>();
            lock.release();

            myWriteStateInstance.addExtension(comp);

            return comp;
         }

         return T_Component();
      }

      template <typename T_Component>
      DtStateComponent* getStateComponent(int index = 0)
      {
         if (T_Component::ComponentType() < myStateComponents.size())
         {
            if (index < myStateComponents[T_Component::ComponentType()].size())
            {
               return myStateComponents[T_Component::ComponentType()][index];
            }
         }

         return 0;
      }

      template <typename T_Component>
      std::vector<T_Component*> getNextFrameStateComponentList() const
      {
         return myNextFrameState.getStateComponentList<T_Component>();
      }

      template <typename T_Component>
      std::vector<const T_Component*> getCurrentFrameStateComponentList() const
      {
         return myCurrentFrameState.getStateComponentList<T_Component>();
      }

      template <typename T_Component>
      bool hasStateComponent(bool checkWritable = false)
      {
         try
         {
            if (nextFrameState()->hasStateComponent<T_Component>())
            {
               if (checkWritable)
               {
                  return (nextFrameStateComponent<T_Component>()->isWritable());
               }

               return true;
            }
            else
            {
               return currentFrameState()->hasStateComponent<T_Component>();
            }
         }
         catch(...)
         {
            return false;
         }

         return false;
      }

      template <typename T_Component>
      const bool hasStateComponent() const
      {
         if (currentFrameState()->hasStateComponent<T_Component>())
         {
            return (dynamic_cast<const T_Component*>(currentFrameState()->getStateComponent<T_Component>()) != nullptr);
         }

         return false;
      }

      template <typename T_Component>
      T_Component* nextFrameStateComponent()
      {
         T_Component* comp = nextFrameState()->getStateComponent<T_Component>(0);
         if (comp && comp->isWritable())
         {
            return comp;
         }
         else
         {
            throw DtUnknownStateComponent("This object cannot have state written to it.");
         }
      }

      template <typename T_Component>
      const T_Component* currentFrameStateComponent() const
      {
         return currentFrameState()->getStateComponent<T_Component>(0);
      }

      virtual const DtFrameStateInterface* currentFrameStateFor(const DtFrameStateInterface*) const;

      void removeComponent(Legion::WriteStateInstance& set);

      bool frozen() const;

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

      void setCheckForNameReservation(bool);
      bool checkForNameReservation() const;

      void setGlobalId(const DtString& s);
      const DtString& globalId() const;

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

      const DtString parentGlobalId() const;
      DtString parentGlobalId();

      const DtUUID& nextFrameHostId() const;
      const DtUUID& currentFrameHostId() const;

      bool isClutterEntity() const;

      void setEntityType(const DtObjectType& type);
      void setObjectType(const DtObjectType& type) { setEntityType(type); };

      DtEntityType entityType() const { return DtEntityType(objectType()); };
      DtObjectType objectType() const;

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

      virtual void setAwaitingTransfer(bool);
      bool awaitingTransfer() const
      {
         return myAwaitingTransfer;
      }

      virtual void initializeParameterData(const DtVrfObjectParameters*);

      virtual bool createPublicData(const DtVrfObjectParameters*, bool isReflectedObject, const DtEntityType& et);

      SimStateID id() const
      {
         return mySimStateID;
      }

      template <typename T_Class>
      void removeInstanceUpdatedCallback(Legion::InstanceHandle instanceHandle, unsigned int callbackHandle);
      template <typename T_Class>
      unsigned int addInstanceUpdatedCallback(DtInstanceUpdatedCallback callback, Legion::InstanceHandle instanceHandle,
         const std::vector<Legion::AttributeIndex>& attributeIndexFilter = std::vector<Legion::AttributeIndex>());

      virtual void advanceFrame();

      virtual void takeControlOfComponent(DtStateComponent*);

      virtual void setCoordinateSystem(const Coordinate_System*);

      void setIsLocal(bool b);
      bool isLocal() const;

      PublishFlag publishFlag() const
      {
         return myPublishFlag;
      }

      bool isPublishedOnNetwork() const
      {
         return ((myPublishFlag == PublishAll) || (myPublishFlag == PublishComponentsOnly));
      }

      DtStateDataManager* stateDataManager()
      {
         return myStateDataManager;
      }

      const DtStateDataManager* stateDataManager() const
      {
         return myStateDataManager;
      }

      double absRealTime() const;

      const Coordinate_System* coordinateSystem() const
      {
         return myCoordinateSystem;
      }
   
      Legion::WriteStateInstance writeStateInstance()
      {
         return myWriteStateInstance;
      }

      Legion::ReadStateInstance* readStateInstance() const
      {
         return myReadStateInstance;
      }
   
      bool convertedToLocal() const
      {
         return myConvertedToLocal;
      }

      UInt64 legionGlobalId() const;

      virtual void clearComponents();

      virtual DtLaserDesignatorStateComponent* addLaserDesignator(bool isRemote = false);
      virtual void removeLaserDesignator(DtLaserDesignatorStateComponent*);

      virtual DtTaskVisualizationStateComponent* lineTaskVisualization(const DtString& visualName, const DtString& component);
      virtual DtTaskVisualizationStateComponent* pointTaskVisualization(const DtString& visualName, const DtString& component);
      virtual DtTaskVisualizationStateComponent* areaTaskVisualization(const DtString& visualName, const DtString& component);
      virtual DtTaskVisualizationStateComponent* textTaskVisualization(const DtString& visualName, const DtString& component);
      virtual void removeTaskVisualization(DtTaskVisualizationStateComponent*);

      virtual DtEmitterSystemStateComponent* addEmitterSystem(bool isRemote = false);
      virtual void removeEmitterSystem(DtEmitterSystemStateComponent*);

      virtual DtActiveSonarStateComponent* addActiveSonarSystem(bool isRemote = false);
      virtual void removeActiveSonarSystem(DtActiveSonarStateComponent*);

      virtual DtRadioTransmitterStateComponent* addRadioTransmitter(bool isRemote = false);
      virtual void removeRadioTransmitter(DtRadioTransmitterStateComponent*);

      virtual DtNavAidRadioTransmitterStateComponent* addNavAidRadioTransmitter(bool isRemote = false);
      virtual void removeNavAidRadioTransmitter(DtNavAidRadioTransmitterStateComponent*);

      virtual DtRadioReceiverStateComponent* addRadioReceiver(bool isRemote = false);
      virtual void removeRadioReceiver(DtRadioReceiverStateComponent*);

      virtual DtIffStateComponent* getOrCreateIffSystem(bool isRemote = false);
      virtual void removeIffSystem();

      virtual DtUnderwaterAcousticsStateComponent* getOrCreateUnderwaterAcousticsSystem(bool isRemote = false);
      virtual void removeUnderwaterAcousticsSystem();

      virtual void removeStateComponent(DtFrameStateInterface*);

      Legion::SimulationDatabase* database()
      {
         return myDatabase;
      }

      virtual void convertToRemote();

      virtual void convertToLocal();

      virtual int indexOfComponent(const DtFrameStateInterface*) const;

      virtual UInt64 instanceHandle(const DtFrameStateInterface*) const;

      virtual void shuttingDown();

      virtual void deletingComponent(DtStateComponent*);

      static void addDefaultPublicDataFor(const std::string& type, const std::string& componentCreator);
      static void removeDefaultPublicDataFor(const std::string& type, const std::string& componentCreator);
      static std::set<std::string> defaultPublicDataFor(DtEntityType defaultEntityType, const std::string& dislpayName, const std::string& parameterType);

      static void addPublicDataFor(const std::string& type, const std::string& componentCreator);
      static void removePublicDataFor(const std::string& type, const std::string& componentCreator);
      static std::set<std::string> additionalPublicDataFor(DtEntityType defaultEntityType, const std::string& dislpayName, const std::string& parameterType);


      static void setDefaultMainComponentFor(const std::string& type, const std::string& defaultPublicData);
      static std::string defaultMainComponentFor(DtEntityType defaultEntityType, const std::string& dislpayName, const std::string& type);

      virtual void aboutToBeDeleted();

      virtual void setPublishingOnLegionNetwork(bool b);
      bool publishingOnLegionNetwork() const
      {
         return myPublishingOnLegionNetwork;
      }

   protected:
      virtual const DtSimulatedObjectStateComponent* currentFrameSimulatedObjectStateComponent() const;
      virtual const DtLocationStateComponent* currentFrameLocationStateComponent() const;
      virtual DtSimulatedObjectStateComponent* nextFrameSimulatedObjectStateComponent();

      virtual DtStateData* currentFrameHostStateData() const;

      virtual bool createMainData(const DtVrfObjectParameters* params, const DtEntityType& et);

      virtual void hostChanged(const DtUUID& oldUUID, const DtUUID& newUUID);
      virtual void setupStateComponent(DtStateComponent*, const DtVrfObjectParameters* params = 0);
      virtual void subordinatesChanged(const std::vector<DtUUID>& oldSubordinates, const std::vector<DtUUID>& newSubordinates);
   
      friend class DtStateDataManager;

      void setPublishFlag(PublishFlag b)
      {
         myPublishFlag = b;
      }

      virtual std::string defaultParameterTypeForEntityType(const DtEntityType&) const;

      virtual void completeRemoteConversion();

      virtual void hostWasDeleted();

   protected:
      friend class DtExternalNextFrameState;

      virtual void removeStateComponent(DtStateComponent::StateComponentType t);
      virtual void uuidChanged(const DtUUID& oldUUID, const DtUUID& newUUID);
      virtual void markingTextChanged(const DtString& oldUUID, const DtString& newUUID);

   public:
      mutable boost::signals2::signal<void (const DtStateData*)> signal_firstFrameAdvance;

      boost::signals2::signal<void(const DtUUID&, const DtUUID&, SimStateID)> signal_uuidChanged;
      boost::signals2::signal<void(const DtString&, const DtString&, const DtUUID&, SimStateID)> signal_markingTextChanged;

      boost::signals2::signal<void (const DtStateData*, const DtUUID& oldUUID, const DtUUID& newUUID)> signal_hostChanged;

      mutable boost::signals2::signal<void (const DtStateData*)> signal_stateDataToBeDestroyed;
      boost::signals2::signal<void (SimStateID)> signal_preFrameAdvanced;

      mutable boost::signals2::signal<void (const DtStateData*)> signal_frameAdvanced;

      boost::signals2::signal<void (const DtStateData*)> signal_modified;

      boost::signals2::signal<void (DtStateData*)> signal_convertingToRemote;
      boost::signals2::signal<void (DtStateData*)> signal_convertedToRemote;

      boost::signals2::signal<void (DtStateData*)> signal_convertingToLocal;
      boost::signals2::signal<void (DtStateData*)> signal_convertedToLocal;

      boost::signals2::signal<void (const DtStateData*, const std::vector<DtUUID>& added, const std::vector<DtUUID>& removed)> signal_subordinatesChanged;

   protected:
      DtExternalNextFrameState myNextFrameState;
      DtExternalCurrentFrameState myCurrentFrameState;

      DtStateDataManager* myStateDataManager;
      Legion::SimulationDatabase* myDatabase;

      Legion::WriteStateInstance myWriteStateInstance;
      Legion::ReadStateInstance* myReadStateInstance;

      SimStateID mySimStateID;
   
      PublishFlag myPublishFlag;

      const Coordinate_System* myCoordinateSystem;

      int mySessionId;

      std::vector<std::vector<DtStateComponent*> > myStateComponents;
      std::vector<std::vector<DtStateComponent*> >  myCreatedStateComponents;
      std::set<DtFrameStateInterface*> myRemoveStateComponents;

      bool myAdvancedFrame;
      bool myConvertToRemote;
      bool myAwaitingTransfer;

      UInt64 myLegionGlobalId;
      std::atomic<unsigned int> myComponentNumber;

      boost::signals2::scoped_connection mySubordinatesChangedConnection;
      boost::signals2::scoped_connection myHostChangedConnection;
      boost::signals2::scoped_connection myUUIDChangedConnection;
      boost::signals2::scoped_connection myMarkingTextChangedConnection;
      mutable boost::signals2::scoped_connection myHostWasDeletedConnection;

      typedef std::map<std::string, std::set<std::string> > PublicData;
      static PublicData theDefaultPublicData;
      static PublicData theAdditionalPublicData;

      typedef std::map<std::string, std::string> DefaultMainComponentMap;
      static DefaultMainComponentMap theDefaultMainComponentMap;
      bool myCleared;

      const DtVrfObjectParameters* myParameters;
      bool myPublishingOnLegionNetwork;
      bool myMainComponentOnLegion;

      const DtSimulatedObjectStateComponent* myCurrentFrameSimulatedObjectStateComponent;
      const DtLocationStateComponent* myCurrentFrameLocationStateComponent;
      const DtLocationStateComponent*  myNextFrameLocationStateComponent = nullptr;
      DtSimulatedObjectStateComponent* myNextFrameSimulatedObjectStateComponent;
      mutable DtStateData* myCurrentFrameHostStateData;
      mutable tbb::spin_rw_mutex myCurrentFrameHostStateDataMutex;
      static tbb::mutex theCreateInstanceMutex;

      bool myAdvancingFrame = false;
      bool myConvertedToLocal = false;
   };
}

#include <vrfStateData/stateData.inl>