lgrEditorDriver.h

Go to the documentation of this file.

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



#ifndef lgrEditorDriver_H_
#define lgrEditorDriver_H_

#include <lgrCore/lgrDriver.h>
#include <lgrCore/lgrExportType.h>
#include <lgrUtil/filePosition.h>
#include <map>

class DtThread;
class DtRunnable;

namespace MAKLogger
{
   class DtLgrEditorCommandFactory;
   class DtLgrEditorInterface;
   class DtLgrEditorThread;
   class DtLgrFileInput;
   class DtLgrFileOutput;
   class DtLgrPacketPrinter;
   class DtLgrPacketPrinterOutput;
   class DtLgrPlaybackDriver;
   class DtLgrRecordDriver;
   class DtMessageInput;
   class DtMessageOutput;
   class DtMessageState;
   class DtLgrSystemDriver;

   class DT_DLL_LGRCORE DtLgrEditorDriver : public DtLgrCommandHandler
   {
   public:

      typedef DtLgrEditorCommandFactory Factory;
      typedef DtLgrEditorInterface Interface;

      typedef std::map<DtString,DtLgrExportType> ExportTypeMap;

      DT_VIRTUAL_CTR(DtLgrEditorDriver,(DtLgrSystemDriver&))

      virtual ~DtLgrEditorDriver();

      virtual void tick();

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

      virtual DtResponse addExportType(const DtCommand& command);

      virtual DtResponse exportFile(const DtCommand& command);

      virtual DtResponse exportSection(const DtCommand& command);

      virtual DtResponse clearSection(const DtCommand& command);

      virtual DtResponse cutSection( const DtCommand& command);

      virtual DtResponse mergeInFile( const DtCommand& command);

      virtual DtResponse appendFileToEnd( const DtCommand& command);

      virtual DtResponse prefixFileToStart( const DtCommand& command);

      virtual DtResponse trimStart( const DtCommand& command);

      virtual DtResponse offsetTime( const DtCommand& command);

      virtual DtResponse convertFile( const DtCommand& command);

      virtual DtResponse recheckpointOnExport( const DtCommand& command);

      const ExportTypeMap& exportTypes() const;


   public:

      static const DtString& exportLoggerFileType();

      static const DtString& exportMultipleFileType();

   protected:

      virtual void finishEditOperation();

      void convertOperation();

      void exportOperation( const DtString& fileFormat,
         const DtString& filename, const DtAbsoluteTime& startTime,
         const DtAbsoluteTime& endTime, const DtRelativeTime& offset,
         bool checkpoint, bool openAfterExport, bool silentSpawnThread);

      void mergeOperation( const DtString& filename,
         const DtRelativeTime& offset);

      void offsetOperation(const DtRelativeTime& offset);

      void completeFileOperation( bool success,DtString outputName,
         bool selectAll);

      virtual void exportToFile(const DtString& fileExportType, const DtString& filename,
         DtAbsoluteTime startTime, DtAbsoluteTime endTime, DtRelativeTime offset,
         bool checkpoint, bool openAfterExport, bool silentSpawnThread);

      void exportToMultipleFiles(const DtString& destination, DtAbsoluteTime startTime,
         DtAbsoluteTime endTime, DtRelativeTime offset, bool checkpoint,
         bool openAfterExport, bool silentSpawnThread);

      virtual void exportToPrinter(const DtString& exportType,
         DtLgrPacketPrinter* printer, const DtString& destination,
         DtAbsoluteTime startTime, DtAbsoluteTime endTime,
         DtRelativeTime offset, bool generateData, bool silentSpawnThread);

      virtual void clearSectionOperation(const DtAbsoluteTime& start,
         const DtAbsoluteTime& end);

      virtual void cutSectionOperation(const DtAbsoluteTime& start,
         const DtAbsoluteTime& end);

      virtual bool preparePlaybackFileAndPrinter(DtLgrFileInput** fileInput,
         DtLgrPacketPrinterOutput** printerOutput, DtLgrPacketPrinter* printer,
         const DtString& destination);

      bool prepareRecordFileAndPrinter(DtLgrFileInput** fileInput,
         DtLgrPacketPrinterOutput** printerOutput, DtLgrPacketPrinter* printer,
         const DtString& printerDestination,DtFilePosition firstPacket,
         DtFilePosition lastPacket);

      virtual bool preparePlaybackFileForEditing(DtLgrFileInput** fileInput,
         DtLgrFileOutput** fileOutput);

      virtual bool prepareRecordFileForEditing( DtLgrFileInput** fileInput,
         DtLgrFileOutput** fileOutput, const DtString& filename,
         DtFilePosition firstPacekt,DtFilePosition lastPacket);

      virtual bool prepareFileForInput(const DtLgrFileInput* existingInput,
         DtLgrFileInput** secondaryInput, const DtString& filename );

      virtual DtLgrPlaybackDriver* getPlaybackDriver(bool checkForFileOpen) const;

      virtual DtLgrRecordDriver* getRecordDriver() const;


   protected:

      DtLgrSystemDriver& mySystemDriver;

      typedef std::map<DtString,DtLgrPacketPrinter*> PacketPrinterMap;

      PacketPrinterMap myExportPrinters;

      ExportTypeMap myExportTypes;

      int myPacketOperationCount;

      DtString myCurrentOperationName;

      bool myDeleteSecondaryInputFlag;

      bool myRecheckpointOnExport;

   protected:
      static DtLgrExportType theExportLoggerFileType;

      static DtLgrExportType theExportMultipleFileType;

   };

}

#endif