lgrLegacyUncheckpointedFormat.h

Go to the documentation of this file.

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


#ifndef lgrLegacyUncheckpointedFormat_H_
#define lgrLegacyUncheckpointedFormat_H_

#include "lgrFileFormatter.h"
#include "filePosition.h"
#include <vlutil/vlNetTypes.h>
#include <vlutil/vlTime.h>

#include "memoryBuffer.h"

namespace MAKLogger
{
   class DtPacket;

   class DT_DLL_LGRCORE DtLgrLegacyUncheckpointedFormat : public DtLgrFileFormatter
   {

   protected:
      DtLgrLegacyUncheckpointedFormat(DtLoggerFile*);
      virtual ~DtLgrLegacyUncheckpointedFormat();

   private:
      DtLgrLegacyUncheckpointedFormat(const DtLgrLegacyUncheckpointedFormat&);
      DtLgrLegacyUncheckpointedFormat& operator=(const DtLgrLegacyUncheckpointedFormat&);
   public:

      virtual void initializeSerialMode(DtFilePosition firstPacket = 0,
         DtFilePosition lastPacket = 0);

      virtual void copyMetaData(const DtLgrFileFormatter* formatter);



      virtual bool isEofValid() const;

      virtual bool hasLastPacket() const;

      virtual bool recoverLastPacket();

      virtual bool atEndOfFile();

      virtual bool seekToFirstPacket();

      virtual bool seekToFirstPacket(int type);

      virtual bool seekToLastPacket();

      virtual bool seekToLastPacket(int type);

      virtual bool seekToFirstPacketBeforeTime(double time);

      virtual bool seekToFirstPacketBeforeTime(int type,double time);

      virtual bool seekToFirstPacketAfterTime(double time);

      virtual bool seekToFirstPacketAfterTime(int type,double time);

      virtual bool seekToNextSerialPacket();

      virtual bool seekToNextPacket();

      virtual bool seekToNextPacket(int type);

      virtual bool seekToPreviousPacket();

      virtual bool seekToPreviousPacketOfType(int type);

      virtual void seekToPosition(DtFilePosition);

      virtual double currentPacketTime();

      virtual bool validPacket(double previousPacketTime = -1.0,
         double* currentTime=0);

      virtual int currentPacketType();

      virtual size_t currentPacketSize();

      virtual size_t currentPacketDataSize();

      virtual DtFilePosition currentPosition();

      virtual bool hasCheckpoints() const;

      virtual void readMetaData(DtLoggerFileMetaData::DataPosition position);

      virtual void readMetaData();

      virtual void writeMetaData(DtLoggerFileMetaData::DataPosition position);

      virtual char* readPacketIntoBuffer(char* cur, char* end, DtMessageBuffer& messages, DtMemoryBufferSP& buffer);

      virtual void readPacketsUptoCount(DtMessageBuffer&,DtMemoryBufferSP,int packetCount);

      virtual void readPacketsUptoSize(DtMessageBuffer&,DtMemoryBufferSP);

      virtual double readPacketsUpToTime(DtMessageBuffer&,DtMemoryBufferSP,
         double time,bool inclusive = true);

      virtual void writePackets(const DtMessageBuffer&);

      virtual void writePacket(const DtPacket& packet);

      virtual size_t writePacket(const DtPacket& packet,void* memory,size_t memorySize,
         int fileWriteBufferOffset = -1);

      virtual void setDuration(double duration);

      virtual double duration() const;

      virtual void setDescription(DtString description);

      virtual DtString description() const;


      virtual size_t headerSize() const;

      virtual size_t tailSize() const;

      virtual double firstPacketTime() const;

      virtual size_t firstPacketSize() const;

      virtual double lastPacketTime() const;

      virtual size_t lastPacketSize() const;


   protected:

      struct NetPacketHeader
      {
         DtNetU32 numBytes;
         DtNetU32 flags;
         DtNetFloat64 arrivalTime;
      };

      struct NetPacketTail
      {
         DtNetU32 numBytes;
      };

      virtual DtFilePosition firstPacketPosition() const;

      virtual DtFilePosition lastPacketPosition() const;

      virtual size_t readPreviousPacketSize();

      virtual void fillHeader(void* header, const DtPacket& packet);

      virtual void writeHeader(int fd, const DtPacket& packet);

      virtual DtNetU32 headerNumBytes(void* header);

      virtual DtNetU32 headerFlags(void* header);

      virtual DtNetFloat64 headerArrivalTime(void* header);

      virtual void setFileEmpty();

      virtual void setFirstPacket();

      virtual void setLastPacket();

      virtual void findFirstSerialPacket(DtFilePosition firstPacket);

      virtual void findLastSerialPacket(DtFilePosition lastPacket);

      virtual DtPacket* readPacket();

      virtual void validateTime(double time);

      virtual void initReadStartMetaData();

      virtual void readStartMetaData();

      virtual void initReadMiddleMetaData();

      virtual void readMiddleMetaData();

      virtual void initReadEndMetaData();

      virtual void readEndMetaData();

      virtual void writeStartMetaData();

      virtual void writeMiddleMetaData();

      virtual void writeEndMetaData();

      int fd();



      virtual void validateType(int type) = 0;

      virtual int decodeTypeFromFlags(unsigned int flags) = 0;



   protected:

      // When reading a start metadata packet (from start of file forward),
      // save the position of next packet (i.e., the end of start)
      DtFilePosition myEndOfStartMetadata;
      // When reading an end metadata packet (from eof back),
      // save the position of the packet being read (i.e., the start of end)
      DtFilePosition myStartOfEndMetadata;
      DtFilePosition myFirstPacketPosition;
      DtFilePosition myLastPacketPosition;
      double myFirstPacketTime;
      double myLastPacketTime;
      size_t myFirstPacketSize;
      size_t myLastPacketSize;
      bool myIsEmptyFlag;
      double myPreviousArrivalTime;
      int myPreviousType;

      DtClock myProfilingClock;
   };
}

#endif