lgrDump Example

---

A logger plug-in which exports a logger file to a text file. This is a working example which is integrated into the actual logger. The output of the logger dump can be seen by using the export menu and selecting plain text.

The logger dump packet printers:

lgrDisPacketPrinter.h/cxx

lgrHlaPacketPrinter.h/cxx

lgrDisPacketPrinter.h/cxx

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


#if DtDIS

#ifndef lgrDisPacketPrinter_H_
#define lgrDisPacketPrinter_H_

#include "lgrDump.h"

#include <lgrPacketPrinter.h>
#include <messageBuffer.h>

#include <vlutil/vlTime.h>

class DtDisPduFactory;

namespace MAKLogger
{
   class DtPacket;

   class DT_DLL_LGRDUMP DtLgrDisPacketPrinter : public DtLgrPacketPrinter
   {
   public:

      DT_VIRTUAL_CTR(DtLgrDisPacketPrinter,(bool raw))
      DT_VIRTUAL_BASE_CTR(DtLgrPacketPrinter,(bool raw))

      
      virtual ~DtLgrDisPacketPrinter();
   
   private:
      DtLgrDisPacketPrinter(const DtLgrDisPacketPrinter&);
      DtLgrDisPacketPrinter& operator=(const DtLgrDisPacketPrinter&);   
   
   public:

      virtual void beginPrinting(const DtMessageIOInfo* info,
         const DtMessageInput* msgInput, const DtString& destination);

      virtual void printPacket( const DtPacket& packet );

      virtual void endPrinting();

   protected:

      std::ofstream& outputStream();

      virtual void printPacketHeader(const DtPacket& packet);

      virtual void printPacketTail(const DtPacket& packet);

      void printOtherPacket(const DtPacket& packet);

      void printConfigPacket(const DtPacket& packet);

      void printDateTimePacket(const DtPacket& packet);

      void printCheckpointPacket(const DtPacket& packet);

      void printIndexTablePacket(const DtPacket& packet);

      void printRecordingDataPacket(const DtPacket& packet);

      void printDescriptionPacket(const DtPacket& packet);

      void printEntityTablePacket(const DtPacket& packet);

      void printPausePacket(const DtPacket& packet);

      void printUnpausePacket(const DtPacket& packet);

      void printPduPacket(const DtPacket& packet);

   protected:

      typedef void (DtLgrDisPacketPrinter::*PacketPrintFunction)(const DtPacket&);
      typedef std::map<DtPacket::DtPacketType,PacketPrintFunction> PrintFunctionMap;
      
      DtDisPduFactory* myPduFactory;

      int myPduCount;
      int myPacketCount;
      int myCheckpointCount;

      bool myPrintRawData;
      PrintFunctionMap myPrintFunctionMap;
      std::ofstream* myOutputFile;

      DtTime myFileDateTime;

      DtMessageBuffer myEndMetadata;

      DtTime myUnpauseTime;

   };
}

#endif
#endif

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


#if DtDIS

#include "lgrDisPacketPrinter.h"
#include <disPacket.h>
#include <lgrFileInput.h>
#include <loggerPlaybackFile.h>
#include <lgrFileFormatter.h>
#include <lgrConfigData.h>
#include <lgrEntityTracker.h>
#include <lgrPacketIndexer.h>
#include <lgrPrint.h>
#include <lgrDisFileFormats.h>
#include <messageIoInfo.h>
#include <loggerFile.h>

#include <vl/enum2string.h>
#include <vl/disPduFactory.h>
#include <vl/unknownPdu.h>
#include <vlutil/vlPrint.h>
#include <vlutil/vlPrintUtil.h>

#include <iomanip>
#include <time.h>

namespace MAKLogger
{

   static bool printHeader = true;
   static bool printData = true;

   std::ostream& operator << (std::ostream & output, const DtPdu& pdu)
   {
      if(printHeader)
      {
         const char *str = DtEnumString(pdu.kind());
         if ((pdu.protocolVersion() == 4) &&
         pdu.kind() == DtMessagePduKind) { str = "MessagePduKind"; }

         DtString tmpStr = "Absolute";
         if (pdu.timeStampType() == DtRELATIVE) { tmpStr =  "Relative"; }

         DtPrintAndIndent(output, "PduKind");
         if (str)
         {
            output << str << "   (" << pdu.kind() << ")" <<  std::endl;
         }
         else
         {
            output << "   (" << pdu.kind() << ")" <<  std::endl;
         }
         DtPrintAttribute(output, "Version", pdu.protocolVersion());
         DtPrintAttribute(output, "Exercise", pdu.exerciseId());
         DtPrintAttribute(output, "ProtocolFamily", pdu.protocolFamily());
         DtPrintAttribute(output, "TimeStamp", pdu.timeStamp());
         DtPrintAttribute(output, "TimeStampType", tmpStr);
         DtPrintAttribute(output, "Size", pdu.length());
         output << "-----------------------------------------\n";
      }
      if(printData)
      {
         DtString str;
         pdu.printDataToString(str);
         output << str;
      }
      return output;
   }

