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 <lgrCore/lgrPacketPrinter.h>
#include <lgrCore/messageBuffer.h>

#include <vlutil/vlTime.h>

class DtDisPduFactory;

namespace MAKLogger
{
   class DtPacket;
   class DtLgrFileFormatter;

   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 printState(const char* stateBuffer, size_t bufferSize, bool includeUpdateHeaders);

      void printInitialStatePacket(const DtPacket& packet);

      void printCheckpointPacket(const DtPacket& packet);

      void printIndexTablePacket(const DtPacket& packet);

      void printRecordingDataPacket(const DtPacket& packet);

      void printStartEndTimePacket(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;

      const DtLgrFileFormatter* myFormatter;

      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 <lgrSim/disPacket.h>
#include <lgrSim/lgrDisFileFormats.h>
#include <lgrSim/lgrDisMessageState.h>
#include <lgrCore/lgrEntityTrackingFormat.h>
#include <lgrCore/lgrFileInput.h>
#include <lgrCore/loggerPlaybackFile.h>
#include <lgrCore/lgrFileFormatter.h>
#include <lgrCore/lgrConfigData.h>
#include <lgrCore/lgrEntityTracker.h>
#include <lgrCore/lgrPacketIndexer.h>
#include <lgrCore/messageIoInfo.h>
#include <lgrCore/loggerFile.h>
#include <lgrUtil/lgrPrint.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)
   , myFormatter(0)
{
   myPrintFunctionMap[DtPacket::Type_ConfigData] =      &DtLgrDisPacketPrinter::printConfigPacket;
   myPrintFunctionMap[DtPacket::Type_TapeTimeDate] =    &DtLgrDisPacketPrinter::printDateTimePacket;
   myPrintFunctionMap[DtPacket::Type_Pdu] =             &DtLgrDisPacketPrinter::printPduPacket;
   myPrintFunctionMap[DtPacket::Type_InitialState] =    &DtLgrDisPacketPrinter::printInitialStatePacket;
   myPrintFunctionMap[DtPacket::Type_Checkpoint] =      &DtLgrDisPacketPrinter::printCheckpointPacket;
   myPrintFunctionMap[DtPacket::Type_EntityTable] =     &DtLgrDisPacketPrinter::printEntityTablePacket;
   myPrintFunctionMap[DtPacket::Type_RecordingData] =   &DtLgrDisPacketPrinter::printRecordingDataPacket;
   myPrintFunctionMap[DtPacket::Type_StartEndTime] =    &DtLgrDisPacketPrinter::printStartEndTimePacket;
   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::printState(const char* buffer, size_t bufferSize, bool includeUpdateHeaders)
{
    const int updateHeadersSize = sizeof(DtNetPduHeader) +
       (includeUpdateHeaders ? sizeof(const DtLgrDisMessageState::NetInitialStateUpdateHeader) : 0);
    int pduIndex = 0;
    size_t numberBytesUsed = 0;

    while (numberBytesUsed < bufferSize && bufferSize >= updateHeadersSize)
    {
       DtFloat64 arrivalTime = 0.0;
       if (includeUpdateHeaders)
       {
          const DtLgrDisMessageState::NetInitialStateUpdateHeader* updateHeader = (const DtLgrDisMessageState::NetInitialStateUpdateHeader*)buffer;
          arrivalTime = updateHeader->arrivalTime;
          buffer += sizeof(DtLgrDisMessageState::NetInitialStateUpdateHeader);
          numberBytesUsed += sizeof(DtLgrDisMessageState::NetInitialStateUpdateHeader);
       }

       unsigned int length = ((DtNetPduHeader*)buffer)->DtLength;
       if (length > 4000)
       {
           // Packet is larger than Maximum, stop processing initial state
          DtLgrPrinter::warning("Invalid PDU size, checkpoint data invalid/corrupted.");
          break;
       }
       else
       {
          DtPdu* pdu = myPduFactory->createPdu((DtNetPacket*)buffer, (DtBufferPtr)buffer);
          if (!pdu)
          {
             DtLgrPrinter::warning("Failed to create PDU, checkpoint data invalid/corrupted.");
             break;
          }
          const char* pduKindStr = DtEnumString(pdu->kind());
          outputStream() << "************ Checkpoint PDU #" << std::setw(6) << std::setfill(' ') << std::left << pduIndex
             << " Kind=" << (pduKindStr ? pduKindStr : "Unknown") << "(" << pdu->kind() << ")"
             << " Size=" << std::setw(6) << length
             << " Time=" << std::setw(6) << pdu->timeStamp();
          if (includeUpdateHeaders)
          {
             outputStream() << " Arrival=" << arrivalTime;
          }
          outputStream() << std::endl;
          pdu->printDataToStream(outputStream());
          delete pdu;
          buffer   += length;
          numberBytesUsed += length;
       }
       pduIndex++;
    }
}

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

   outputStream() << std::setfill(' ') << std::left;
   outputStream() << "******** Type=Initial State "
      << "*******************************************" << std::endl;

   size_t bufferSize = packet.size();
   const char* buffer = packet.data();

   if (myFormatter->loggerFile()->fileVersion() <= -70)
   {
      DtMessageState::NetInitialStateHeader* initialStateHeader =
         (DtMessageState::NetInitialStateHeader*)buffer;
      outputStream() << "Number Checkpoints: " << (DtInt64)initialStateHeader->numberCheckpoints
         << " Offset: " << (DtFloat64)initialStateHeader->offset << std::endl;
      buffer += sizeof(*initialStateHeader);
      bufferSize -= sizeof(*initialStateHeader);
   }

   printState(buffer, bufferSize, true);

   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 bufferSize = packet.size();
   const char* buffer = packet.data();

   if (myFormatter->loggerFile()->fileVersion() <= -70)
   {
      DtMessageState::NetCheckpointHeader* checkpointHeader =
         (DtMessageState::NetCheckpointHeader*)buffer;
      outputStream() << "Number Checkpoints: " << (DtInt64)checkpointHeader->numCheckpoints
         << " Previous/Next Positions: " << (DtInt64)checkpointHeader->previousCheckpoint
         << " / " << (DtInt64)checkpointHeader->nextCheckpoint << std::endl;
      buffer += sizeof(*checkpointHeader);
      bufferSize -= sizeof(*checkpointHeader);
   }

   printState(buffer, bufferSize, false);

   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::printStartEndTimePacket(const DtPacket& packet)
{
   DtLgrEntityTrackingFormat::NetStartEndTime* times = 
      (DtLgrEntityTrackingFormat::NetStartEndTime*)packet.data();
   double startTime = (DtNetFloat64)times->startTime;
   double endTime = (DtNetFloat64)times->endTime;
   DtAbsoluteTime startT(startTime);
   DtAbsoluteTime endT(endTime);
   outputStream() << "******** Type=StartTime/EndTime ****************************************************" << std::endl;
   outputStream() << "Start/End: " << startT.toString(3) << "/" << endT.toString(3) << 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 = myFormatter->entityTracker()->createFromPacket(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);

      myFormatter = formatter;

      // 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 <lgrCore/lgrPacketPrinter.h>
#include <lgrSim/hlaMessageFactory.h>
#include <lgrCore/messageBuffer.h>

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

   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 printState(const char* stateBuffer, size_t bufferSize, int numberCheckpoints);

      void printInitialStatePacket(const DtPacket& packet);

      void printCheckpointPacket(const DtPacket& packet);

      void printIndexTablePacket(const DtPacket& packet);

      void printRecordingDataPacket(const DtPacket& packet);

      void printStartEndTimePacket(const DtPacket& packet);

      void printDescriptionPacket(const DtPacket& packet);

      void printEntityTablePacket(const DtPacket& packet);

      void printRegionDescriptorSet(const DtRegionDescSet& regionSet);

      void printInteractionPacket(const DtPacket& packet);

      void printInteractionPacketData( const DtPacket& packet, bool printTag );

      void printUpdatePacket(const DtPacket& packet);
      
      void printUpdatePacketData( const DtPacket& packet, bool printTag );

      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;

      const DtLgrFileFormatter* myFormatter;

      DtTime myFileDateTime;

      DtTime myUnpauseTime;

      DtMessageBuffer myEndMetadata;

   };
}

#endif
#endif

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

#if DtHLA

#include "lgrHlaPacketPrinter.h"
#include <lgrCore/lgrEntityTrackingFormat.h>
#include <lgrUtil/lgrPrint.h>
#include <lgrSim/hlaPacket.h>
#include <lgrSim/lgrHlaSimInterface.h>
#include <lgrSim/baseFomDesc.h>
#include <lgrSim/hlaMessageIOInfo.h>
#include <lgrSim/baseObjDesc.h>
#include <lgrSim/baseIntDesc.h>
#include <lgrCore/lgrFileInput.h>
#include <lgrCore/loggerPlaybackFile.h>
#include <lgrCore/lgrFileFormatter.h>
#include <lgrSim/lgrHlaConfigData.h>
#include <lgrSim/lgrHlaEntityTracker.h>
#include <lgrCore/lgrPacketIndexer.h>
#include <lgrCore/loggerFile.h>
#include <lgrSim/lgrHlaFileFormats.h>
#include <lgrCore/messageState.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_InitialState] =    &DtLgrHlaPacketPrinter::printInitialStatePacket;
   myPrintFunctionMap[DtPacket::Type_Checkpoint] =      &DtLgrHlaPacketPrinter::printCheckpointPacket;
   myPrintFunctionMap[DtPacket::Type_EntityTable] =     &DtLgrHlaPacketPrinter::printEntityTablePacket;
   myPrintFunctionMap[DtPacket::Type_RecordingData] =   &DtLgrHlaPacketPrinter::printRecordingDataPacket;
   myPrintFunctionMap[DtPacket::Type_StartEndTime] =    &DtLgrHlaPacketPrinter::printStartEndTimePacket;
   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::printState(const char* checkpointBuffer, size_t bufferSize,
   int numberCheckpoints)
{
   size_t numberBytesUsed = 0;
   const int packetOffset = sizeof(NetCheckpointUpdateHeader) +
      sizeof(NetCheckpointUpdateTail);
   int updateCount = 0;
   int interactionCount = 0;
   int checkpointCount = 0;

   outputStream() <<  "buffer size " << bufferSize << std::endl;

   while (numberBytesUsed < bufferSize && checkpointCount < numberCheckpoints)
   {
      NetCheckpointUpdateHeader* header = (NetCheckpointUpdateHeader*)checkpointBuffer;
      DtU32 size = header->numBytes;
      DtU32 packetType = header->flags;
      DtFloat64 arrivalTime = header->arrivalTime;
      DtFloat64 packetTime = DtAbs(arrivalTime);

      checkpointBuffer += sizeof(NetCheckpointUpdateHeader);

      if (packetType == DtPacket::Type_Update)
      {
         DtPacket* aPacket = DtPacket::create(size, packetTime, DtPacket::Type_Update);
         memcpy(aPacket->data(),checkpointBuffer,size);
         ++updateCount;
         outputStream() << "******** Checkpoint Update #" << std::setw(6) << updateCount
            << " Size=" << std::setw(6) << size
            << " Time=" << std::setw(6) << arrivalTime << std::endl;
         printUpdatePacketData(*aPacket, false);
         delete aPacket;
      }
      else
      {
         DtPacket* aPacket = DtPacket::create(size, packetTime, packetType);
         memcpy(aPacket->data(),checkpointBuffer,size);
         ++interactionCount;
         outputStream() << "******** Checkpoint Interaction #" << std::setw(6) << interactionCount
            << " Size=" << std::setw(6) << size
            << " Time=" << std::setw(6) << arrivalTime << std::endl;
         printInteractionPacketData(*aPacket, false);
         delete aPacket;
      }

      ++checkpointCount;
      checkpointBuffer += size;         //move past data.
      checkpointBuffer += sizeof(NetCheckpointUpdateTail); //move past tail.
      numberBytesUsed += size + packetOffset;
      outputStream() <<  "bytes used " << numberBytesUsed <<  " buffer size " << bufferSize << std::endl;
   }
}

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

   outputStream() << "******** Type=Initial State"
      << " *******************************************" << std::endl;

   const char* initialStateBuffer = packet.data();
   size_t bufferSize = packet.size();
   DtInt64 numberCheckpoints = 0;
   DtFloat64 offset = 0.0;

   if (myFormatter->loggerFile()->fileVersion() <= -70)
   {
      DtMessageState::NetInitialStateHeader* initialStateHeader =
         (DtMessageState::NetInitialStateHeader*)initialStateBuffer;
      numberCheckpoints = initialStateHeader->numberCheckpoints;
      offset = initialStateHeader->offset;
      outputStream() << "Number Checkpoints: " << numberCheckpoints
         << " Offset: " << offset << std::endl;
      initialStateBuffer += sizeof(*initialStateHeader);
      bufferSize -= sizeof(*initialStateHeader);
   }

   if (bufferSize > 0 && numberCheckpoints > 0)
   {
      printState(initialStateBuffer, bufferSize, numberCheckpoints);
   }

   outputStream().flags(original_flags);
}

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* checkpointBuffer = packet.data();
   size_t bufferSize = packet.size();
   DtInt64 numberCheckpoints = 0;
   DtFloat64 offset = 0.0;

