vrfComponentProcessorInterface.h

Go to the documentation of this file.

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

#pragma once

#include <vrfGuiNetworkCommon/vrfDataProcessorInterface.h>
#include <tbb/spin_rw_mutex.h>

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

namespace makVrf
{
   class DtSimDataProcessorManager;
   class DtStateComponent;

   class DT_DLL_vrfGuiNetworkCommon DtComponentProcessorInterface : public DtVrfSimDataProcessorInterface
   {
   public:
      virtual void createAndSendState(const std::set<const DtFrameStateInterface*>&, makVrv::DtSimStateObjectAgent&,
         bool force = false) = 0;
   };

   template <typename T_Agent, typename T_Component>
   class DtVrfComponentProcessor : public virtual DtComponentProcessorInterface
   {
   public:

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

      virtual ~DtVrfComponentProcessor();


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

      virtual void queueStateComponentDiscovered(const DtStateComponent*);
      virtual void queueStateComponentRemoved(const DtStateComponent*);

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

      virtual bool componentDiscovered(const DtFrameStateInterface*);
      virtual void componentRemoved(UInt64, const DtFrameStateInterface*);

      virtual void stateComponentDiscovered(const DtStateComponent*);
      virtual void stateComponentRemoved(UInt64, const DtFrameStateInterface*);

   protected:
      void setupComponentData();

      virtual void slot_frameAdvanced();
      virtual bool shouldForceObjectUpdate(const DtFrameStateInterface*) const;
      virtual void componentUpdated(const DtFrameStateInterface*);

      virtual makVrv::DtUniqueID idForStateComponent(const DtFrameStateInterface*);
      virtual makVrv::DtUniqueID vantageIdFromLegionId(Legion::UInt64) const;

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

      DtSimDataProcessorManager* simDataProcessorManager();

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

         ComponentUpdater(const std::set<const DtFrameStateInterface*>& listener,
            makVrv::DtSimStateObjectAgent& driver,
            DtComponentProcessorInterface& iface)
         : myFrameStateInterfaces(listener)
         , myObjectAgent(&driver)
         , myDataProcessorInterface(&iface)
         {
         }

         ComponentUpdater(const ComponentUpdater& orig)
         : myFrameStateInterfaces(orig.myFrameStateInterfaces)
         , myObjectAgent(orig.myObjectAgent)
         , myDataProcessorInterface(orig.myDataProcessorInterface)
         {
         }

         ComponentUpdater& operator=(const ComponentUpdater& orig)
         {
            myFrameStateInterfaces = orig.myFrameStateInterfaces;
            myObjectAgent = orig.myObjectAgent;
            myDataProcessorInterface = orig.myDataProcessorInterface;

            return *this;
         }

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

         void update(double)
         {
            if (myFrameStateInterfaces.size() && 
                (myDataProcessorInterface->vantageIdFromLegionId((*myFrameStateInterfaces.begin())->legionGlobalId()) != 0))
            {
               myDataProcessorInterface->createAndSendState(myFrameStateInterfaces, *myObjectAgent);
            }
         }

      protected:
         std::set<const DtFrameStateInterface*> myFrameStateInterfaces;
         makVrv::DtSimStateObjectAgent* myObjectAgent;
         DtComponentProcessorInterface* myDataProcessorInterface;
      };

      virtual void dataDiscoveredByLegionId(Legion::UInt64 lid);

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

      DtTimedSection myTimer;
      makVrv::DtSimEntryObjectAgent* mySimEntryAgent;

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

      UpdateGroupMap myRefreshRateGroups;

      typedef std::set<makVrv::DtUniqueID> EntityIdList;
      EntityIdList myForceUpdateList;
    
      struct ComponentInstance
      {
         std::set<const DtFrameStateInterface*> myFrameStateInterfaces;
         makVrv::DtSimStateObjectAgent* myAgent;
         makVrv::DtSimEntryUpdater::UpdateRate myRate;
      };

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

      boost::signals2::connection myVantageToLegionIdMapperConnection;

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