   DtString DtTimeAndDate(double time)
   {
      double intPart = 0;
      time = modf(time, &intPart);

      int fractionalPart = time * 10000;
      time_t timeValue = intPart;
      struct tm * timeinfo;
      timeinfo = localtime ( &timeValue );

      char dateBuffer[80];
      char timeBuffer[80];
      strftime (dateBuffer,80," %a %b %d, %Y",timeinfo);
      strftime (timeBuffer,80,"%X",timeinfo);

      DtString dateAndTime(timeBuffer);
      dateAndTime += ".";
      sprintf(timeBuffer, "%04d", fractionalPart);
      dateAndTime += timeBuffer;
      dateAndTime += dateBuffer;

      return dateAndTime;
   }

DT_VIRTUAL_CTR_DEFINE(DtLgrDisPacketPrinter,(bool raw),
   (raw))

DT_VIRTUAL_BASE_CTR_DEFINE(DtLgrDisPacketPrinter,DtLgrPacketPrinter,
   (bool raw),(raw))

//
// Main (possibly default) constructor
//
DtLgrDisPacketPrinter::DtLgrDisPacketPrinter( bool raw)
   : DtLgrPacketPrinter()
   , myPduFactory( new DtDisPduFactory() )
   , myPduCount( 0 )
   , myPacketCount( 0)
   , myCheckpointCount(0)
   , myPrintRawData( raw )
   , myPrintFunctionMap()
   , myOutputFile(0)
   , myFileDateTime(-1)
   , myUnpauseTime(0)
{
   myPrintFunctionMap[DtPacket::Type_ConfigData] =      &DtLgrDisPacketPrinter::printConfigPacket;
   myPrintFunctionMap[DtPacket::Type_TapeTimeDate] =    &DtLgrDisPacketPrinter::printDateTimePacket;
   myPrintFunctionMap[DtPacket::Type_Pdu] =             &DtLgrDisPacketPrinter::printPduPacket;
   myPrintFunctionMap[DtPacket::Type_Checkpoint] =      &DtLgrDisPacketPrinter::printCheckpointPacket;
   myPrintFunctionMap[DtPacket::Type_EntityTable] =     &DtLgrDisPacketPrinter::printEntityTablePacket;
   myPrintFunctionMap[DtPacket::Type_RecordingData] =   &DtLgrDisPacketPrinter::printRecordingDataPacket;
   myPrintFunctionMap[DtPacket::Type_TapeDescription] = &DtLgrDisPacketPrinter::printDescriptionPacket;
   myPrintFunctionMap[DtPacket::Type_IndexTable] =      &DtLgrDisPacketPrinter::printIndexTablePacket;
   myPrintFunctionMap[DtPacket::Type_Pause] =           &DtLgrDisPacketPrinter::printPausePacket;
   myPrintFunctionMap[DtPacket::Type_Unpause] =         &DtLgrDisPacketPrinter::printUnpausePacket;
}

//
// Destructor
//
DtLgrDisPacketPrinter::~DtLgrDisPacketPrinter()
{
   endPrinting();
   delete myPduFactory;
   myPduFactory = 0;
}

void DtLgrDisPacketPrinter::printPacketHeader(const DtPacket& packet)
{
   std::ios_base::fmtflags original_flags = outputStream().flags();

   outputStream() << std::setfill(' ') << std::left;

   outputStream() << "**** Packet #" << std::setw(6) << myPacketCount
      << " Size=" << std::setw(6) << (unsigned int)packet.size()
      << " time=" << packet.time().toString(4);
   if (myFileDateTime > 0)
   {
      outputStream() << ", " << DtTimeAndDate(myFileDateTime - myUnpauseTime + packet.time().seconds());
   }
   outputStream() << std::endl;

   outputStream().flags(original_flags);
}

void DtLgrDisPacketPrinter::printPacketTail(const DtPacket& packet)
{
   outputStream() << "********************************************************************************" << std::endl;
}


void DtLgrDisPacketPrinter::printPacket( const DtPacket& packet )
{
   if(!myOutputFile)
   {
      DtLgrPrinter::warning("Unable to print packet, beginPrinting not called.");
      return;
   }

   if (packet.type() == DtPacket::Type_Unpause)
   {
      myFileDateTime = *(DtNetFloat64*)packet.data();
      myUnpauseTime = packet.time().seconds();

   }
   ++myPacketCount;
   printPacketHeader(packet);

   DtPacket::DtPacketType type = (DtPacket::DtPacketType)packet.type();
   PrintFunctionMap::iterator funcIter = myPrintFunctionMap.find(type);
   if(funcIter == myPrintFunctionMap.end())
   {
      printOtherPacket(packet);
   }
   else
   {
      // Nasty member function call syntax.
      (this->*funcIter->second)(packet);
   }
   printPacketTail(packet);
}

void DtLgrDisPacketPrinter::printOtherPacket(const DtPacket& packet)
{
   outputStream() << "******** Type=Other(" << packet.type()
      << ")************************************************" << std::endl;
}

void DtLgrDisPacketPrinter::printDateTimePacket(const DtPacket& packet)
{
   DtNetFloat64* netFileTime = (DtNetFloat64*)packet.data();
   DtFloat64 internalFileTime = *netFileTime;
   outputStream() << "******** Type=DateTime *********************************************************" << std::endl;
   outputStream() << "Time and date: " << DtTimeAndDate(internalFileTime) << std::endl;
}

void DtLgrDisPacketPrinter::printConfigPacket(const DtPacket& packet)
{
   std::ios_base::fmtflags original_flags = outputStream().flags();
   DtLgrConfigData config;

   config.deserialize(packet.data());

   outputStream() << std::setfill(' ') << std::left;
   outputStream() << "******** Type=Config ***********************************************************" << std::endl;
   outputStream() << "FileName:" << config.configFileName().string() << std::endl;
   outputStream() << config.configFileContents().string() << std::endl;
   outputStream().flags(original_flags);
}

void DtLgrDisPacketPrinter::printCheckpointPacket(const DtPacket& packet)
{
   std::ios_base::fmtflags original_flags = outputStream().flags();

   ++myCheckpointCount;

   outputStream() << std::setfill(' ') << std::left;
   outputStream() << "******** Type=Checkpoint #" << std::setw(10) << myCheckpointCount
      << "*******************************************" << std::endl;

    size_t sizeRead = 0;
    size_t totalRead = packet.size();
    const char* buffer = packet.data();

    int pduIndex = 0;
    while(sizeRead < totalRead)
    {
       int length = ((DtNetPduHeader*)buffer)->DtLength;
       if(length > 4000)
       {
           //Packet is larger than Maximum, stop processing checkpoint
          DtLgrPrinter::warning("Invalid PDU size, checkpoint data invalid/corrupted.");
          break;
       }
       else
       {
          DtPdu* pdu = myPduFactory->createPdu((DtNetPacket*)buffer, (DtBufferPtr)buffer);
          outputStream() << "************ Checkpoint PDU #" << std::setw(6) << pduIndex
             << " Size=" << std::setw(6) << (unsigned int)length << std::endl;
          pdu->printDataToStream(outputStream());
          delete pdu;
          buffer   += length;
          sizeRead += length;
       }
       pduIndex++;
    }
    outputStream().flags(original_flags);
}

void DtLgrDisPacketPrinter::printIndexTablePacket(const DtPacket& packet)
{
   std::ios_base::fmtflags original_flags = outputStream().flags();
   DtLgrPacketIndexer packetIndexer;
   packetIndexer.decodePacket(&packet);

   int indexCount = packetIndexer.indexCount();

   outputStream() << std::setfill(' ') << std::left;
   outputStream() << "******** Type=IndexTable Count=" << std::setw(6) << indexCount
      << " ******************************************" << std::endl;
   for (int index=0; index <indexCount; ++index)
   {
      outputStream() << std::setw(6) << index
         << " Position: " << packetIndexer.getPositionOfIndex(index)
         << " Time: " << packetIndexer.getTimeOfIndex(index)
         << " Size: " << packetIndexer.getSizeOfIndex(index) << std::endl;

   }
   outputStream().flags(original_flags);
}

void DtLgrDisPacketPrinter::printRecordingDataPacket(const DtPacket& packet)
{
   DtFloat64 duration = *(DtNetFloat64*)packet.data();
   outputStream() << "******** Type=RecordingInfo ****************************************************" << std::endl;
   outputStream() << "File Duration: " << duration << std::endl;
}

void DtLgrDisPacketPrinter::printDescriptionPacket(const DtPacket& packet)
{
   DtString description = packet.data();
   outputStream() << "******** Type=Description ****************************************************" << std::endl;
   outputStream() << "File Description: " << description << std::endl;
}

void DtLgrDisPacketPrinter::printEntityTablePacket(const DtPacket& packet)
{
   std::ios_base::fmtflags original_flags = outputStream().flags();
   DtLgrEntityTracker* tracker = DtLgrEntityTracker::create();

   tracker->decodePacket(&packet);

   outputStream() << std::setfill(' ') << std::left;
   outputStream() << "******** Type=EntityTable "
      << " Count=" << std::setw(6) << tracker->entityCount()
      << " ****************************************" << std::endl;

   DtLgrEntityTracker::EntryHandle entryIter = tracker->begin();
   DtLgrEntityTracker::EntryHandle entryEnd = tracker->end();
   for ( ; entryIter != entryEnd; ++entryIter)
   {
      outputStream() << "   " << std::setw(6) << entryIter
         << " Type: " << std::setw(20) << tracker->entityType(entryIter)
         << " Force: " << std::setw(2) << tracker->entityForce(entryIter)
         << std::setiosflags(std::ios::fixed) << std::setprecision(2) << std::right
         << " First: " << std::setw(10) << tracker->entityFirstTime(entryIter)
         << " Last: " << std::setw(10) << tracker->entityLastTime(entryIter)
         << " Name: " << std::left << tracker->entityName(entryIter)
         << std::endl;
   }
   outputStream().flags(original_flags);
   delete tracker;
}

void DtLgrDisPacketPrinter::printPduPacket(const DtPacket& packet)
{
   std::ios_base::fmtflags original_flags = outputStream().flags();
   DtConstLgrDisMessage disMsg(packet);

   outputStream() << std::setfill(' ') << std::left;

   // DtNetPduHeader.DtLength is a DtNetU16
   size_t pktSize = (size_t)(disMsg.netPduHeader()->DtLength);
   if ( packet.size() != pktSize )
   {
      outputStream() << "#### WARNING: size mismatch: packet(" <<
         (unsigned int)packet.size() << "), DIS header(" << pktSize << ") ####\n";
   }

   int disVersion = disMsg.netPduHeader()->version;
   DtPdu* pdu(0);

   if ( !myPrintRawData &&
      disVersion >= DtProtocolVersionToRecvMin &&
      disVersion <= DtProtocolVersionToRecvMax )
   {
      pdu = myPduFactory->createPdu((DtNetPacket*)packet.data(),
         (DtBufferPtr)packet.data() );
   }
   else
   {
      pdu = new DtUnknownPdu(disMsg.netPduHeader(),(DtBufferPtr)packet.data() );
   }

   if(!pdu)
   {
      DtLgrPrinter::warning("Error creating PDU.");
   }
   else
   {
      ++myPduCount;

      outputStream() << "******** Type=PDU #" << std::setw(10) << myPduCount
         << "***************************************************" << std::endl;

      pdu->printToStream(outputStream());
      delete pdu;
      outputStream().flags(original_flags);
   }
}

void DtLgrDisPacketPrinter::printPausePacket( const DtPacket& packet )
{
   DtNetFloat64* netFileTime = (DtNetFloat64*)packet.data();
   DtFloat64 internalFileTime = *netFileTime;
   outputStream() << "******** Type=Pause *********************************************************" << std::endl;
   outputStream() << "Time and date: " << DtTimeAndDate(internalFileTime) << std::endl;
}

void DtLgrDisPacketPrinter::printUnpausePacket( const DtPacket& packet )
{
   DtNetFloat64* netFileTime = (DtNetFloat64*)packet.data();
   DtFloat64 internalFileTime = *netFileTime;
   outputStream() << "******** Type=Unpause *********************************************************" << std::endl;
   outputStream() << "Time and date: " << DtTimeAndDate(internalFileTime) << std::endl;
}

std::ofstream& DtLgrDisPacketPrinter::outputStream()
{
   if(myOutputFile)
   {
      return *myOutputFile;
   }
   else
   {
      DtTHROW_NEW(DtCorruptedState,"Output Stream not initialize.");
   }
}

void DtLgrDisPacketPrinter::beginPrinting( const DtMessageIOInfo* info,
   const DtMessageInput* msgInput, const DtString& destination )
{
   if (myOutputFile)
   {
      endPrinting();
   }

   myOutputFile = new std::ofstream();
   myOutputFile->open(destination.c_str());
   if(!myOutputFile->good())
   {
      DtLgrPrinter::warning(DtString("Unable to open file:") + destination +
         DtString(" for export."));
      delete myOutputFile;
      myOutputFile = 0;
   }
   myPduCount = 0;
   myPacketCount = 0;
   myCheckpointCount = 0;
   myFileDateTime = -1;
   myUnpauseTime = 0;

   if (msgInput)
   {
      const DtLgrFileInput* fileInput = dynamic_cast<const DtLgrFileInput*>(msgInput);
      const DtLgrFileFormatter* formatter = fileInput->playbackFile()->formatter();
      const DtLoggerFileMetaData* metaData = formatter->metaData();
      const DtPacket* packet = metaData->getMetaData(DtLoggerFileMetaData::StartOfFile,DtPacket::Type_TapeTimeDate);

      // Start the dump with the file name, time and date.
      if (packet)
      {
         myFileDateTime = *(DtNetFloat64*)packet->data();
      }

      outputStream() << "Logger tape: " << fileInput->filename().string() << std::endl;
      outputStream() << "Protocol: " << info->protocol() << " / Version: "
         << DtLgrDisFileFormats::versionString(formatter->loggerFile()->fileVersion())
         << "(" << formatter->loggerFile()->fileVersion() << ")" << std::endl;
      if (myFileDateTime > 0)
      {
         outputStream() << "Time and date: " << DtTimeAndDate(myFileDateTime) << std::endl;
      }
      outputStream() << "********************************************************************************" << std::endl;
      outputStream() << "\n********************************************************************************" << std::endl;
      outputStream() << "**** Start Metadata ***********************************************************" << std::endl;
      outputStream() << "********************************************************************************\n" << std::endl;
      outputStream() << "********************************************************************************" << std::endl;

      // The printer will start at the first serial packet.
      // Print out the start metadata packets.
      const DtMessageBuffer& startMetadata = metaData->getMetaData(DtLoggerFileMetaData::StartOfFile);
      DtMessageBuffer::PacketList::const_iterator curIter = startMetadata.begin();
      DtMessageBuffer::PacketList::const_iterator endIter = startMetadata.end();
      for( ; curIter != endIter ; ++curIter)
      {
         printPacket(**curIter);
      }
      outputStream() << "\n********************************************************************************" << std::endl;
      outputStream() << "**** Serial Packets ************************************************************" << std::endl;
      outputStream() << "********************************************************************************\n" << std::endl;
      outputStream() << "********************************************************************************" << std::endl;

      // The printer will end at the last serial packet.
      // Save the end metadata packets.
      myEndMetadata.clear();
      const DtMessageBuffer& endMetadata = metaData->getMetaData(DtLoggerFileMetaData::EndOfFile);
      curIter = endMetadata.begin();
      endIter = endMetadata.end();
      for( ; curIter != endIter ; ++curIter)
      {
         DtPacket* packet = DtPacket::create((*curIter)->size(),(*curIter)->time(),(*curIter)->type());
         memcpy(packet->data(),(*curIter)->data(),(*curIter)->size());
         myEndMetadata.add(packet);
      }
   }
}

void DtLgrDisPacketPrinter::endPrinting()
{
   if(myOutputFile)
   {
      outputStream() << "\n********************************************************************************" << std::endl;
      outputStream() << "**** End Metadata **************************************************************" << std::endl;
      outputStream() << "********************************************************************************\n" << std::endl;
      outputStream() << "********************************************************************************" << std::endl;

      // Print the end metadata packets.
      DtMessageBuffer::PacketList::const_iterator curIter = myEndMetadata.begin();
      DtMessageBuffer::PacketList::const_iterator endIter = myEndMetadata.end();
      for( ; curIter != endIter ; ++curIter)
      {
         printPacket(**curIter);
      }

      myOutputFile->close();
      delete myOutputFile;
      myOutputFile = 0;
   }
}

}

