vrfDriver.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/guiThreadVrfRemoteController.h>
#include <vrfGuiCore/sharedNetworkSignaler.h>
#include <vrvVrl/DtConnection.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrfVrlSharedSource/vrfProtocol.h>
#include <vrfVrlSharedSource/DtVrfEnvironmentProcessor.h>
#include <vrfVrlSharedSource/vrfAggregateProcessor.h>
#include <vrfVrlSharedSource/extendedStateDataProcessor.h>
#include <vrfVrlSharedSource/stateCacheManager.h>
#include <vrfcontrol/vrfRemoteController.h>
#include <vrfmsgs/ifSavedSimulationObjectGroup.h>
#include <vrfplan/changeWeatherCommand.h>
#include <vrfutil/backend.h>
#include <vrfMsgTransport/eventManager.h>

#include <vrvVrl/DtVrlinkConnection.h>

#include <vlpi/entityType.h>
#include <matrix/vlVector.h>

#include <vrfutil/scenario.h>

#include <vl/commentInteraction.h>

#if DtHLA
#include <vrfExtObjects/influenceInteractionHLA.h>
#endif
#include "vrfutil/rwColor.h"

class DtVrfObjectMessage;

class DtVrfRemoteController;
class DtVrfMessageInterface;
class DtVrfTDLMessageInterface;
class DtScenarioLoadInformation;
class DtSetDataRequest;
class DtSimTask;
class DtSimInterfaceContent;
class DtRemoteLoggerController;
class DtAddressMap;
class DtBackendMap;

#if DtHLA
namespace makVrfVrlinkExtToolkit
{
   class DtReflectedExtendedAttributesObjectList;
}
#endif

#if DtDIS
#define DtCommentCallbackFcn DtCommentPduCb
#elif DtHLA
#define DtCommentCallbackFcn DtCommentInteractionCb
#endif

namespace makVrv
{
   class DtVrlinkElement;

   namespace DT_PROTOCOL_NAMESPACE
   {
      class DtVrlinkEntityStateListener;
      class DtAggregateElement;
      class DtEntityElement;
      class DtEntitySimDataProcessor;
      class DtSensorFieldOfViewSimDataProcessor;
      class DtSensorFieldOfViewSimDataProcessorAccessory;
   }
}

namespace makVrf 
{
   class DtNetworkMessageInterface;
   class DtNetworkMessageInterfaceHandlerAgent;

   namespace VRF_PROTOCOL_NAMESPACE
   {
      class DtTDLMessageProcessor;
      class DtRadioProcessor;
      class DtVrfBackendInterceptor;
      class DtVrfConnectionHelper;
      class DtVrfObjectDataStateProcessor;
      class DtVrfWeatherStateProcessor;
      class DtVrfCloudLayerStateProcessor;
      class DtVrfEnvironmentObjectDataStateProcessor;
      class DtEnvironmentSimDataProcessor;
      class DtEmitterSystemSimDataProcessor;
      class DtActiveSonarSimDataProcessor;
      class DtVrfAggregateObjectDataStateProcessor;
      class DtAggregateSimDataProcessor;
      class DtOrbatSimDataProcessor;
      class DtVrfFogOfWarHandler;
      class DtVrfEmbarkationProcessor;
      class DtIffSimDataProcessor;
      class DtLaserDesignatorSimDataProcessor;
      class DtPropulsionNoiseSimDataProcessor;
      class DtWeatherStateCacheManager;
      class DtCloudLayerStateCacheManager;
      class DtVrfWeatherProcessor;
      class DtVrfCloudLayerProcessor;
      class DtVrfVrlinkGuiOrbatManager;

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

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

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

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

         virtual void callback(const DtEvent& e)
         {
            (myCallbackFcn)(static_cast<_Class*>(e.contents()), myUser);
         }

