vrfDataProcessorInterface.h

Go to the documentation of this file.

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

#pragma once

#include <vrfGuiNetworkCommon/vrfGuiNetworkCommonDefines.h>
#include <vrfStateData/stateData.h>
#include <vrfutil/vrfCallbackQueue.h>
#include <legionDataStore/dataTypes.h>
#include <vrvCore/DtSimDataProcessorInterface.h>
#include <vrvCore/DtSimEntryUpdater.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtBalancedUpdater.h>
#include <vlutil/vlPerformanceStats.h>
#include <boost/signals2.hpp>
#include <boost/unordered_set.hpp>
#include <tbb/spin_rw_mutex.h>
#include <tbb/spin_mutex.h>
#include <map>

namespace makVrv
{
   class DtSimEntryObjectAgent;
   class DtSimStateObjectAgent;
   class DtBaseConnection;
}

namespace makVrf
{
   class DtStateComponent;
   class DtSimDataProcessorManager;

   class DT_DLL_vrfGuiNetworkCommon DtVrfSimDataProcessorInterface : public makVrv::DtSimDataProcessorInterface
   {
   public:
      virtual const char* processorName() const = 0;
      virtual makVrv::DtUniqueID vantageIdFromLegionId(Legion::UInt64 lid) const = 0;

   protected:
      virtual const makVrv::DtSimState& emptyState() const = 0;

      static void AddEntry(makVrv::DtSimEntryObjectAgent*, makVrv::DtUniqueID);
      static void RemoveEntry(makVrv::DtSimEntryObjectAgent*, makVrv::DtUniqueID);

   protected:
      static tbb::spin_mutex theEntryMapMutex;
      static std::map<makVrv::DtUniqueID, int> theEntryMap;
   };

   class DT_DLL_vrfGuiNetworkCommon DtVrfDataProcessorInterface : public virtual DtVrfSimDataProcessorInterface
   {
   public:
      virtual void setState(const DtStateData*, makVrv::DtSimState&) = 0;
      virtual void createAndSendState(DtStateData*, makVrv::DtSimStateObjectAgent&, bool force = false) = 0;
      virtual void slot_postUpdateCallback(const DtStateData*) = 0;
   };

   template <typename T_Agent>
   class DtVrfDataProcessor : public virtual DtVrfDataProcessorInterface
   {
   public:

      DtVrfDataProcessor(DtStateDataManager*, makVrv::DtBaseConnection&);

      virtual ~DtVrfDataProcessor();

      virtual void setObjectUpdateRate(makVrv::DtUniqueID uniqueId, makVrv::DtSimEntryUpdater::UpdateRate rate);
      virtual void forceObjectUpdate(makVrv::DtUniqueID);

      virtual void queueDataDiscovered(DtStateData* sd);
      virtual void queueRemoveData(const DtStateData*);

      virtual bool dataDiscovered(DtStateData* sd);
      virtual void removeData(Legion::UInt64 legionGlobalId);
      virtual void componentUpdated(const DtFrameStateInterface*);

      virtual void queueFunction(const boost::function<void ()>& function);

   protected:
      virtual void slot_frameAdvanced();

      virtual bool shouldForceObjectUpdate(const DtFrameStateInterface*) const;

      virtual makVrv::DtUniqueID vantageIdFromLegionId(Legion::UInt64) const;

      virtual void addSimData(DtStateData* sd);

      virtual void vantageIdMapped(makVrv::DtUniqueID, Legion::UInt64);

      virtual void setDiscoverBackgroundEntities(bool);

      DtSimDataProcessorManager* simDataProcessorManager();

      DtStateDataManager* stateDataManager();

      //A Listener and a driver which will be updated with it.
      class StateDataUpdater
      {
      public:

         StateDataUpdater(DtStateData* listener,
            UInt64 legionGlobalId,
            makVrv::DtSimStateObjectAgent& driver,
            DtVrfDataProcessor<T_Agent>& iface)
         : myStateData(listener)
         , myObjectAgent(&driver)
         , myDataProcessorInterface(&iface)
         , myLegionGlobalId(legionGlobalId)
         {
         }

         StateDataUpdater(const StateDataUpdater& orig)
         : myStateData(orig.myStateData)
         , myObjectAgent(orig.myObjectAgent)
         , myDataProcessorInterface(orig.myDataProcessorInterface)
         , myLegionGlobalId(orig.myLegionGlobalId)
         {
         }

         StateDataUpdater& operator=(const StateDataUpdater& orig)
         {
            myStateData = orig.myStateData;
            myObjectAgent = orig.myObjectAgent;
            myDataProcessorInterface = orig.myDataProcessorInterface;
            myLegionGlobalId = orig.myLegionGlobalId;

            return *this;
         }

         //Are the updaters equal
         bool operator==(const StateDataUpdater& orig) const
         {
            return ((myLegionGlobalId == orig.myLegionGlobalId) &&
               (myObjectAgent == orig.myObjectAgent));
         }

         void update(double);

         Legion::UInt64 legionGlobalId() const
         {
            return myLegionGlobalId;
         }

      protected:
         DtStateData* myStateData;
         makVrv::DtSimStateObjectAgent* myObjectAgent;
         DtVrfDataProcessor<T_Agent>* myDataProcessorInterface;
         Legion::UInt64 myLegionGlobalId;
      };

      virtual void dataDiscoveredByLegionId(Legion::UInt64 lid);
      virtual void dataRemovedByLegionId(Legion::UInt64 lid);

   protected:
      std::set<makVrv::DtUniqueID> myUpdated;

      DtStateDataManager* myStateDataManager;
      makVrv::DtSignalConnectionManager myConnectionManager;
      makVrv::DtBaseConnection& mySimulation;

      DtTimedSection myTimer;
      makVrv::DtSimEntryObjectAgent* mySimEntryAgent;

      typedef makVrv::DtBalancedUpdater<StateDataUpdater> UpdaterGroup;
      typedef std::map<makVrv::DtSimEntryUpdater::UpdateRate, UpdaterGroup> UpdateGroupMap;                  

      UpdateGroupMap myRefreshRateGroups;

      typedef std::set<makVrv::DtUniqueID> EntityIdList;
      EntityIdList myForceUpdateList;
    
      struct SimDataInstance
      {
         SimDataInstance() : myStateData(0), myLegionGlobalId(0), myAgent(0), myRate(makVrv::DtSimEntryUpdater::NoUpdates) {};

         DtStateData* myStateData;
         UInt64 myLegionGlobalId;
         makVrv::DtSimStateObjectAgent* myAgent;
         makVrv::DtSimEntryUpdater::UpdateRate myRate;
      };

      typedef std::map<makVrv::DtUniqueID, SimDataInstance> AgentMap;
      AgentMap myAgents;

      boost::signals2::connection myVantageToLegionIdMapperConnection;

      std::set<makVrv::DtUniqueID> myAwaitingValidId;
      DtSimDataProcessorManager* mySimDataProcessorManager;
      bool myDiscoverBackgroundEntities;
      tbb::spin_rw_mutex myMutex;
   };
}