#endif

lgrHlaPacketPrinter.h/cxx

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


#if DtHLA

#ifndef lgrHlaPacketPrinter_H_
#define lgrHlaPacketPrinter_H_

#include "lgrDump.h"

#include <lgrPacketPrinter.h>
#include <hlaMessageFactory.h>
#include <messageBuffer.h>

class DtInteractionFactory;
namespace MAKLogger
{
   class DtBaseFomDesc;
   class DtPacket;
   class DtLogger;

   class DT_DLL_LGRDUMP DtLgrHlaPacketPrinter : public DtLgrPacketPrinter
   {
   public:

      DT_VIRTUAL_CTR(DtLgrHlaPacketPrinter,(DtLogger& logger,bool raw))

      
      DT_VIRTUAL_BASE_CTR(DtLgrPacketPrinter,(DtLogger& logger,bool raw))

      
      virtual ~DtLgrHlaPacketPrinter();
   
   private:
      DtLgrHlaPacketPrinter(const DtLgrHlaPacketPrinter&);
      DtLgrHlaPacketPrinter& operator=(const DtLgrHlaPacketPrinter&);   
   
   public:

      virtual void beginPrinting(const DtMessageIOInfo* info,
         const DtMessageInput* msgInput, const DtString& destination);

      virtual void printPacket( const DtPacket& packet );

