vrfConnectionHelper.h

Go to the documentation of this file.

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

#pragma once

#include <vrfGuiNetworkCommon/vrfGuiNetworkCommonDefines.h>
#include <vrvCore/DtSelectionManager.h>
#include <vrfGuiCore/guiThreadNetworkCallbackManager.h>
#include <vrfGuiCore/guiThreadVrfRemoteController.h>
#include <vrfGuiCore/sharedNetworkSignaler.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrfMsgTransport/events.h>
#include <vrvUtil/DtLockedBufferedQueue.h>
#include <vrfutil/scenario.h>
#include <vrfutil/backend.h>
#include <vrfmsgs/ifSaveComplete.h>

#include <matrix/vlVector.h>
#include <boost/function.hpp>
#include <boost/signals2.hpp>
#include <vlutil/vlThread.h>

class DtVrfMessageInterface;
class DtVrfTDLMessageInterface;
class DtScenarioLoadInformation;
class DtEntityType;
class DtSetDataRequest;
class DtVrfObjectMessage;
class DtSimInterfaceContent;
class DtVrfRemoteController;
class DtSimulationAddress;
class DtCommunicationManager;
class Coordinate_System;
class DtAddressMap;
class DtBackendMap;
class DtMtlParameterDb;
class DtVrfObjectMessage;
class DtSimInterfaceContent;
class DtSimulationModelSet;

namespace makVrv
{
   class DtDe;
   class DtBaseConnection;
   class DtCoordinateSystem;
   class DtSharedSettingsManager;
}

namespace Legion
{
   class SimulationDatabase;
}

namespace makVrf 
{
   class DtNetworkMessageInterface;
   class DtNetworkMessageInterfaceHandlerAgent;
   class DtStateDataManager;
   class DtSimDataProcessorManager;
   class DtRadioProcessor;
   class DtVrfBackendInterceptor;
   class DtVantageToLegionIdMapper;
   class DtTDLMessageProcessor;
   class DtExtendedStateDataProcessor;
   class DtVrfCommunicationManager;
   struct DtSimpleTypedDictionary;

   class DT_DLL_vrfGuiNetworkCommon DtVrfConnectionHelperMessageCallbackHandler
   {
   public:
      virtual void callback(const makVrfEvents::DtEvent&) = 0;
      virtual bool operator==(const DtVrfConnectionHelperMessageCallbackHandler& orig)
      {
         return true;
      }

      virtual bool operator!=(const DtVrfConnectionHelperMessageCallbackHandler& orig)
      {
         return !(*this == orig);
      }
   };

   template <typename _Class, typename _CallbackFunction>
   class DtVrfDriverEventManagerCallbackHandler : public DtVrfConnectionHelperMessageCallbackHandler
   {
   public:
      DtVrfDriverEventManagerCallbackHandler(_CallbackFunction fcn, void* usr)
      : myCallbackFcn(fcn)
      , myUser(usr)
      {
      }

      virtual ~DtVrfDriverEventManagerCallbackHandler()
      {
         myConnection.disconnect();
      }

      virtual void callback(const makVrfEvents::DtEvent& e)
      {
         (myCallbackFcn)(dynamic_cast<const _Class*>(&e), myUser);
      }

      virtual bool operator==(const DtVrfConnectionHelperMessageCallbackHandler& orig)
      {
         const DtVrfDriverEventManagerCallbackHandler* handler = dynamic_cast<const DtVrfDriverEventManagerCallbackHandler*>(&orig);

         if (handler)
         {
            return ((handler->myCallbackFcn == myCallbackFcn) &&
                     (handler->myUser == myUser));
         }

         return false;
      }

      _CallbackFunction myCallbackFcn;
      void* myUser;
      boost::signals2::connection myConnection;
   };

   class DT_DLL_vrfGuiNetworkCommon DtVrfConnectionHelper
   {
   public:

      DtVrfConnectionHelper(makVrv::DtDe&, bool inThread = true);

      virtual ~DtVrfConnectionHelper();

      virtual void beginFrame();

      virtual void advanceFrame();

      virtual bool onStop();

      virtual DtSimpleTypedDictionary& extendedStateFor(makVrv::DtUniqueID id, bool forceUpdate = true);

      typedef boost::function<void (DtVrfConnectionHelper*)> RemoteControllerInitialization;

      virtual void createStateDataManager(Legion::SimulationDatabase* db = 0);

      virtual void init(const DtSimulationAddress&, makVrv::DtBaseConnection*, int sessionId = -1,
         int fileReceiveTransferPort = 9000, Legion::SimulationDatabase* db = 0,
          RemoteControllerInitialization remoteControllerInitializationFunction = RemoteControllerInitialization(),
         bool disableRemoteDiscovery = false);

      virtual void setupQueuedConenctions(makVrv::DtSharedSettingsManager& manager);

