DtVrfDriver.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/DtGuiThreadVrfRemoteController.h>
#include <vrfGuiCore/DtEntityStateListenerExtensions.h>
#include <vrvVrl/DtConnection.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrfVrlSharedSource/vrfProtocol.h>

#include <vrfVrlSharedSource/DtVrfEnvironmentProcessor.h>
#include <vrfVrlSharedSource/DtVrfAggregateProcessor.h>
#include <vrfVrlSharedSource/DtExtendedStateDataProcessor.h>
#include <vrfVrlSharedSource/DtStateCacheManager.h>

#include <vrvVrl/DtVrlinkConnection.h>
#include <vrvVrl/DtVrlinkEntityStateListener.h>
#include <vrvVrl/DtEntityExistenceListener.h>
#include <vrvVrl/DtEntityStateInterceptorCreator.h>

#include <vrvCore/DtEntityState.h>

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

#include <vrftasks/setReqFact.h>
#include <vrftasks/taskFactory.h>
#include <vrfutil/ceFactory.h>
#include <vrfplan/simCommandFactory.h>
#include <vrftasks/adminContentFactory.h>
#include <vrfExtProtocol/ifContFactory.h>
#include <vrfmsgs/vrfObjectMessageFactory.h>
#include <vrftasks/reportFactory.h>
#include <vrfmsgs/vrfObjectMessageExecutive.h>

#include <vrfmsgs/msgExec.h>
#include <vrfplan/plan.h>
#include <vrfExtObjects/refExtEntList.h>
#include <vrfutil/scenario.h>

#include <vl/commentInter.h>


class DtVrfObjectMessage;

class DtVrfRemoteController;
class DtVrfMessageInterface;
class DtScenarioLoadInformation;
class DtSetDataRequest;
class DtSimTask;
class DtSimInterfaceContent;
class DtRemoteLoggerController;
class DtReflectedIffList;

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

namespace makVrv
{
   class DtVrlinkElement;

   namespace DT_PROTOCOL_NAMESPACE
   {
      class DtEntitySimDataProcessor;
   }
}

namespace makVrf 
{
   class DtNetworkMessageInterface;
   class DtNetworkMessageInterfaceHandlerAgent;

   namespace VRF_PROTOCOL_NAMESPACE
   {
      class DtVrfBackendInterceptor;
      class DtVrfConnectionHelper;
      class DtVrfObjectDataStateProcessor;
      class DtVrfEnvironmentObjectDataStateProcessor;
      class DtEnvironmentSimDataProcessor;
      class DtEmitterSystemSimDataProcessor;
      class DtVrfAggregateObjectDataStateProcessor;
      class DtAggregateSimDataProcessor;
      class DtVrfFogOfWarHandler;
      class DtVrfEmbarkationProcessor;
      class DtIffSimDataProcessor;

      class VRF_PROTOCOL_EXPORT DtVrfVrlinkEntityStateListener : public makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkEntityStateListener,
         public DtEntityStateListenerExtensions
      {
      public:
         DtVrfVrlinkEntityStateListener(makVrv::DtUniqueID id);

         virtual ~DtVrfVrlinkEntityStateListener();

      protected:
         virtual void postUpdate();
      };

      class VRF_PROTOCOL_EXPORT DtVrfVrlinkEntityStateListenerCreator : public makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkEntityStateListenerCreator
      {
      public:

         static DtVrfVrlinkEntityStateListenerCreator& instance(makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection& sim);

         virtual ~DtVrfVrlinkEntityStateListenerCreator();

   #ifdef DtHLA

         //functionality.
         virtual makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkEntityStateListener* create(DtHlaObject* object);
   #endif

   #ifdef DtDIS


         virtual makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkEntityStateListener* create(const DtEntityIdentifier& id, 
            const DtEntityType& type);
   #endif

         DtVrfVrlinkEntityStateListenerCreator(makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection&);
      };
      

      class VRF_PROTOCOL_EXPORT DtVrfVrlinkAggregateStateListener : public makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkAggregateStateListener,
         public DtEntityStateListenerExtensions
      {
      public:
         DtVrfVrlinkAggregateStateListener(makVrv::DtUniqueID id);

         virtual ~DtVrfVrlinkAggregateStateListener();
      };

      class VRF_PROTOCOL_EXPORT DtVrfVrlinkAggregateStateListenerCreator : public makVrv::DT_PROTOCOL_NAMESPACE::DtAggregateStateListenerCreator
      {
      public:

         static DtVrfVrlinkAggregateStateListenerCreator& instance(makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection& sim);

         virtual ~DtVrfVrlinkAggregateStateListenerCreator();

   #ifdef DtHLA

