lgrDisSimManager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2025 MAK Technologies, Inc
** All rights reserved.
******************************************************************************/


#ifndef lgrDisSimManager_H_
#define lgrDisSimManager_H_

#if DtDIS

#include <lgrSim/lgrSim.h>
#include <lgrSim/lgrBaseSimManager.h>
#include <lgrUtil/virtualConstructor.h>
#include <lgrUtil/absoluteTime.h>
#include <lgrCore/lgrConfigData.h>

#include <vl/pduCallbackManager.h>
#include <map>
#include <set>

class DtPdu;
class DtExerciseConn;
class DtExerciseConnInitializer;
class DtObjectPublisher;
enum DtPduKind;

namespace MAKLogger
{

   class DtDisDescriptor;
   class DtLgrPublisherInterface;
   class DtLgrDisMessageState;
   class DtLgrDisSimInput;
   class DtLgrDisSimOutput;
   class DtLgrFileOutput;
   class DtLgrDisEntityTypeManager;
   class DtLgrDisSimDriver;

   class DT_DLL_LGRSIM DtLgrDisSimulationManager : public DtLgrBaseSimManager
   {
   public:

      typedef DtLgrPublisherInterface* (*LgrPublisherCreator)\
         (DtLgrDisSimulationManager&,const DtPdu& pdu);

   public:

      DT_VIRTUAL_CTR(DtLgrDisSimulationManager,(DtLogger& logger, DtLgrDisSimDriver& simDriver))

      virtual ~DtLgrDisSimulationManager();

      virtual void tick();

      virtual bool isConnected() const;

      virtual bool isConnectionOk() const;

      virtual bool connect(DtExerciseConnInitializer& initializer, DtString& failureReason);

      virtual void disconnect();

      virtual DtLgrDisSimDriver& simDriver();

      virtual const DtLgrDisSimDriver& simDriver() const;

      virtual const DtLgrSimInput* input() const;
      virtual DtLgrSimInput* input();

      virtual const DtLgrSimOutput* output() const;
      virtual DtLgrSimOutput* output();

      virtual const DtMessageState* state() const;
      virtual DtMessageState* state();

      virtual DtMessageState* createState() const;

      virtual DtLgrFileInput* openFileForInput(const DtString& filename) const;

      virtual DtLgrFileOutput* openFileForCopying(const DtString& filename,
         const DtLgrFileInput* input) const;

      virtual DtLgrFileOutput* openFileForOutput(const DtString& filename, 
         const DtString& description) const;

      virtual DtLgrFileInput* openPartialFileForCopying(
         const DtLgrFileOutput* output , DtFilePosition firstPacket,
         DtFilePosition lastPacket) const;

      virtual void addReceivePduCallback(DtPduCallbackFcn receivePduCb,void* usr);
      virtual void removeReceivePduCallback(DtPduCallbackFcn receivePduCb,void* usr);

      virtual void sendPdu(DtPdu& pdu);

      virtual void registerPublisher(DtPduKind,LgrPublisherCreator);

      virtual void removePublisherCreator(DtPduKind);

      virtual bool pduNeedsPublisher(DtPduKind pduKind) const;

      virtual DtLgrPublisherInterface* createPublisher(const DtPdu& pdu);

      virtual DtRelativeTime heartbeatRate() const;

      virtual void setHeartbeatRate(DtRelativeTime time);

      virtual DtRelativeTime timeoutRate() const;

      virtual void setTimeoutRate(DtRelativeTime time);

      virtual bool scaleArticulatedParts() const;

      static DtVector scaleVector(const DtVector& vec,double scaleValue);

      virtual void setDisDescription(DtDisDescriptor* desc);

      virtual void setDrainInputMaxTime(double maxTime);

      virtual double drainInputMaxTime() const;

      virtual void setNumPdusToReadPerTimeCheck(int number);

      virtual int numPdusToReadPerTimeCheck() const;

      virtual const DtDisDescriptor* disDescription() const;
      virtual DtDisDescriptor* disDescription();

      virtual void setEntityTypeManager(DtLgrDisEntityTypeManager* mgr);

      virtual DtLgrDisEntityTypeManager* entityTypeManager();
      virtual const DtLgrDisEntityTypeManager* entityTypeManager() const;

      virtual void setConfigurationFileName(const DtString& filename);

   protected:

      static DtLgrPublisherInterface* createEntityStatePublisher(
         DtLgrDisSimulationManager&, const DtPdu& pdu);

      static DtLgrPublisherInterface* createDesignatorPublisher(
         DtLgrDisSimulationManager&, const DtPdu& pdu);

      static DtLgrPublisherInterface* createAggregateStatePublisher(
         DtLgrDisSimulationManager&,const DtPdu& pdu);

      static DtLgrPublisherInterface* createEnvironmentalProcessPublisher(
         DtLgrDisSimulationManager&,const DtPdu& pdu);

      static DtLgrPublisherInterface* createTransmitterPublisher(
         DtLgrDisSimulationManager&,const DtPdu& pdu);

      static DtLgrPublisherInterface* createReceiverPublisher(
         DtLgrDisSimulationManager&,const DtPdu& pdu);

      static DtLgrPublisherInterface* createGriddedDataPublisher(
         DtLgrDisSimulationManager&,const DtPdu& pdu);

      typedef std::map<DtPduKind,LgrPublisherCreator> DtPublisherFunctionMap;

      typedef std::set<DtPduKind> DtPduKindSet;

      DtPduKindSet myPublishedKinds;
      DtPduKindSet myMessageStateKinds;
      DtPublisherFunctionMap myPublisherMap;
      DtLgrDisMessageState* myMessageState;
      DtLgrDisSimInput* myInput;
      DtLgrDisSimOutput* myOutput;
      DtDisDescriptor* myDisDescriptor;
      DtLgrDisEntityTypeManager* myEntityTypeManager;
      DtLgrDisSimDriver& mySimDriver;

      DtRelativeTime myHeartbeatRate;
      DtRelativeTime myTimeoutRate;
      bool myScaleArticulatedpartsFlag;
      double myDrainInputMaxTime;
      int myNumPdusToReadPerTimeCheck;

      DtLgrConfigData myConfigData;
   };

}

#endif
#endif