      virtual void receivedNetworkMessage(DtNetworkMessageInterface* iface);

      virtual void registerCommentInteractionCallback(DtCommentCallbackFcn, void*);

      virtual void unregisterCommentInteractionCallback(DtCommentCallbackFcn, void*);

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

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

      virtual void rollbackToSnapshot(double);

      virtual void setCoordinateSystem(const makVrv::DtCoordinateSystem&);

      virtual void loadScenario(const DtScenarioLoadInformation*, bool deleteMemory = false);

      virtual void clearSavingCheckpoints();

      virtual DtSimulationStatus simulationStatus() const;

      virtual void simulationStatusChanged(DtSimulationStatus);

      DtVantageToLegionIdMapper* vantageToLegionIdMapper() const
      {
         return myVantageToLegionIdMapper;
      }

      DtRadioProcessor* radioProcessor() const
      {
         return myRadioProcessor;
      }

      DtVrfRemoteController* remoteController() const
      {
         return myRemoteController;
      }

      DtCommunicationManager* communicationManager() const;
      
      Coordinate_System* coordinateSystem() const
      {
         return myCoordinateSystem;
      }

      DtVrfMessageInterface* messageInterface() const
      {
         return myVrfMessageInterface;
      }

      DtVrfTDLMessageInterface* vrfTDLMessageInterface() const
      {
         return myVrfTDLMessageInterface;
      }

      DtTDLMessageProcessor* tdlMessageProcessor() const
      {
         return myTDLMessageProcessor;
      }

      DtExtendedStateDataProcessor*  extendedDataStateProcessor() const
      {
         return myExtendedStateDataProcessor;
      }

      DtStateDataManager* stateDataManager() const
      {
         return myStateDataManager;
      }

      virtual void sendMessageToObject(const DtVrfObjectMessage* m, DtSimulationAddress addr);

      virtual void sendMessage(const DtSimInterfaceContent* m, DtSimulationAddress addr);

      virtual void importScenarioDescriptionFile(std::string file, DtSimulationAddress address, std::string format,
         std::map<std::string, std::string> importData);

      virtual void exportScenarioDescriptionFile(std::string file, DtSimulationAddress address, std::string format,
         std::map<std::string, std::string> importData);

      virtual void createGlobalEnvironment(bool);

      virtual void createEnvironmentalObject(DtSimulationAddress addr,
         DtSharedNetworkSignaler::EnvironmentalSignalCreationData sigData);

      virtual void newScenario(const DtScenario*, time_t startTimeOfDay = 12 * 3600, const DtChangeWeatherCommand& initialCondition = DtChangeWeatherCommand());

      virtual void closeScenario(DtFilename, bool forceCloseAll = false);

      virtual void getMessageFilterStatus(std::map<std::string,bool>& statusMap) const;

      virtual void setMessageFilterStatus(const std::map<std::string,bool>& statusMap);

      virtual void getMessageProcessorStatus(std::map<std::string,bool>& statusMap) const;

      virtual void setMessageProcessorStatus(const std::map<std::string,bool>& statusMap);

      virtual void addSetCreatorFcn(const DtSetMessageType&, DtSetDataRequestCreatorFcn);

      virtual void addTaskCreatorFcn(const DtSimTaskMessageType&, DtSimTaskCreatorFcn);

      virtual void addInterfaceContentCreatorFcn(int, DtInterfaceContentCreatorFcn);

      virtual void addObjectMessageCreatorFcn(int, DtVrfObjectMessageCreatorFcn);

      virtual void addReportCreatorFcn(const DtSimReportMessageType&, DtSimReportCreatorFcn);

      virtual void addAdminContentCreatorFcn(const DtAdminContentMessageType&, DtAdminContentCreatorFcn);

      virtual void addSimulationCommandCreatorFcn(const DtSimCommandMessageType&, DtSimCommandCreatorFcn);

      virtual void addConditionCreatorFcn(std::string, int, DtCondExprCreatorFcn);

      virtual void setTimeoutInterval(int i);

      virtual void registerSimMessageCallbackFor(int t, bool reg);

      virtual void registerSimReportMessageCallbackFor(const DtSimReportMessageType& s, bool reg);

      virtual void registerSimTaskMessageCallbackFor(const DtSimTaskMessageType& s, bool reg);

      virtual void registerSetMessageCallbackFor(const DtSetMessageType& s, bool reg);

      virtual void registerAdminMessageCallbackFor(const DtAdminContentMessageType& t, bool reg);

      int proposedNumberOfObjectsToBeLoaded() const
      {
         return myProposedNumberOfObjectsToBeLoaded;
      }

