lgrSimManager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
******************************************************************************/


#ifndef lgrSimManager_H_
#define lgrSimManager_H_

#include <lgrCore/lgrCore.h>
#include <lgrUtil/filePosition.h>
#include <lgrCore/lgrSimDriver.h>
#include <vlutil/vlString.h>
#include <list>
#include <lgrCore/lgrEntityTracker.h>

namespace MAKLogger
{

   class DtPacket;
   class DtLgrPacketFilter;
   class DtAbsoluteTime;
   class DtLgrSimInput;
   class DtLgrSimOutput;
   class DtLgrFileInput;
   class DtLgrFileOutput;
   class DtMessageState;
   class DtLegacyLoggerFile;
   class DtTimeProvider;
   class DtLgrClock;
   class DtCheckpointPolicy;
   class DtLgrVRFMessageFilter;
   class DtMessageIOInfo;
   class DtMessagePipeline;

   class DT_DLL_LGRCORE DtLgrSimManager
   {
   public:
      DtLgrSimManager();
      virtual ~DtLgrSimManager();

      virtual bool isConnected() const = 0;

      virtual void tick() = 0;

      virtual bool scaleAttributes() const;

      virtual void setScaleAttributes(bool enable);

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

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

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

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

      virtual DtMessageState* createState() const = 0;

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

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

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

      virtual void activateIdleListening(DtMessagePipeline* pipeLine);

      virtual void deactivateIdleListening(DtMessagePipeline* pipeLine);


      virtual void setEntitiesForRefresh(const DtLgrEntityTracker::EntryHandleSet& handleSet);
      virtual const DtLgrEntityTracker::EntryHandleSet& entitiesForRefresh() const;
      virtual void clearEntitiesForRefresh();

      virtual void setTimeProvider(DtTimeProvider* provider);


      virtual DtTimeProvider* timeProvider();
      virtual const DtTimeProvider* timeProvider() const;

      virtual DtAbsoluteTime simTime() const;

      virtual void setSimTime(DtAbsoluteTime simTime);

      virtual void setAdjustSimTime(bool adjustSimTime);

      virtual bool isSimTimeAdjusted() const;

      virtual DtAbsoluteTime adjustedSimTime(DtAbsoluteTime packetTime) const;

      virtual void setTimeJump(DtAbsoluteTime jumpTime);

      virtual bool activity() const = 0;

      virtual int remoteControlId() const;

      virtual void setRemoteControlId(int id);

      virtual void activateFilters(const DtMessageIOInfo* info);

      virtual void deactivateFilters();

      virtual bool filter(DtPacket* packet);

      virtual int addFilter(DtLgrPacketFilter* filter);

      virtual int removeFilter(const DtLgrPacketFilter* filter);

      virtual int filterCount() const;

      virtual int filterIndex(const DtLgrPacketFilter* filter) const;


      virtual DtLgrPacketFilter* filterByIndex(int index);
      virtual const DtLgrPacketFilter* filterByIndex(int index) const;

      virtual void setHeartbeatIntervals(const std::map<DtString, DtLgrSimDriver::HeartbeatTimeRecord>& intervals);
      virtual const std::map<DtString, DtLgrSimDriver::HeartbeatTimeRecord>& heartbeatIntervals() const;

      virtual void setTimeoutIntervals(const std::map<DtString, DtLgrSimDriver::HeartbeatTimeRecord>& intervals);
      virtual const std::map<DtString, DtLgrSimDriver::HeartbeatTimeRecord>& timeoutIntervals() const;

      virtual void updateEntityTracker(const DtString& tracker);

      virtual void setAllowEntityTracking(bool trackingEnabled);

      virtual DtLgrEntityTracker* entityTracker();

      virtual const DtLgrEntityTracker* entityTracker() const;

      virtual const std::vector<DtString>& filterEntityList();

      virtual void addTemporaryTrackedEntity(const DtString& name);

      virtual void setEntityTracker(DtLgrEntityTracker* tracker);

      //Add list of entity IDs to the current filterEntityList
      virtual void addToFilterEntityList( const std::vector<DtString>& nameList);

      virtual void setConfigurationFileName(const DtString& filename) = 0;

      virtual void initPlayback(DtLgrFileInput& input);


      virtual bool playbackFilesUseRandomAccess() const;
      virtual void setPlaybackFilesUseRandomAccess(bool val);


      virtual double extendedStopTimeoutInterval() const;
      virtual void setExtendedStopTimeoutInterval(double interval);

      virtual bool listenWhenIdle() const;

      virtual void setListenWhenIdle(bool val);

      virtual bool staticDRAlgorithmWhenPaused() const;

      virtual void setStaticDRAlgorithmWhenPaused(bool staticDRAlgorithm);

   protected:


      DtTimeProvider* myTimeProvider;
      DtLgrClock* myClock;
      double myBasePacketTime;
      double myJumpPacketTime;
      int myRemoteControlId;
      DtLgrEntityTracker* myEntityTracker;
      std::vector<DtString> myFilterEntityList;
      DtLgrEntityTracker::EntryHandleSet myEntitiesToRefresh;
      bool myIsTrackingEnabled;
      bool myScaleAttributesFlag;
      typedef std::list<DtLgrPacketFilter*> FilterList;
      FilterList myFilterList;
      std::map<DtString, DtLgrSimDriver::HeartbeatTimeRecord> myHeartbeatIntervals;
      std::map<DtString, DtLgrSimDriver::HeartbeatTimeRecord> myTimeoutIntervals;
      bool myPlaybackFilesUseRandomAccess;
      double myExtendedStopTimeoutInterval;
      bool myListenWhenIdle;
      bool myAdjustSimTime;
      bool myStaticDRAlgorithmWhenPaused;

   };

}

#endif