         //functionality.
         virtual makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkAggregateStateListener* create(DtHlaObject* object);
   #endif

   #ifdef DtDIS


         virtual makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkAggregateStateListener* create(const DtEntityIdentifier& id, 
            const DtEntityType& type);
   #endif

         DtVrfVrlinkAggregateStateListenerCreator(makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection&);
      };
      
      class VRF_PROTOCOL_EXPORT DtVrfEntityStateInterceptorCreator : public makVrv::DT_PROTOCOL_NAMESPACE::DtEntityStateInterceptorCreator
      {
      public:
         static DtEntityStateInterceptorCreator& instance(makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection& sim)
         {
            DtVrfEntityStateInterceptorCreator* creator = 
               dynamic_cast<DtVrfEntityStateInterceptorCreator*>(sim.findInstance(
                  "DtEntityStateInterceptorCreator"));
            if(!creator)
            {
               creator = new DtVrfEntityStateInterceptorCreator;
               sim.registerInstance("DtEntityStateInterceptorCreator",creator);
            }
            return *creator;
         }

         virtual ~DtVrfEntityStateInterceptorCreator()
         {
         }

         virtual DtEntityStateRepository* create(makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkEntityStateListener* listener);

         DtVrfEntityStateInterceptorCreator()
         {
         }
      };

      class VRF_PROTOCOL_EXPORT DtVrfEntityReflectedListCreator : public makVrv::DT_PROTOCOL_NAMESPACE::DtVrvEntityReflectedListCreator
      {
      public:

         static makVrv::DT_PROTOCOL_NAMESPACE::DtVrvEntityReflectedListCreator&
            instance(makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection& sim);

         virtual DtReflectedEntityList* create(makVrv::DT_PROTOCOL_NAMESPACE::DtEntityExistenceListener&);

      #if DtHLA
         virtual DtReflectedEntityList* create(makVrv::DT_PROTOCOL_NAMESPACE::DtEntityExistenceListener&, DtDDMRegionSet&);
      #endif

      protected:
         DtVrfEntityReflectedListCreator(makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection& sim);
      };

      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*, int startTimeOfDay = 12 * 3600);

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

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

         virtual void closeScenario();

         virtual void createEnvironmentalObject(DtSimulationAddress addr, DtEntityType, int force,
            std::vector<DtVector>, DtEnvironmentalCreationData data );

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

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

         DtEmitterSystemSimDataProcessor*  emitterSystemDataProcessor()
         {
            return myEmitterSystemDataProcessor;
         }

         DtEnvironmentSimDataProcessor*  environmentDataProcessor()
         {
            return myEnvironmentDataProcessor;
         }

         DtAggregateSimDataProcessor*  aggregtateDataProcessor()
         {
            return myAggregateDataProcessor;
         }

         DtExtendedStateDataProcessor*  extendedDataStateProcessor()
         {
            return myExtendedStateDataProcessor;
         }

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

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

         boost::signal<void ()> signal_connectionSetUp;
         boost::signal<void ()> signal_connectionCleanedUp;
         boost::signal<void ()> signal_connectionAboutToBeCleanedUp;

      public:

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

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

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

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

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

         DtEmitterSystemSimDataProcessor*  myEmitterSystemDataProcessor;
         DtEnvironmentSimDataProcessor*  myEnvironmentDataProcessor;
         DtEnvironmentProcessCacheManager*   myEnvironmentProcessCacheManager;
         DtExtendedStateDataProcessor*  myExtendedStateDataProcessor;
         DtVrfObjectDataStateProcessor*   myVrfObjectDataStateDataProcessor;
         DtVrfEnvironmentObjectDataStateProcessor*   myVrfEnvironmentObjectDataStateDataProcessor;

         DtAggregateSimDataProcessor*  myAggregateDataProcessor;
         DtAggregateStateCacheManager* myAggregateStateCacheManager;

         DtReflectedIffList*           myReflectedIffList; 
         DtIffSimDataProcessor*        myIffDataProcessor;
         DtIffStateCacheManager*       myIffStateCacheManager;

         DtVrfAggregateObjectDataStateProcessor*   myVrfAggregateObjectDataStateDataProcessor;

         std::string                   myHostAddressString;
         int                           mySessionId;
         DtVrfFogOfWarHandler*         myFogOfWarHandler;

         DtVrfEmbarkationProcessor*    myVrfEmbarkationProcessor;
         makVrv::DtSignalConnectionManager     myConnectionManager;

         DtNetworkMessageInterfaceHandlerAgent* myNetworkMessageInterfaceHandlerAgent;

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

         ShowHideContextMap myShowHideContextMap;
         bool myConnected;
         std::string myLocalSettingsDesignator;
      };

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

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