      boost::signals2::signal<void (bool)> signal_parameterDatabaseInitialized;
      boost::signals2::signal<void (DtSimulationStatus)> signal_simulationStatusChanged;
      boost::signals2::signal<void ()> signal_scenarioLoaded;
      boost::signals2::signal<void (DtScenario&)> signal_scenarioAboutToBeSaved;
      boost::signals2::signal<void (DtSaveResult, const DtString&)> signal_scenarioSaved;

   protected:
      virtual void processNetworkMessage(DtNetworkMessageInterface* iface);

      virtual void slot_onSaveScenario(const DtScenario*, DtPreserveMappingsFcn fcn = 0, void* userData = 0,
         bool saveInZipFile = false, bool queueSave = false, int putIntoPlayMode = 0);

      virtual void slot_onSaveCheckpoints(std::vector<DtScenario*>, DtFilename);

      virtual void slot_onClearSavingCheckpoints();

      virtual void slot_onLoadScenario(const DtScenarioLoadInformation&);

      virtual void slot_onRollbackToSnapshot(double);

      virtual void slot_registerCommentInteraction(bool);

      virtual void slot_registerInfluenceInteraction(bool);

      static void influenceInteractionCallback(const makVrfEvents::DtInfluenceEvent *inter, void* usr);

      virtual void processInfluenceInteraction(const makVrfEvents::DtInfluenceEvent* inter);
      static void commentInteractionCallback(const makVrfEvents::DtCommentEvent *inter, void* usr);

      virtual void processCommentInteraction(const makVrfEvents::DtCommentEvent* inter);

      virtual void regsiterInfluenceIteractionCallback(DtInfluenceEventCb, void*);

      virtual void unregsiterInfluenceIteractionCallback(DtInfluenceEventCb, void*);

      virtual Coordinate_System* createVrfCoordinateSystem( const makVrv::DtCoordinateSystem& coodSysIn );

      static void scenarioAboutToBeSaved(DtScenario&, void*);
      virtual void processScenarioAboutToBeSaved(DtScenario&) const;

      virtual void saveScenario(const DtScenario*, DtPreserveMappingsFcn fcn = 0, void* userData = 0,
         bool deleteMemory = false, bool saveInZipFile = false, bool queueSave = false, int putIntoPlayMode = 0);

      virtual void saveCheckpoints(const std::vector<DtScenario*>&, const DtFilename& baseName);

      virtual void saveNextCheckpoint();

      virtual void slot_quitBackend(DtSimulationAddress);
      virtual void symbolDecorationsChanged();

      virtual void setupParameterDatabase(std::vector<DtFilename> searchPaths);
      virtual void setupEnumerations(const std::vector<DtSimulationModelSet*>& sets);

      virtual void createGlobalDynamicTerrain(bool);

   protected:
      virtual void slot_modelSetLoaded(std::vector<DtFilename> searchPaths);

      virtual void setupDirectConnections();
      virtual void disconnectConnections();

      virtual void sendScenarioLoadSuccessMessage();
      virtual void sendScenarioLoadErrorMessage(DtString error);

      static void scenarioSavedCallback(DtSaveResult result, const DtString& error, void* usr);
      virtual void processScenarioSaved(DtSaveResult, const DtString&);

      static void scenarioCheckpointed(DtSaveResult result, double, void*);
      virtual void processScenarioCheckpointed(DtSaveResult result, double);

      virtual void runFunctionQueue();

      virtual void runPostAdvanceFrameFunctionQueue();

      static void simMessageCallback(DtSimMessage* msg, void* usr);
      virtual void processSimMessage(DtSimMessage* msg);

      static void radioMessageCallback(const DtVrfObjectMessage* msg, void* usr);
      virtual void processRadioMessage(const DtVrfObjectMessage* msg);

      virtual void registerExistingMessages();

      template <typename _Class, typename _CallbackFunction>
      DtVrfConnectionHelperMessageCallbackHandler* addEventManagerCallback(makVrfEvents::DtEvent::EventType et, _CallbackFunction fcn, void* usr)
      {
         EventHandlerCallbacksMap::iterator iter = myEventHandlerCallbacksMap.find(et);

         if (iter == myEventHandlerCallbacksMap.end())
         {
            myEventHandlerCallbacksMap[et] = EventHandlerCallbacks();
            iter = myEventHandlerCallbacksMap.find(et);
         }

         DtVrfDriverEventManagerCallbackHandler<_Class, _CallbackFunction>* adder =
            new DtVrfDriverEventManagerCallbackHandler<_Class, _CallbackFunction>(fcn, usr);

         EventHandlerCallbacks::const_iterator currentIter = iter->second.begin();
         EventHandlerCallbacks::const_iterator currentEnd = iter->second.end();

         while (currentIter != currentEnd)
         {
            if (**currentIter == *adder)
            {
               delete adder;
               return 0;
            }

            ++currentIter;
         }

         return adder;
      }

