simManager.h

Go to the documentation of this file.

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

#pragma once




#include "vrfutil/noArgumentCallbackList.h"
#include <vl/hostStructs.h>
#include <vlutil/vlMachineTypes.h>
#include <vrfmsgs/messageExecutive.h>
#include <matrix/vlVector.h>

class DtExerciseConn;
class DtPhysicalWorld;
class DtCommModelManager;
class DtReflectedExtEntityList;
class DtThreadSocket;
class DtThreadMessageList;
class DtFrameRateMonitor;
class DtResourceMonitor;
class DtVrfObjectMessage;

class DtEntityType;
class DtEchelonRoleName;
class DtString;
class DtList;
class DtSimInterfaceMessage;
class DtEntityType;
class DtSimInterfaceContent;

class DtScheduler;
class DtExerciseClock;
class DtVrfObjectManager;
class DtScriptedTaskManager;
class DtScenarioEventManager;
class DtHazardAreaManager;
class DtIntelCollectionAreaManager;
class DtScriptedObjectsMovementManager;
class DtScriptedObjects;
class DtAggregateSpatialModel;
class DtDetonationManager;
class DtFireManager;
class DtGlobalPlanManager;
class DtStealthCommandsManager;
class DtInterfaceMessageExecutive;
class DtVrfMessageInterface;
class DtVrfTDLMessageInterface;
class DtHostilityManager;
class DtScenarioExtrasMgr;
class DtTimer;
class DtVrfSimSettingsManager;
class DtSimTerrainRequestManager;
class DtEmbeddedEntityInfoManager;
class DtParallelTickManager;
class DtVrfSimOptionsInterface;
class DtVrfNavAreaManager;
class DtSpawnSinkManager;
class DtSimCommandDistributor;

typedef void (*DtSimTickFunction)(void* userData);
typedef void (*DtRunDurationCallbackFcn)(void* userData);

#include "vrfcore/vrfcoreDefines.h"
class DT_DLL_vrfcore DtSimManager
{
public:

   DtSimManager(DtExerciseConn* connection);

   virtual ~DtSimManager();

private:

   DtSimManager(const DtSimManager& orig);

   DtSimManager& operator=(const DtSimManager& orig);

public:

   virtual bool init();

   virtual const DtVrfSimOptionsInterface* simOptions() const;

   virtual void setSimOptions(const DtVrfSimOptionsInterface&);

   virtual bool createExerciseClock();

   virtual bool createScheduler();
   virtual bool createMessageInterface();
   virtual bool createTDLMessageInterface();
   virtual bool createFrameRateMonitor();
   virtual bool createVrfSimSettingsManager();
   virtual bool createParallelTickManager();
   
   virtual void tick();

   virtual bool deliverMessage(const DtSimInterfaceMessage& msg);

   virtual bool receiveMessage(const DtSimInterfaceMessage& msg);

   virtual bool createAndDeliverMessage(
      const DtSimulationAddress& recipient, 
      const DtSimInterfaceContent & content,
      bool overrideTimestampOrder = true);

#if XXX

   virtual bool createAndDeliverMessage(const DtSimulationAddress& sender,
    const DtSimulationAddress& recipient, 
    const DtSimInterfaceContent & content);
#endif


   virtual void addTickEntry(DtSimTickFunction tickFunction, void* userData);
   virtual void removeTickEntry(DtSimTickFunction tickFunction, void* userData);

   virtual void addPostTickEntry(DtSimTickFunction tickFunction, void* userData);
   virtual void removePostTickEntry(DtSimTickFunction tickFunction, void* userData);

   virtual DtExerciseConn* exerciseConn();

   virtual DtExerciseClock* exerciseClock();

   virtual DtFrameRateMonitor* frameRateMonitor();

   virtual DtParallelTickManager* parallelTickManager();

   class EnableParallelTickManagerScopeGuard
   {
   public:
      explicit EnableParallelTickManagerScopeGuard(DtSimManager* mgr) : myMgr(mgr)
      {
         myMgr->setEnableParallelTickManager(true);
      }

      ~EnableParallelTickManagerScopeGuard()
      {
         myMgr->setEnableParallelTickManager(false);
      }

   private:
      DtSimManager* myMgr;

      EnableParallelTickManagerScopeGuard();
      EnableParallelTickManagerScopeGuard(const EnableParallelTickManagerScopeGuard&);
      void operator=(const EnableParallelTickManagerScopeGuard&);
   };