      virtual void endPrinting();

   protected:

      std::ofstream& outputStream();

      virtual void printPacketHeader(const DtPacket& packet);

      virtual void printPacketTail(const DtPacket& packet);

      void printOtherPacket(const DtPacket& packet);

      void printFomPacket(const DtPacket& packet);

      void printConfigPacket(const DtPacket& packet);

      void printDateTimePacket(const DtPacket& packet);

      void printCheckpointPacket(const DtPacket& packet);

      void printIndexTablePacket(const DtPacket& packet);

      void printRecordingDataPacket(const DtPacket& packet);

      void printDescriptionPacket(const DtPacket& packet);

      void printEntityTablePacket(const DtPacket& packet);

      void printRegionDescriptorSet(const DtRegionDescSet& regionSet);

      void printInteractionPacket(const DtPacket& packet);

      void printUpdatePacket(const DtPacket& packet);
      
      void printRemovalPacket( const DtPacket& packet );

      void printPausePacket(const DtPacket& packet);

      void printUnpausePacket(const DtPacket& packet);

      typedef void (DtLgrHlaPacketPrinter::*PacketPrintFunction)(const DtPacket&);
      typedef std::map<DtPacket::DtPacketType,PacketPrintFunction> PrintFunctionMap;
      
   protected:

      int myPacketCount;

      int myCheckpointCount;

      int myInteractionCount;

      int myUpdateCount;
      
      int myRemovalCount;

      bool myPrintRawData;

      PrintFunctionMap myPrintFunctionMap;

      std::ofstream* myOutputFile;

      DtLogger* myLogger;

      DtBaseFomDesc* myOutputFom;

      DtTime myFileDateTime;

      DtTime myUnpauseTime;

      DtMessageBuffer myEndMetadata;

   };
}

#endif
#endif

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

#if DtHLA

#include "lgrHlaPacketPrinter.h"
#include <lgrPrint.h>
#include <hlaPacket.h>
#include <lgrHlaSimInterface.h>
#include <baseFomDesc.h>
#include <hlaMessageIOInfo.h>
#include <baseObjDesc.h>
#include <baseIntDesc.h>
#include <lgrFileInput.h>
#include <loggerPlaybackFile.h>
#include <lgrFileFormatter.h>
#include <lgrHlaConfigData.h>
#include <lgrHlaEntityTracker.h>
#include <lgrPacketIndexer.h>
#include <loggerFile.h>
#include <lgrHlaFileFormats.h>

#include <vlutil/vlPrintUtil.h>
#include "vlutil/vlUtil.h"

#include <iomanip>
#include <time.h>

namespace MAKLogger
{

