lgrRecordDriver.h

Go to the documentation of this file.

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


#ifndef lgrRecordDriver_H_
#define lgrRecordDriver_H_

#include "lgrDriver.h"
#include "absoluteTime.h"
#include "messageBuffer.h"
#include <vlutil/vlRunnable.h>

class DtThread;

namespace MAKLogger
{
   class DtCheckpointPolicy;
   class DtLgrClock;
   class DtLgrFileInput;
   class DtLgrFileOutput;
   class DtLgrPlaybackDriver;
   class DtLgrRecordCommandFactory;
   class DtLgrRecordInterface;
   class DtMessagePipeline;
   class DtThreadedObject;
   class DtLgrEditorThread;

   class DT_DLL_LGRCORE DtLgrRecordDriver : public DtLgrCommandHandler
   {
   public:
      typedef DtLgrRecordCommandFactory Factory;
      typedef DtLgrRecordInterface Interface;

      DT_VIRTUAL_CTR(DtLgrRecordDriver,(DtLgrSystemDriver&))

      virtual ~DtLgrRecordDriver();

      virtual void tick();

      virtual bool releasePipeline();
      virtual bool getPipeline();
      virtual bool hasPipeline() const;

      virtual bool isFileOpen() const;
      virtual bool isFileEmpty() const;

      virtual bool isRecording() const;
      virtual bool isPaused() const;

      virtual bool pauseOnRecordAs() const;

      int checkpointPolicyId() const;

      int checkpointCount() const;

      int checkpointSize() const;

      DtAbsoluteTime checkpointTime() const;

      virtual const DtString& filename() const;

      virtual DtCheckpointPolicy* duplicateCheckpointPolicy() const;

      virtual bool recordToMultipleFiles() const;

      virtual double multipleFileDuration() const;

      const DtString& multipleFileNamingConvention() const;

      virtual const DtLgrFileOutput* currentOutput() const;

      virtual bool spawnThread(DtLgrEditorThread* editorThread);

      virtual void stopAllThreads();

      virtual void stopThread( DtLgrEditorThread* runningThread );

      virtual void addTemporaryTrackedEntity(const DtString& name);

   protected:

      DtLgrPlaybackDriver* getPlaybackDriver(bool checkForFileOpen) const;

      virtual void setCheckpointPolicy(DtCheckpointPolicy* policy);

      void tickNormalRecording();

      void tickRecordToMultipleFiles(double multipleFileDuration);

      DtResponse newFile(const DtCommand& command);
      DtResponse closeFile(const DtCommand& command);
      DtResponse cancelRecording(const DtCommand& command);
      DtResponse record(const DtCommand& command);
      DtResponse pause(const DtCommand& command);
      DtResponse unpause(const DtCommand& command);
      DtResponse stop(const DtCommand& command);
      DtResponse stopCondition(const DtCommand& command);
      DtResponse stopDuration(const DtCommand& command);
      DtResponse stopSize(const DtCommand& command);
      DtResponse setCheckpointParameters(const DtCommand& command);
      DtResponse setPauseOnRecordAs(const DtCommand& command);
      DtResponse saveRecordedData(const DtCommand& command);
      DtResponse saveRecordedDataFinished(const DtCommand& command);
      DtResponse setRecordToMultipleFilesSettings(const DtCommand& command);
      DtResponse startRecordToMultipleFiles(const DtCommand& command);

      class DumpCurrentRecordingThread : public DtRunnable
      {
      public:
         DumpCurrentRecordingThread( MAKLogger::DtLgrSystemDriver* driver,
            DtString newFileName, DtLgrFileInput* input,
            DtLgrFileOutput* output, int packetOperationCount,
            double fixedDuration,DtRelativeTime offset);

         virtual ~DumpCurrentRecordingThread();

         virtual void run();

      protected:
         DtCommandInterface* myInterface;
         DtString myFilename;
         DtLgrFileInput* myInputFile;
         DtLgrFileOutput* myOutput;
         int  myPacketOperationCount;
         DtRelativeTime myFixedDuration;
         DtRelativeTime myOffset;
      };


      virtual void configurePipeline();

      virtual bool doNewFile(DtString filename,bool overwrite);
      virtual bool doRecord(bool multipleFiles);
      virtual bool doStop();
      virtual bool doPause();
      virtual bool doUnpause();

      DtString multipleFileName() const;

      DtString myFileName;
      DtLgrFileOutput* myFileOutput;
      DtLgrSystemDriver* myDriver;
      DtMessagePipeline* myPipeline;

      DtCheckpointPolicy* myCheckpointPolicy;
      int myCheckpointPolicyId;
      int myCheckpointPolicyCount;
      int myCheckpointPolicySize;
      DtAbsoluteTime myCheckpointPolicyTime;

      DtLgrClock* myRecordingClock;
      DtAbsoluteTime myCurrentTime;

      bool myRecordingFlag;
      bool myPausedFlag;
      bool myPauseOnRecordAsFlag;
      bool myFileEmptyFlag;
      int myStopCondition;
      bool myStopConditionClose;
      DtRelativeTime myStopDuration;
      DtU64 myStopSize;
      int myPacketOperationCount;
      bool mySavingRecordingData;
      DtThreadedObject* myDumpThread;

      bool myRecordToMultipleFiles;
      double myMultipleFileDuration;
      DtString myMultipleFileNamingConvention;
      DtAbsoluteTime myTimeToSaveMultipleFiles;
      int myMultipleFileIndex;
      DtFilePosition myNextSavePosition;
      DtMessageBuffer* myCompleteState;


      typedef std::map<DtLgrEditorThread*,DtThread*> ThreadMap;

      ThreadMap myRunningThreads;

      DtMessageBuffer myPauseTimeSnapshot;
   };

}

#endif