   if (myFormatter->loggerFile()->fileVersion() <= -70)
   {
      DtMessageState::NetCheckpointHeader* checkpointHeader =
         (DtMessageState::NetCheckpointHeader*)checkpointBuffer;
      numberCheckpoints = checkpointHeader->numCheckpoints;
      outputStream() << "Number Checkpoints: " << numberCheckpoints
         << " Previous/Next Positions: " << (DtInt64)checkpointHeader->previousCheckpoint
         << " / " << (DtInt64)checkpointHeader->nextCheckpoint << std::endl;
      checkpointBuffer += sizeof(*checkpointHeader);
      bufferSize -= sizeof(*checkpointHeader);
   }

   if (bufferSize > 0 && numberCheckpoints > 0)
   {
      printState(checkpointBuffer, bufferSize, numberCheckpoints);
   }

   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::printStartEndTimePacket(const DtPacket& packet)
{
   DtLgrEntityTrackingFormat::NetStartEndTime* times = 
      (DtLgrEntityTrackingFormat::NetStartEndTime*)packet.data();
   double startTime = (DtNetFloat64)times->startTime;
   double endTime = (DtNetFloat64)times->endTime;
   DtAbsoluteTime startT(startTime);
   DtAbsoluteTime endT(endTime);
   outputStream() << "******** Type=StartTime/EndTime ****************************************************" << std::endl;
   outputStream() << "Start/End: " << startT.toString(3) << "/" << endT.toString(3) << 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 = myFormatter->entityTracker()->createFromPacket(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 )
{
   ++myInteractionCount;

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

   printInteractionPacketData(packet, true);
}

void DtLgrHlaPacketPrinter::printInteractionPacketData( const DtPacket& packet, bool printTag )
{
   DtConstLgrHlaMessage hlaInfo(packet);

   std::ios_base::fmtflags original_flags = outputStream().flags();
   outputStream() << std::setfill(' ') << std::left;

   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;
   }

   if (printTag)
   {
      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 )
{
   ++myUpdateCount;

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

   printUpdatePacketData(packet, true);
}

void DtLgrHlaPacketPrinter::printUpdatePacketData( const DtPacket& packet, bool printTag )
{
   DtConstLgrHlaMessage hlaInfo(packet);

   std::ios_base::fmtflags original_flags = outputStream().flags();
   outputStream() << std::setfill(' ') << std::left;

   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;
   }

   if (printTag)
   {
      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);
      myFormatter = fileInput->playbackFile()->formatter();
      const DtLoggerFileMetaData* metaData = myFormatter->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(myFormatter->loggerFile()->fileVersion())
         << "(" << myFormatter->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