   virtual void setEnableParallelTickManager(bool enabled);

   virtual DtScheduler* scheduler();


   virtual void setPhysicalWorld(DtPhysicalWorld* newPhysicalWorld);
   virtual DtPhysicalWorld* physicalWorld();
   virtual const DtPhysicalWorld* physicalWorld() const;


   virtual void setCommModelManager(DtCommModelManager* newCommModelManager);
   virtual DtCommModelManager* commModelManager();
   virtual const DtCommModelManager* commModelManager() const;


   virtual void setSimTerrainRequestManager(DtSimTerrainRequestManager* newSimTerrainRequestManager);
   virtual DtSimTerrainRequestManager* simTerrainRequestManager();
   virtual const DtSimTerrainRequestManager* simTerrainRequestManager() const;

   virtual void setVrfObjectManager (DtVrfObjectManager* entityManager);
   virtual DtVrfObjectManager* vrfObjectManager();
   virtual const DtVrfObjectManager* vrfObjectManager() const;

   virtual void setVrfNavAreaManager(DtVrfNavAreaManager* navAreaManager);
   virtual DtVrfNavAreaManager* vrfNavAreaManager();
   virtual const DtVrfNavAreaManager* vrfNavAreaManager() const;

   virtual void setSpawnSinkManager(DtSpawnSinkManager* spawnSinkManager);
   virtual DtSpawnSinkManager* spawnSinkManager();
   virtual const DtSpawnSinkManager* spawnSinkManager() const;

   virtual void setEmbeddedEntityInfoManager(DtEmbeddedEntityInfoManager* eeInfManager);
   virtual DtEmbeddedEntityInfoManager* embeddedEntityInfoManager();
   virtual const DtEmbeddedEntityInfoManager* embeddedEntityInfoManager() const;

   virtual void setScriptedTaskManager (DtScriptedTaskManager*);
   virtual DtScriptedTaskManager* scriptedTaskManager();
   virtual const DtScriptedTaskManager* scriptedTaskManager() const;

   virtual void setScenarioEventManager (DtScenarioEventManager*);
   virtual DtScenarioEventManager* scenarioEventManager();
   virtual const DtScenarioEventManager* scenarioEventManager() const;

   virtual void setHazardAreaManager (DtHazardAreaManager*);
   virtual DtHazardAreaManager* hazardAreaManager();
   virtual const DtHazardAreaManager* hazardAreaManager() const;

   virtual void setIntelCollectionAreaManager (DtIntelCollectionAreaManager*);
   virtual DtIntelCollectionAreaManager* intelCollectionAreaManager();
   virtual const DtIntelCollectionAreaManager* intelCollectionAreaManager() const;

   virtual void setScriptedObjectsMovementManager (DtScriptedObjectsMovementManager*);
   virtual DtScriptedObjectsMovementManager* scriptedObjectsMovementManager();
   virtual const DtScriptedObjectsMovementManager* scriptedObjectsMovementManager() const;

   virtual void setAggregateSpatialModel (DtAggregateSpatialModel* aggregateSpatialModel);
   virtual DtAggregateSpatialModel* aggregateSpatialModel();
   virtual const DtAggregateSpatialModel* aggregateSpatialModel() const;

   virtual void setDetonationManager(DtDetonationManager* detonationManager);
   virtual DtDetonationManager* detonationManager();

   virtual void setFireManager(DtFireManager* fireManager);
   virtual DtFireManager* fireManager();


   virtual void setGlobalPlanManager(DtGlobalPlanManager* planManager);
   virtual const DtGlobalPlanManager* globalPlanManager() const;
   virtual DtGlobalPlanManager* globalPlanManager();


   virtual void setStealthCommandsManager(DtStealthCommandsManager* planManager);
   virtual const DtStealthCommandsManager* stealthCommandsManager() const;
   virtual DtStealthCommandsManager* stealthCommandsManager();


   virtual void setHostilityManager(DtHostilityManager* hostilityManager);
   virtual const DtHostilityManager* hostilityManager() const;
   virtual DtHostilityManager* hostilityManager();


   virtual void setScenarioExtrasMgr(DtScenarioExtrasMgr* scenarioExtrasMgr);
   virtual const DtScenarioExtrasMgr* scenarioExtrasMgr() const;
   virtual DtScenarioExtrasMgr* scenarioExtrasMgr();


   virtual void setSimCommandDistributor(DtSimCommandDistributor* distributor);
   virtual const DtSimCommandDistributor* simCommandDistributor() const;
   virtual DtSimCommandDistributor* simCommandDistributor();