      template <typename _Class, typename _CallbackFunction>
      void removeEventManagerCallback(makVrfEvents::DtEvent::EventType et, _CallbackFunction fcn, void* usr)
      {
         EventHandlerCallbacksMap::iterator iter = myEventHandlerCallbacksMap.find(et);

         if (iter == myEventHandlerCallbacksMap.end())
         {
            myEventHandlerCallbacksMap[et] = EventHandlerCallbacks();
            iter = myEventHandlerCallbacksMap.find(et);
         }

         DtVrfDriverEventManagerCallbackHandler<_Class, _CallbackFunction>* adder =
            new DtVrfDriverEventManagerCallbackHandler<_Class, _CallbackFunction>(fcn, usr);

         EventHandlerCallbacks::const_iterator currentIter = iter->second.begin();
         EventHandlerCallbacks::const_iterator currentEnd = iter->second.end();

         while (currentIter != currentEnd)
         {
            if (**currentIter == *adder)
            {
               delete adder;
               return;
            }

            ++currentIter;
         }
      }

      virtual void remoteControllerInitialized();

   protected:
      typedef std::vector<std::pair<DtVrfObjectConsoleMessageCallbackFcn, void*> > DtCommentInteractionCallbackList;

      makVrv::DtDe& myDe;
      makVrv::DtBaseConnection* myConnection;

      makVrv::DtSignalConnectionManager     myConnections;

      DtNetworkMessageInterfaceHandlerAgent* myNetworkMessageInterfaceHandlerAgent;

      bool myInThreadFlag;

      typedef std::vector<DtVrfConnectionHelperMessageCallbackHandler*> EventHandlerCallbacks;
      typedef std::map<makVrfEvents::DtEvent::EventType, EventHandlerCallbacks> EventHandlerCallbacksMap;
      EventHandlerCallbacksMap myEventHandlerCallbacksMap;

      typedef makVrv::DtLockedBufferedQueue<boost::function<void ()> > FunctionCallQueue;
      typedef std::vector<boost::function<void ()> > FunctionCallList;

      FunctionCallQueue myConnectionThreadFunctions;
      FunctionCallQueue myAdvancedFrameConnectionThreadFunctions;

      DtVrfRemoteController* myRemoteController;
      DtStateDataManager* myStateDataManager;
      DtVrfCommunicationManager* myCommunicationManager;
      Coordinate_System* myCoordinateSystem;
      int mySessionId;
      int myFileTransporterReceivePort;

      DtAddressMap* myLastAddressMap;
      DtBackendMap* myLastBackendMap;

      typedef std::map<double, std::pair<DtScenario, int> > CheckpointsToSave;
      CheckpointsToSave myCheckpointsToSave;
      CheckpointsToSave myCheckpointsSaving;
      DtVrfMessageInterface*     myVrfMessageInterface;
      DtVrfTDLMessageInterface*  myVrfTDLMessageInterface;
      DtSimDataProcessorManager* mySimDataProcessorManager;
      DtTDLMessageProcessor* myTDLMessageProcessor;
      DtRadioProcessor* myRadioProcessor;
      DtExtendedStateDataProcessor*  myExtendedStateDataProcessor;
      bool myStopped;

      DtMtlParameterDb* myParameterDatabase;
      std::vector<DtFilename> myLastSearchPaths;
      double myParameterDatabaseTimerStart;

      DtSimulationStatus mySimulationStatus;
      DtVrfBackendInterceptor*   myBackEndInterceptor;
      DtVantageToLegionIdMapper* myVantageToLegionIdMapper;

      std::set<int> mySimMessageCallbacks;
      std::set<DtAdminContentMessageType> myAdminMessageCallbacks;
      std::set<DtSimReportMessageType> myReportMessageCallbacks;
      std::set<DtSimTaskMessageType> myTaskMessageCallbacks;
      std::set<DtSetMessageType> mySetMessageCallbacks;

      std::map<DtSetMessageType, DtSetDataRequestCreatorFcn> mySetCreator;
      std::map<DtSimTaskMessageType, DtSimTaskCreatorFcn> myTaskCreator;
      std::map<int, DtInterfaceContentCreatorFcn> myInterfaceContentCreator;
      std::map<DtAdminContentMessageType, DtAdminContentCreatorFcn> myAdminContentCreator;
      std::map<DtSimCommandMessageType, DtSimCommandCreatorFcn> mySimulationCommandCreator;
      std::map<std::string, std::pair<int, DtCondExprCreatorFcn> > myConditionCommandCreator;
      std::map<int, DtVrfObjectMessageCreatorFcn> myObjectMessageCreator;
      std::map<DtSimReportMessageType, DtSimReportCreatorFcn> myReportCreator;

      std::vector<DtFilename> myModelSetSearchPaths;

      DtThreadId myThreadId;
      int myProposedNumberOfObjectsToBeLoaded = 0;
   };
}