   DtString DtTimeAndDate(double time)
   {
      double intPart = 0;
      time = modf(time, &intPart);

      int fractionalPart = time * 10000;
      time_t timeValue = intPart;
      struct tm * timeinfo;
      timeinfo = localtime ( &timeValue );

      char dateBuffer[80];
      char timeBuffer[80];
      strftime (dateBuffer,80," %a %b %d, %Y",timeinfo);
      strftime (timeBuffer,80,"%X",timeinfo);

      DtString dateAndTime(timeBuffer);
      dateAndTime += ".";
      sprintf(timeBuffer, "%04d", fractionalPart);
      dateAndTime += timeBuffer;
      dateAndTime += dateBuffer;

      return dateAndTime;
   }

DT_VIRTUAL_CTR_DEFINE(DtLgrHlaPacketPrinter,
   (DtLogger& logger,bool raw),
   (logger,raw))

DT_VIRTUAL_BASE_CTR_DEFINE(DtLgrHlaPacketPrinter,DtLgrPacketPrinter,
   (DtLogger& logger,bool raw),
   (logger,raw))

//
// Main (possibly default) constructor
//
DtLgrHlaPacketPrinter::DtLgrHlaPacketPrinter( DtLogger& logger,bool raw)
   : DtLgrPacketPrinter()
   , myPacketCount(0)
   , myCheckpointCount(0)
   , myUpdateCount(0)
   , myInteractionCount(0)
   , myRemovalCount(0)
   , myFileDateTime(-1)
   , myUnpauseTime(0)
   , myPrintRawData(raw)
   , myPrintFunctionMap()
   , myOutputFile(0)
   , myLogger(&logger)
   , myOutputFom(0)
{
   myPrintFunctionMap[DtPacket::Type_Fom] =             &DtLgrHlaPacketPrinter::printFomPacket;
   myPrintFunctionMap[DtPacket::Type_ConfigData] =      &DtLgrHlaPacketPrinter::printConfigPacket;
   myPrintFunctionMap[DtPacket::Type_TapeTimeDate] =    &DtLgrHlaPacketPrinter::printDateTimePacket;
   myPrintFunctionMap[DtPacket::Type_Update] =          &DtLgrHlaPacketPrinter::printUpdatePacket;
   myPrintFunctionMap[DtPacket::Type_Removal] =         &DtLgrHlaPacketPrinter::printRemovalPacket;
   myPrintFunctionMap[DtPacket::Type_Interaction] =     &DtLgrHlaPacketPrinter::printInteractionPacket;
   myPrintFunctionMap[DtPacket::Type_Checkpoint] =      &DtLgrHlaPacketPrinter::printCheckpointPacket;
   myPrintFunctionMap[DtPacket::Type_EntityTable] =     &DtLgrHlaPacketPrinter::printEntityTablePacket;
   myPrintFunctionMap[DtPacket::Type_RecordingData] =   &DtLgrHlaPacketPrinter::printRecordingDataPacket;
   myPrintFunctionMap[DtPacket::Type_TapeDescription] = &DtLgrHlaPacketPrinter::printDescriptionPacket;
   myPrintFunctionMap[DtPacket::Type_IndexTable] =      &DtLgrHlaPacketPrinter::printIndexTablePacket;
   myPrintFunctionMap[DtPacket::Type_Pause] =           &DtLgrHlaPacketPrinter::printPausePacket;
   myPrintFunctionMap[DtPacket::Type_Unpause] =         &DtLgrHlaPacketPrinter::printUnpausePacket;
}

//
// Destructor
//
DtLgrHlaPacketPrinter::~DtLgrHlaPacketPrinter()
{
   endPrinting();
}

// Todo - get rid of these replacements of vr-link print utils
// when switching to vr-link that has label version.
void DtDumpLineOfHex(
   std::ostream & stream, DtU8 *address, size_t num_bytes)
{
   std::ios_base::fmtflags original_flags = stream.flags();
   DtU8 *p=0;
   int i = 0;
   for (p=address; p<(address+num_bytes); p++)
   {
      stream  << std::hex << std::right << std::setfill('0') << std::setw(2)
         << (unsigned short) *p << ' ';
   }
   stream << std::endl;
   stream.flags(original_flags);
}

void DtDumpHex(std::ostream& stream, const char * address, 
   size_t num_bytes, bool offsetLabel=false)
{
   const char * addr;
   unsigned int offset = 0; 

   for (addr=address; offset<num_bytes; offset+=8)
   {
      if (offsetLabel)
      {
         stream << std::hex << std::right << std::setfill('0') << std::setw(4)
            << offset << ": ";
      }
      DtDumpLineOfHex(stream, (DtU8 *)(addr+offset), 
         DtMin((unsigned int)8, (unsigned int)(num_bytes-offset)));
   }
}

void DtLgrHlaPacketPrinter::printPacketHeader(const DtPacket& packet)
{
   std::ios_base::fmtflags original_flags = outputStream().flags();

   outputStream() << std::setfill(' ') << std::left;

   outputStream() << "**** Packet #" << std::setw(6) << myPacketCount
      << " Size=" << std::setw(6) << (unsigned int)packet.size()
      << " time=" << packet.time().toString(4);

   if (myFileDateTime > 0)
   {
      outputStream() << ", " << DtTimeAndDate(myFileDateTime - myUnpauseTime + packet.time().seconds());
   }
   outputStream() << std::endl;

   outputStream().flags(original_flags);
}

void DtLgrHlaPacketPrinter::printPacketTail(const DtPacket& packet)
{
   outputStream() << "********************************************************************************" << std::endl;
}


void DtLgrHlaPacketPrinter::printPacket( const DtPacket& packet )
{
   if (packet.type() == DtPacket::Type_Unpause)
   {
      myFileDateTime = *(DtNetFloat64*)packet.data();
      myUnpauseTime = packet.time().seconds();

   }
   ++myPacketCount;
   printPacketHeader(packet);

   DtPacket::DtPacketType type = (DtPacket::DtPacketType)packet.type();
   PrintFunctionMap::iterator funcIter = myPrintFunctionMap.find(type);
   if(funcIter == myPrintFunctionMap.end())
   {
      printOtherPacket(packet);
   }
   else
   {
      // Nasty member function call syntax.
      (this->*funcIter->second)(packet);
   }

   printPacketTail(packet);
}

void DtLgrHlaPacketPrinter::printOtherPacket(const DtPacket& packet)
{
   outputStream() << "******** Type=Other(" << packet.type()
      << ")************************************************" << std::endl;
}

void DtLgrHlaPacketPrinter::printFomPacket( const DtPacket& packet )
{
   std::ios_base::fmtflags original_flags = outputStream().flags();
   std::auto_ptr<DtBaseFomDesc> fomDesc(DtBaseFomDesc::create());
   fomDesc->setFromSerialForm(packet.data());

   outputStream() << std::setfill(' ') << std::left;
   outputStream() << "******** Type=FOM ***********************************************************" << std::endl;
   outputStream() << "ObjectClassCount=" << std::setw(6) << fomDesc->objectClassCount()
      << "InteractionClassCount=" << std::setw(6) << fomDesc->interactionClassCount() << std::endl;
   outputStream().flags(original_flags);
}

void DtLgrHlaPacketPrinter::printConfigPacket(const DtPacket& packet)
{
   std::ios_base::fmtflags original_flags = outputStream().flags();
   DtLgrHlaConfigData config;

   config.deserialize(packet.data());

   outputStream() << std::setfill(' ') << std::left;
   outputStream() << "******** Type=Config ***********************************************************" << std::endl;
   outputStream() << "FomVersion:" << config.fomVersion().string() << std::endl;
   outputStream() << "FomMapperName:" << (config.fomMapperName().isEmpty() ? "N/A" : config.fomMapperName().string()) << std::endl;
   outputStream() << "FederationName:" << config.federationName().string() << std::endl;
   outputStream() << "FederateType:" << config.federateType().string() << std::endl;
#if DtHLA_1516_EVOLVED
   outputStream() << "FederateName:" << config.federateName().string() << std::endl;
   outputStream() << "FomModules:" << config.fomModules().string() << std::endl;
   outputStream() << "Mim:" << config.mim().string() << std::endl;
#endif
   outputStream() << "ConfigFileName:" << config.configFileName().string() << std::endl;
   outputStream() << config.configFileContents().string() << std::endl;
   outputStream() << "----------------------------------------" << std::endl;
   outputStream() << "FomFileName:" << config.fedFile().string() << std::endl;
   outputStream() << config.fedFileContent().string() << std::endl;
   outputStream() << "----------------------------------------" << std::endl;

   outputStream().flags(original_flags);
}

void DtLgrHlaPacketPrinter::printDateTimePacket(const DtPacket& packet)
{
   DtNetFloat64* netFileTime = (DtNetFloat64*)packet.data();
   DtFloat64 internalFileTime = *netFileTime;
   outputStream() << "******** Type=DateTime *********************************************************" << std::endl;
   outputStream() << "Time and date: " << DtTimeAndDate(internalFileTime) << std::endl;
}

void DtLgrHlaPacketPrinter::printCheckpointPacket(const DtPacket& packet)
{
   std::ios_base::fmtflags original_flags = outputStream().flags();
   outputStream() << std::setfill(' ') << std::left;

   ++myCheckpointCount;

   outputStream() << "******** Type=Checkpoint #"
      << std::setw(10) << myCheckpointCount
      << " *******************************************" << std::endl;

   const char* bp = packet.data();
   size_t bufferSize = packet.size();
   size_t currentSize = 0;
   const int packetOffset = sizeof(NetCheckpointUpdateHeader) +
      sizeof(NetCheckpointUpdateTail);

   int updateCount = 0;
   //  Round to 4 since bufferSize is a multiple of 4
   while(currentSize < bufferSize)
   {
      int size = ((NetCheckpointUpdateHeader*)bp)->numBytes;
      bp += sizeof(NetCheckpointUpdateHeader);

      DtPacket* aPacket = DtPacket::create(size, packet.time(), DtPacket::Type_Update);
      memcpy(aPacket->data(),bp,size);

      DtConstLgrHlaMessage hlaInfo(aPacket);
      ++updateCount;
      outputStream() << "******** Checkpoint Update #" << std::setw(6) << updateCount
         << " Size=" << std::setw(6) << (unsigned int)aPacket->size() << std::endl;
      outputStream() << std::setw(30) << "Object Name(Handle): " << hlaInfo.objectName()
         << "(" << hlaInfo.objectHandle() << ")" << std::endl;
      const DtBaseObjClassDesc* objDesc = myOutputFom->objDesc(hlaInfo.objectClassHandle());
      if(objDesc)
      {
         outputStream() << std::setw(30) << "Object Class Name(Handle): " << objDesc->name()
            << "(" << hlaInfo.objectClassHandle() << ")" << std::endl;
      }
      else
      {
         outputStream() << std::setw(30) << "Object Class Handle: " <<
            hlaInfo.objectClassHandle() << std::endl;
      }

      DtRegionDescSet regionSet;
      if (hlaInfo.getObjectDDMRegionDescSet(regionSet) > 0)
      {
         printRegionDescriptorSet(regionSet);
      }

      std::auto_ptr<DtLgrHandleValueMap> params = hlaInfo.createAttrs();
      outputStream() << "Attribute Count: " << (unsigned int)params->size() << std::endl;

      int attrIndex = 1;
      DtLgrHandleValueMap::const_iterator curIter = params->begin();
      DtLgrHandleValueMap::const_iterator endIter = params->end();
      for(;curIter != endIter;++curIter,++attrIndex)
      {
         outputStream() << "Attribute #" << std::setw(3) << attrIndex
            << " Size: " << std::setw(4) << std::right << (unsigned int)curIter->second.size();
         const DtBaseAttrDesc* attrDesc = 0;
         if (objDesc)
         {
            attrDesc = objDesc->findValueByHandle(curIter->first,false);
         }
         if (!attrDesc)
         {
            outputStream() << ", Handle: " << curIter->first << std::endl;
         }
         else
         {
            outputStream() << ", Name(Handle): " << attrDesc->name()
               << "(" << curIter->first << ")" << std::endl;
         }
         outputStream() << std::right;
         DtPrintAttributeHex(outputStream()," Value",
            curIter->second.data(),curIter->second.size());
         outputStream() << std::setfill(' ') << std::left;
      }

      delete aPacket;
      bp += size;         //move past data.
      bp += sizeof(NetCheckpointUpdateTail); //move past tail.
      currentSize += size + packetOffset;
   }
   outputStream().flags(original_flags);
}

void DtLgrHlaPacketPrinter::printIndexTablePacket(const DtPacket& packet)
{
   std::ios_base::fmtflags original_flags = outputStream().flags();
   DtLgrPacketIndexer packetIndexer;
   packetIndexer.decodePacket(&packet);

   int indexCount = packetIndexer.indexCount();

   outputStream() << std::setfill(' ') << std::left;
   outputStream() << "******** Type=IndexTable Count=" << std::setw(6) << indexCount
      << " ******************************************" << std::endl;
   for (int index=0; index <indexCount; ++index)
   {
      outputStream() << std::setw(6) << index
         << " Position: " << packetIndexer.getPositionOfIndex(index)
         << " Time: " << packetIndexer.getTimeOfIndex(index)
         << " Size: " << packetIndexer.getSizeOfIndex(index) << std::endl;

   }
   outputStream().flags(original_flags);
}

void DtLgrHlaPacketPrinter::printRecordingDataPacket(const DtPacket& packet)
{
   DtFloat64 duration = *(DtNetFloat64*)packet.data();
   outputStream() << "******** Type=RecordingInfo ****************************************************" << std::endl;
   outputStream() << "File Duration: "
      << std::setiosflags(std::ios::fixed) << std::setprecision(2) << duration << std::endl;
}

void DtLgrHlaPacketPrinter::printDescriptionPacket(const DtPacket& packet)
{
   DtString description = packet.data();
   size_t desclength = packet.size();
   outputStream() << "******** Type=Description ****************************************************" << std::endl;
   outputStream() << "File Description: " << description << std::endl;
}

void DtLgrHlaPacketPrinter::printEntityTablePacket(const DtPacket& packet)
{
   std::ios_base::fmtflags original_flags = outputStream().flags();
   DtLgrEntityTracker* tracker = DtLgrEntityTracker::create();

   tracker->decodePacket(&packet);

   outputStream() << std::setfill(' ') << std::left;
   outputStream() << "******** Type=EntityTable "
      << " Count=" << std::setw(6) << tracker->entityCount()
      << " ****************************************" << std::endl;

   DtLgrEntityTracker::EntryHandle entryIter = tracker->begin();
   DtLgrHlaEntityTracker::EntryHandle entryEnd = tracker->end();
   for ( ; entryIter != entryEnd; ++entryIter)
   {
      outputStream() << "   " << std::setw(6) << entryIter
         << " Type: " << std::setw(20) << tracker->entityType(entryIter)
         << " Force: " << std::setw(2) << tracker->entityForce(entryIter)
         << std::setiosflags(std::ios::fixed) << std::setprecision(2) << std::right
         << " First: " << std::setw(10) << tracker->entityFirstTime(entryIter)
         << " Last: " << std::setw(10) << tracker->entityLastTime(entryIter)
         << " Name: " << std::left << tracker->entityName(entryIter)
         << std::endl;
   }

   outputStream().flags(original_flags);
   delete tracker;
}

void DtLgrHlaPacketPrinter::printRegionDescriptorSet(const DtRegionDescSet& regionSet)
{
   if (regionSet.size() > 0)
   {
      std::ios_base::fmtflags original_flags = outputStream().flags();
      outputStream() << std::setfill(' ') << std::left;
      outputStream() << std::setw(22) << "Region Count: " << (unsigned int)regionSet.size() << std::endl;
      DtRegionDescSet::const_iterator regionIter = regionSet.begin();
      int regionIndex = 1;
      for ( ; regionIter != regionSet.end(); ++regionIter)
      {
         outputStream() << std::setw(22) << "Region #" << std::setw(2) << regionIndex
#if DtHLA_1516
            // stringified handle saved in space string
            << ", Handle: " << std::setw(3) << regionIter->space.c_str()
#else
            << ", Handle: " << std::setw(3) << regionIter->regionToken
            << ", Space: "  << regionIter->space.c_str()
#endif
            << ", Number of Extents: " << (unsigned int)regionIter->extents.size() << std::endl;
         int extentIndex = 1;
         DtExtentDescSet::const_iterator extentIter = regionIter->extents.begin();
         int regionIndex = 1;
         for ( ; extentIter != regionIter->extents.end(); ++extentIter)
         {
            outputStream() << std::setw(22) << "Extent #" << std::setw(2) << extentIndex << std::endl;
            DtDimensionDescSet::const_iterator dimIter = extentIter->dimensions.begin();
            int dimIndex = 1;
            for ( ; dimIter != extentIter->dimensions.end(); ++dimIter)
            {
               outputStream() << std::setw(22) << "Dimension #" << std::setw(2) << dimIndex << std::endl;
               outputStream() << std::setw(22) << "Dim Name: " << dimIter->name.c_str()
                  << ", Lower: " << dimIter->lower << ", Upper: " << dimIter->upper << std::endl;
            }
         }
      }
      outputStream().flags(original_flags);
   }
}

void DtLgrHlaPacketPrinter::printInteractionPacket( const DtPacket& packet )
{
   std::ios_base::fmtflags original_flags = outputStream().flags();
   outputStream() << std::setfill(' ') << std::left;
   DtConstLgrHlaMessage hlaInfo(packet);
   ++myInteractionCount;

   outputStream() << "******** Type=Interaction #"
      << std::setw(10) << myInteractionCount
      << " ******************************************" << std::endl;

   const DtBaseInterClassDesc* intDesc = myOutputFom->interDesc(hlaInfo.interactionClassHandle());
   if(intDesc)
   {
      outputStream() << std::setw(30) << "Interaction Class Name(Handle): " << intDesc->name()
         << "(" << hlaInfo.interactionClassHandle() << ")" << std::endl;
   }
   else
   {
      outputStream() << std::setw(30) << "Interaction Class Handle: " <<
         hlaInfo.interactionClassHandle() << std::endl;
   }

   outputStream() << "Tag as timestamp: " << hlaInfo.tagAsTimestamp() << std::endl;
#if DtHLA_1516
   outputStream() << "Tag:" << std::endl;
   DtDumpHex(outputStream(), (char *) hlaInfo.binaryTag().data(), hlaInfo.binaryTag().size(), true);
#else
   outputStream() << "Tag: " << hlaInfo.asciiTag() << std::endl;
#endif

   DtRegionDescSet regionSet;
   if (hlaInfo.getInteractionDDMRegionDescSet(regionSet) > 0)
   {
      printRegionDescriptorSet(regionSet);
   }

   std::auto_ptr<DtLgrHandleValueMap> params = hlaInfo.createParams();
   outputStream() << "Parameter Count: " << (unsigned int)params->size() << std::endl;

   int parameterIndex = 1;
   DtLgrHandleValueMap::const_iterator curIter = params->begin();
   DtLgrHandleValueMap::const_iterator endIter = params->end();
   for(;curIter != endIter;++curIter,++parameterIndex)
   {
      outputStream() <<"Parameter #" <<  std::setw(3) << parameterIndex
         << " Size: " << std::setw(4) << std::right << (unsigned int)curIter->second.size();
      const DtBaseParamDesc* paramDesc = 0;

      if(intDesc)
      {
         paramDesc = intDesc->findValueByHandle(curIter->first,false);
      }
      if(!paramDesc)
      {
         outputStream() << ", Handle: " << curIter->first << std::endl;
      }
      else
      {
         outputStream() << ", Name(Handle): " << paramDesc->name()
            << "(" << curIter->first << ")" << std::endl;
      }

      // This manipulator must be explicitly changed (or reset).
      outputStream() << std::right;
      DtPrintAttributeHex(outputStream(),"Value",
         curIter->second.data(),curIter->second.size());
      outputStream() << std::setfill(' ') << std::left;
   }

   outputStream().flags(original_flags);
}

void DtPrintAttributeHex(std::ostream &stream, const char *label,  const void *bytes, int size)
{
   DtPrintAndIndent(stream, label);
   stream << std::endl;
   DtDumpHex(stream, (char *) bytes, size, true);
}

void DtLgrHlaPacketPrinter::printUpdatePacket( const DtPacket& packet )
{
   std::ios_base::fmtflags original_flags = outputStream().flags();
   outputStream() << std::setfill(' ') << std::left;
   DtConstLgrHlaMessage hlaInfo(packet);
   ++myUpdateCount;

   outputStream() << "******** Type=Update #"
      << std::setw(10) << myUpdateCount
      << " ***********************************************" << std::endl;

   outputStream() << std::setw(30) << "Object Name(Handle): " << hlaInfo.objectName()
      << "(" << hlaInfo.objectHandle() << ")" << std::endl;

   const DtBaseObjClassDesc* objDesc = myOutputFom->objDesc(hlaInfo.objectClassHandle());
   if(objDesc)
   {
      outputStream() << std::setw(30) << "Object Class Name(Handle): " << objDesc->name()
         << "(" << hlaInfo.objectClassHandle() << ")" << std::endl;
   }
   else
   {
      outputStream() << std::setw(30) << "Object Class Handle: " <<
         hlaInfo.objectClassHandle() << std::endl;
   }

   outputStream() << "Tag as timestamp: " << hlaInfo.tagAsTimestamp() << std::endl;
#if DtHLA_1516
   outputStream() << "Tag:" << std::endl;
   DtDumpHex(outputStream(), (char *) hlaInfo.binaryTag().data(), hlaInfo.binaryTag().size(), true);
#else
   outputStream() << "Tag: " << hlaInfo.asciiTag() << std::endl;
#endif

   DtRegionDescSet regionSet;
   if (hlaInfo.getObjectDDMRegionDescSet(regionSet) > 0)
   {
      printRegionDescriptorSet(regionSet);
   }

   std::auto_ptr<DtLgrHandleValueMap> params = hlaInfo.createAttrs();
   outputStream() << "Attribute Count: " << (unsigned int)params->size() << std::endl;

   int attrIndex = 1;
   DtLgrHandleValueMap::const_iterator curIter = params->begin();
   DtLgrHandleValueMap::const_iterator endIter = params->end();
   for(;curIter != endIter;++curIter,++attrIndex)
   {
      outputStream() << "Attribute #" << std::setw(3) << attrIndex
         << " Size: " << std::setw(4) << std::right << (unsigned int)curIter->second.size();
      const DtBaseAttrDesc* attrDesc = 0;
      if (objDesc)
      {
         attrDesc = objDesc->findValueByHandle(curIter->first,false);
      }
      if (!attrDesc)
      {
         outputStream() << ", Handle: " << curIter->first << std::endl;
      }
      else
      {
         outputStream() << ", Name(Handle): " << attrDesc->name()
            << "(" << curIter->first << ")" << std::endl;
      }
      outputStream() << std::right;
      DtPrintAttributeHex(outputStream(),"Value",
         curIter->second.data(),curIter->second.size());
      outputStream() << std::setfill(' ') << std::left;
   }

   outputStream().flags(original_flags);
}

void DtLgrHlaPacketPrinter::printRemovalPacket( const DtPacket& packet )
{
   std::ios_base::fmtflags original_flags = outputStream().flags();
   outputStream() << std::setfill(' ') << std::left;
   DtConstLgrHlaMessage hlaInfo(packet);
   ++myRemovalCount;

   outputStream() << "******** Type=Removal #"
      << std::setw(10) << myRemovalCount
      << " **********************************************" << std::endl;

   outputStream() << std::setw(30) << "Object Name(Handle): " << hlaInfo.objectName()
      << "(" << hlaInfo.objectHandle() << ")" << std::endl;

   const DtBaseObjClassDesc* objDesc = myOutputFom->objDesc(hlaInfo.objectClassHandle());
   if(objDesc)
   {
      outputStream() << std::setw(30) << "Object Class Name(Handle): " << objDesc->name()
         << "(" << hlaInfo.objectClassHandle() << ")" << std::endl;
   }
   else
   {
      outputStream() << std::setw(30) << "Object Class Handle: " <<
         hlaInfo.objectClassHandle() << std::endl;
   }

   outputStream().flags(original_flags);
}

void DtLgrHlaPacketPrinter::printPausePacket( const DtPacket& packet )
{
   DtNetFloat64* netFileTime = (DtNetFloat64*)packet.data();
   DtFloat64 internalFileTime = *netFileTime;
   outputStream() << "******** Type=Pause *********************************************************" << std::endl;
   outputStream() << "Time and date: " << DtTimeAndDate(internalFileTime) << std::endl;
}

void DtLgrHlaPacketPrinter::printUnpausePacket( const DtPacket& packet )
{
   DtNetFloat64* netFileTime = (DtNetFloat64*)packet.data();
   DtFloat64 internalFileTime = *netFileTime;
   outputStream() << "******** Type=Unpause *********************************************************" << std::endl;
   outputStream() << "Time and date: " << DtTimeAndDate(internalFileTime) << std::endl;
}

void DtLgrHlaPacketPrinter::beginPrinting(const DtMessageIOInfo* info,
   const DtMessageInput* msgInput, const DtString& destination )
{
   if (myOutputFile)
   {
      endPrinting();
   }

   if(myOutputFom)
   {
      delete myOutputFom;
      myOutputFom = 0;
   }

   const DtLgrHlaMessageIOInfo* hlaInfo = dynamic_cast<const DtLgrHlaMessageIOInfo*>(info);
   if(hlaInfo)
   {
      myOutputFom = DtBaseFomDesc::copy(hlaInfo->fom());
   }

   myOutputFile = new std::ofstream();
   myOutputFile->open(destination.c_str());
   if(!myOutputFile->good())
   {
      DtLgrPrinter::warning(DtString("Unable to open file:") + destination +
         DtString(" for export."));
      delete myOutputFile;
      myOutputFile = 0;
   }
   myPacketCount = 0;
   myCheckpointCount = 0;
   myInteractionCount = 0;
   myUpdateCount = 0;
   myFileDateTime = -1;
   myUnpauseTime = 0;

   if (msgInput)
   {
      const DtLgrFileInput* fileInput = dynamic_cast<const DtLgrFileInput*>(msgInput);
      const DtLgrFileFormatter* formatter = fileInput->playbackFile()->formatter();
      const DtLoggerFileMetaData* metaData = formatter->metaData();
      const DtPacket* packet = metaData->getMetaData(DtLoggerFileMetaData::StartOfFile,DtPacket::Type_TapeTimeDate);

      // Start the dump with the file name, time and date.
      if (packet)
      {
         myFileDateTime = *(DtNetFloat64*)packet->data();
      }

      outputStream() << "Logger tape: " << fileInput->filename().string() << std::endl;
      outputStream() << "Protocol: " << hlaInfo->protocol() << " / Version: "
         << DtLgrHlaFileFormats::versionString(formatter->loggerFile()->fileVersion())
         << "(" << formatter->loggerFile()->fileVersion() << ")" << std::endl;
      if (myFileDateTime > 0)
      {
         outputStream() << "Time and date: " << DtTimeAndDate(myFileDateTime) << std::endl;
      }
      outputStream() << "********************************************************************************" << std::endl;
      outputStream() << "\n********************************************************************************" << std::endl;
      outputStream() << "**** Start Metadata ***********************************************************" << std::endl;
      outputStream() << "********************************************************************************\n" << std::endl;
      outputStream() << "********************************************************************************" << std::endl;

      // The printer will start at the first serial packet.
      // Print out the start metadata packets.
      const DtMessageBuffer& startMetadata = metaData->getMetaData(DtLoggerFileMetaData::StartOfFile);
      DtMessageBuffer::PacketList::const_iterator curIter = startMetadata.begin();
      DtMessageBuffer::PacketList::const_iterator endIter = startMetadata.end();
      for( ; curIter != endIter ; ++curIter)
      {
         printPacket(**curIter);
      }
      outputStream() << "\n********************************************************************************" << std::endl;
      outputStream() << "**** Serial Packets ************************************************************" << std::endl;
      outputStream() << "********************************************************************************\n" << std::endl;
      outputStream() << "********************************************************************************" << std::endl;

      // The printer will end at the last serial packet.
      // Save the end metadata packets.
      myEndMetadata.clear();
      const DtMessageBuffer& endMetadata = metaData->getMetaData(DtLoggerFileMetaData::EndOfFile);
      curIter = endMetadata.begin();
      endIter = endMetadata.end();
      for( ; curIter != endIter ; ++curIter)
      {
         DtPacket* packet = DtPacket::create((*curIter)->size(),(*curIter)->time(),(*curIter)->type());
         memcpy(packet->data(),(*curIter)->data(),(*curIter)->size());
         myEndMetadata.add(packet);
      }
   }
}

void DtLgrHlaPacketPrinter::endPrinting()
{
   if(myOutputFile)
   {
      outputStream() << "\n********************************************************************************" << std::endl;
      outputStream() << "**** End Metadata **************************************************************" << std::endl;
      outputStream() << "********************************************************************************\n" << std::endl;
      outputStream() << "********************************************************************************" << std::endl;

      // Print the end metadata packets.
      DtMessageBuffer::PacketList::const_iterator curIter = myEndMetadata.begin();
      DtMessageBuffer::PacketList::const_iterator endIter = myEndMetadata.end();
      for( ; curIter != endIter ; ++curIter)
      {
         printPacket(**curIter);
      }

      myOutputFile->close();
      delete myOutputFile;
      myOutputFile = 0;
   }

   if(myOutputFom)
   {
      delete myOutputFom;
      myOutputFom = 0;
   }
}

std::ofstream& DtLgrHlaPacketPrinter::outputStream()
{
   return *myOutputFile;
}

}

#endif