   virtual void setScenarioRunId(int);
   virtual int scenarioRunId() const;

   virtual void setRejectMismatchedScenarioMessages(bool);
   virtual bool rejectMismatchedScenarioMessages() const;

   virtual bool rejectMessage(const DtVrfObjectMessage*) const;

   virtual DtVrfSimSettingsManager* vrfSimSettingsManager();
   
   virtual void addMessageCallback(int type, DtMessageCallbackFcn fcn, 
      void* usrData);

   virtual void removeMessageCallback(int type, DtMessageCallbackFcn fcn, 
      void* usrData);


   virtual DtU32 scenarioCapabilities() const;
   virtual void setScenarioCapabilities(DtU32 v);


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

   virtual DtVrfTDLMessageInterface* tdlMessageInterface() const;

   static void TickFunction(void* userData);

   virtual void registerInterfaceCallbacks();

   virtual bool registerExtendedProperties();

   virtual const DtSimulationAddress& messageAddress() const;

   static void randSeedCallback(DtSimMessage* msg, void* usr);

   virtual unsigned long sequenceNumber();

   virtual void setSequenceNumber(unsigned long sequenceNumber);

   DtResourceMonitor* resourceMonitor();
   void setResourceMonitor(DtResourceMonitor*);

   virtual int vrfSessionId() const;

   virtual int vrfMessageVersionSupported() const;

   virtual void runForDuration(double);
   virtual double runDurationTime() const;

   virtual void stopSimulationDurationTimer();

   static void runDurationCompleteCallback(DtTimer*);
   virtual void processRunDurationComplete();

   virtual void addSimulationRunDurationCallback(DtRunDurationCallbackFcn tickFunction, void* userData);
   virtual void removeSimulationRunDurationCallback(DtRunDurationCallbackFcn tickFunction, void* userData);

protected:
   DtVrfSimOptionsInterface*    mySimOptions;

   DtScheduler*                 myScheduler;
   DtExerciseClock*             myExerciseClock;
   DtNoArgumentCallbackList     myTickList;
   DtNoArgumentCallbackList     myPostTickList;
   DtFrameRateMonitor*          myFrameRateMonitor;
   DtVrfSimSettingsManager*     myVrfSimSettingsManager;
   DtVrfMessageInterface*       myMessageInterface;
   DtVrfTDLMessageInterface*    myTDLMessageInterface;

   DtExerciseConn*              myExerciseConn;
   DtPhysicalWorld*             myPhysicalWorld;
   DtCommModelManager*          myCommModelManager;
   DtSimTerrainRequestManager*  mySimTerrainRequestManager;
   DtVrfObjectManager*          myVrfObjectManager;
   DtEmbeddedEntityInfoManager* myEmbeddedEntityInfoManager;
   DtAggregateSpatialModel*     myAggregateSpatialModel;
   DtDetonationManager*         myDetonationManager;
   DtFireManager*               myFireManager;
   DtGlobalPlanManager*         myGlobalPlanManager;
   DtStealthCommandsManager*    myStealthCommandsManager;
   DtHostilityManager*          myHostilityManager;
   DtScenarioExtrasMgr*         myScenarioExtrasMgr;
   DtResourceMonitor*           myResourceMonitor;
   DtScriptedTaskManager*       myScriptedTaskManager;
   DtScenarioEventManager*      myScenarioEventManager;
   DtHazardAreaManager*         myHazardAreaManager;
   DtIntelCollectionAreaManager*         myIntelCollectionAreaManager;
   DtScriptedObjectsMovementManager*   myScriptedObjectsMovementManager;
   DtParallelTickManager*       myParallelTickManager;
   bool                         myParallelTickManagerEnabled;
   DtVrfNavAreaManager*            myVrfNavAreaManager;
   DtSpawnSinkManager*          mySpawnSinkManager; 
   DtSimCommandDistributor*     mySimCommandDistributor;

   DtTimer* mySimulationDurationTimer;
   DtNoArgumentCallbackList     mySimulationDurationCallbackList;
   double myRunDurationTime;

   int myScenarioRunId;
   bool myRejectMismatchedScenarioMessages;
   DtU32 myScenarioCapabilities;
};

inline DtResourceMonitor* DtSimManager::resourceMonitor()
{
   return myResourceMonitor;
}

inline void DtSimManager::setResourceMonitor(DtResourceMonitor* m)
{
   myResourceMonitor = m;
}