         virtual bool operator==(const DtVrfDriverMessageCallbackHandler& 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 VRF_PROTOCOL_EXPORT DtVrfDriver : public VRF_DRIVER_BASE_CLASS
      {
      public:
         DtVrfDriver(makVrv::DtAgentManager& agentManager, const std::string& uniqueName);

         virtual ~DtVrfDriver();

      public:
         virtual bool onStart();

      public:
         virtual void realizeConfiguration(const makVrv::DtConfiguration& config);

         virtual void sendLoggerSetFilename(std::string filename);

         virtual void sendLoggerRecordMessage();

         virtual void sendLoggerStopMessage();

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

         virtual void rollbackToSnapshot(double);

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

         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 clearSavingCheckpoints();

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

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

         virtual DtSimulationStatus simulationStatus() const;

         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 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);

         virtual void setTimeoutInterval(int i);

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

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

         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 requestOrbatList();

         virtual void clearOrbatList();

         virtual void executeGesture(std::string gesture, std::vector<makVrv::DtUniqueID>);

         virtual void executeAnimation(std::string gesture, std::vector<makVrv::DtUniqueID>);
         virtual void executeAnimations(std::map<makVrv::DtUniqueID, std::string>);

       virtual void setIconColor(DtRwColor iconColor, std::vector<makVrv::DtUniqueID>);

       virtual void blockNetworkAnimationChange(std::vector<makVrv::DtUniqueID>, bool, double);
       virtual void blockNetworkGestureChange(std::vector<makVrv::DtUniqueID>, bool);

#if DtHLA
         virtual void regsiterInfluenceIteractionCallback(DtInfluenceInterCb, void*);

         virtual void unregsiterInfluenceIteractionCallback(DtInfluenceInterCb, void*);
#endif

         virtual void startFreezeScenario(DtSimulationAddress, bool sendStart);

         virtual void sendSensorFieldOfViewControl(const DtSensorFieldOfViewControlInteractionData* d);

         virtual void sendDetonation(const DtDetonationInteractionData* d);

         virtual void registerCommentInteractionCallback(DtCommentCallbackFcn, void*);

         virtual void unregisterCommentInteractionCallback(DtCommentCallbackFcn, void*);

         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 DtSimpleTypedDictionary& extendedStateFor(makVrv::DtUniqueID id, bool forceUpdate = true);

         virtual void createGlobalDynamicTerrain(bool);

         virtual void createGlobalEnvironment(bool);

         DtVrfObjectDataStateProcessor* vrfObjectDataProcessor()
         {
            return myVrfObjectDataStateDataProcessor;
         }

         makVrv::DT_PROTOCOL_NAMESPACE::DtEntitySimDataProcessor* dataProcessor()
         {
            return myDataProcessor;
         }

         DtRadioProcessor* radioProcessor()
         {
            return myRadioProcessor;
         }

         DtTDLMessageProcessor* tdlMessageProcessor()
         {
            return myTDLMessageProcessor;
         }

         DtEmitterSystemSimDataProcessor*  emitterSystemDataProcessor()
         {
            return myEmitterSystemDataProcessor;
         }

         DtVrfWeatherStateProcessor* weatherDataProcessor()
         {
            return myWeatherDataProcessor;
         }

         DtVrfCloudLayerStateProcessor* cloudLayerDataProcessor()
         {
            return myCloudLayerDataProcessor;
         }

         DtActiveSonarSimDataProcessor*  activeSonarDataProcessor()
         {
            return myActiveSonarDataProcessor;
         }

         DtEnvironmentSimDataProcessor*  environmentDataProcessor()
         {
            return myEnvironmentDataProcessor;
         }

         DtAggregateSimDataProcessor*  aggregtateDataProcessor()
         {
            return myAggregateDataProcessor;
         }

         DtOrbatSimDataProcessor*  orbatDataProcessor()
         {
            return myOrbatDataProcessor;
         }

         DtEventManager*  eventManager()
         {
            return myEventManager;
         }

         DtLaserDesignatorSimDataProcessor*  laserDesignatorSimDataProcessor()
         {
            return myLaserDesignatorSimDataProcessor;
         }

         DtVrfVrlinkGuiOrbatManager*  orbatManager()
         {
            return myOrbatManager;
         }

         DtExtendedStateDataProcessor*  extendedDataStateProcessor()
         {
            return myExtendedStateDataProcessor;
         }

         void setUseThreadFlag(bool b)
         {
            myUseThreadFlag = b;
         }

         bool connected() const
         {
            return myConnected;
         }

         virtual bool onStop();

         virtual bool onTick();
         virtual void receivedNetworkMessage(DtNetworkMessageInterface* iface);

         boost::signals2::signal<void ()> signal_connectionSetUp;
         boost::signals2::signal<void ()> signal_connectionCleanedUp;
         boost::signals2::signal<void ()> signal_connectionAboutToBeCleanedUp;
         boost::signals2::signal<void ()> signal_onFirstTickDriverInitialization;
         boost::signals2::signal<void ()> signal_driverStarted;
         boost::signals2::signal<void ()> signal_driverAboutToBeSetUp;
         boost::signals2::signal<void (DtSimulationStatus)> signal_simulationStatusChanged;

      public:

         virtual DtVrfRemoteController* remoteController();
         virtual const DtVrfRemoteController* remoteController() const;

         virtual DtVrfMessageInterface* messageInterface();
         virtual const DtVrfMessageInterface* messageInterface() const;

         virtual DtVrfTDLMessageInterface* vrfTDLMessageInterface();
         virtual const DtVrfTDLMessageInterface* vrfTDLMessageInterface() const;

         const std::string& nonVrfObjectsUseUUIDScheme() const;

         virtual void simulationStatusChanged(DtSimulationStatus);

      protected:
         virtual void onSetupExerciseConnection();
         virtual void onCleanupExerciseConnection();

         virtual void connectionConnected();

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

         virtual void setupEntityData();
         virtual void setupAggregateData();
         virtual void setupEnvironmentalData();

         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 elementAttributeChangeRequested( 
            makVrv::DtUniqueID id, makVrv::DtUniqueID parentId, DtBoost::shared_ptr<const makVrv::DtElementAttribute> atr );

         makVrv::DtVrlinkElement* findElementWithId(makVrv::DtUniqueID id) const;

         virtual makVrv::DtConnection* createConnection();

         virtual void slot_quitBackend(DtSimulationAddress);

         virtual void symbolDecorationsChanged();
         virtual void slot_entityElementCreated(makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkEntityStateListener& l,
            makVrv::DT_PROTOCOL_NAMESPACE::DtEntityElement* e);

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

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

         virtual void visualsLoaded();

       virtual void logGraphics();

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

         virtual void setVisibleForElement(makVrv::DtVrlinkElement*, bool flag, int context) const;

         template <typename _Class, typename _CallbackFunction>
         DtVrfDriverMessageCallbackHandler* addEventManagerCallback(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(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;
            }
         }

      protected:
         DtVrfRemoteController*     myRemoteController;
         DtVrfMessageInterface*     myVrfMessageInterface;
         DtVrfTDLMessageInterface*  myVrfTDLMessageInterface;
         DtVrfBackendInterceptor*   myBackEndInterceptor;
         DtVrfConnectionHelper*     myConnectionHelper;
         DtRemoteLoggerController*  myLoggerControl;

         makVrv::DT_PROTOCOL_NAMESPACE::DtEntitySimDataProcessor*  myDataProcessor;
         DtEntityStateCacheManager* myEntityStateCacheManager;

         DtEmitterSystemSimDataProcessor*  myEmitterSystemDataProcessor;
         DtActiveSonarSimDataProcessor*  myActiveSonarDataProcessor;
         DtEnvironmentSimDataProcessor*  myEnvironmentDataProcessor;
         DtEnvironmentProcessStateCacheManager*   myEnvironmentProcessCacheManager;
         DtExtendedStateDataProcessor*  myExtendedStateDataProcessor;
         DtVrfObjectDataStateProcessor*   myVrfObjectDataStateDataProcessor;
         DtVrfEnvironmentObjectDataStateProcessor*   myVrfEnvironmentObjectDataStateDataProcessor;
         DtVrfWeatherStateProcessor* myWeatherDataProcessor;
         DtVrfCloudLayerStateProcessor* myCloudLayerDataProcessor;
         DtTDLMessageProcessor* myTDLMessageProcessor;
         DtRadioProcessor* myRadioProcessor;

         makVrv::DtAgentManager& myAgentManager;

         DtEventManager* myEventManager;

         DtVrfVrlinkGuiOrbatManager* myOrbatManager;

         DtAggregateSimDataProcessor*  myAggregateDataProcessor;
         DtOrbatSimDataProcessor*  myOrbatDataProcessor;
         DtAggregateStateCacheManager* myAggregateStateCacheManager;
         DtWeatherStateCacheManager* myWeatherStateCacheManager;
         DtCloudLayerStateCacheManager* myCloudLayerStateCacheManager;

         DtIffSimDataProcessor*        myIffDataProcessor;
         DtLaserDesignatorSimDataProcessor*        myLaserDesignatorSimDataProcessor;
         DtPropulsionNoiseSimDataProcessor*        myPropulsionNoiseDataProcessor;

         DtVrfAggregateObjectDataStateProcessor*   myVrfAggregateObjectDataStateDataProcessor;

         bool myRtiError;
         std::string                   myHostAddressString;
         std::string                   myReportedHostAddressString;
         int                           mySessionId;
         DtVrfFogOfWarHandler*         myFogOfWarHandler;

         DtVrfEmbarkationProcessor*    myVrfEmbarkationProcessor;
         makVrv::DtSignalConnectionManager     myConnectionManager;

         DtVrfWeatherProcessor*        myVrfWeatherProcessor;
         DtVrfCloudLayerProcessor*     myVrfCloudLayerProcessor;

         DtAddressMap* myLastAddressMap;
         DtBackendMap* myLastBackendMap;

         DtNetworkMessageInterfaceHandlerAgent* myNetworkMessageInterfaceHandlerAgent;

         typedef std::map<unsigned int, bool> ContextMap;
         typedef std::map<makVrv::DtUniqueID, ContextMap> ShowHideContextMap;

         bool myConnected;
         std::string myLocalSettingsDesignator;

         int myFileTransporterReceivePort;
         std::string myNonVrfObjectsUseUUIDScheme;

         typedef std::map<double, 
            std::pair<DtScenario, int> > CheckpointsToSave;
         CheckpointsToSave myCheckpointsToSave;
         CheckpointsToSave myCheckpointsSaving;

         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;

#if DtHLA
         makVrfVrlinkExtToolkit::DtReflectedExtendedAttributesObjectList* myExtendedAttributesObjectList;
#endif


         bool myNeedsFirstTickInitialization;

#ifdef DtDIS
         int mySiteId;
         int myAppNumber;
#endif

         DtSimulationStatus mySimulationStatus;

         typedef std::vector<DtVrfDriverMessageCallbackHandler*> EventHandlerCallbacks;
         typedef std::map<DtEvent::EventType, EventHandlerCallbacks> EventHandlerCallbacksMap;
         EventHandlerCallbacksMap myEventHandlerCallbacksMap;
      };

      inline DtVrfMessageInterface* DtVrfDriver::messageInterface()
      {
         return (myVrfMessageInterface);
      }

      inline const DtVrfMessageInterface* DtVrfDriver::messageInterface() const
      {
         return (myVrfMessageInterface);
      }

      inline DtVrfTDLMessageInterface* DtVrfDriver::vrfTDLMessageInterface()
      {
         return (myVrfTDLMessageInterface);
      }

      inline const DtVrfTDLMessageInterface* DtVrfDriver::vrfTDLMessageInterface() const
      {
         return (myVrfTDLMessageInterface);
      }

      inline DtVrfRemoteController* DtVrfDriver::remoteController()
      {
         return (myRemoteController);
      }

      inline const DtVrfRemoteController* DtVrfDriver::remoteController() const
      {
         return (myRemoteController);
      }

      inline const std::string& DtVrfDriver::nonVrfObjectsUseUUIDScheme() const
      {
         return myNonVrfObjectsUseUUIDScheme;
      }
   }
}