readFile Example

---

The main application:

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



#if DtDIS
#include <vl/disPduFactory.h>
#include <lgrDisMessageIoInfo.h>
#include <lgrDisPlaybackFile.h>
#include <lgrDisFileFormats.h>
#endif

#if DtHLA
#include <vl/exerciseConn.h>
#include <vl/hExConnInit.h>
#include <vl/hInterFactory.h>
#include <hlaMessageFactory.h>
#include <hlaMessageIOInfo.h>
#include <hlaPacket.h>
#include <vl/hInteraction.h>
#include <lgrHlaPlaybackFile.h>
#include <onlineFomDesc.h>
#include <lgrHlaFileFormats.h>
#include <hlaMessageState.h>
#endif

#include <lgrVersion.h>
#include <absoluteTime.h>
#include <loggerFileReader.h>
#include <iostream>
#include <cmdLine/cmdLine.h>

using namespace MAKLogger;

#if DtDIS
void readPacket( const DtPacket* packet)
{
   //Necessary factory object.
   static DtDisPduFactory factory;

   // Check to see if packet is a PDU.
   if(packet->type() == static_cast<int>(DtPacket::Type_Pdu))
   {
      DtPdu* Pdu = factory.createPdu (
         reinterpret_cast<const DtNetPacket*>(packet->data()),
         reinterpret_cast<DtBufferPtr>(const_cast<char*>(packet->data())));
      Pdu->print();
      delete Pdu;
   }
}

DtLoggerFileReader* openFileForReading( const DtString& filename )
{
   // Ok lets open the file for playback.
   DtLgrDisPlaybackFile* file(0);
   DtLgrDisMessageIOInfo* ioInfo(0);

   try
   {

      file = new DtLgrDisPlaybackFile(filename);

      // Necessary information (not really needed here but for completeness)
      ioInfo = DtLgrDisMessageIOInfo::create(DtMessageIOInfo::File,5);


      // Now construct a reader object to read the packets from the file.
      return new DtLoggerFileReader(ioInfo,file);
   }
   catch(DtException& ex)
   {
      DtString output = DtSerializeException(ex);
      DtInfo << output << std::endl;
      return 0;
   }
}

#endif

#if DtHLA
DtExerciseConn* theExerciseConn;
DtInteractionFactory* theInteractionFactory;
DtLgrOnlineFomDesc* theOnlineFom;
DtBaseFomDesc* theFileFom;
DtLgrHlaMessageState* theMessageState;

void readPacket( const DtPacket* packet)
{

   DtConstLgrHlaMessage hlaMessage(packet);
   if(hlaMessage.isInteraction())
   {

      DtInteraction* inter = hlaMessage.createInteraction(
         theInteractionFactory,
         *theOnlineFom);
      inter->print();
   }
}

DtLoggerFileReader* openFileForReading( const DtString& filename )
{
   // Now opening the file for playback.
   try
   {
      DtLgrHlaPlaybackFile* file = DtLgrHlaPlaybackFile::create(filename);

      // Necessary information.
      DtLgrHlaMessageIOInfo* ioInfo = DtLgrHlaMessageIOInfo::create(
         DtMessageIOInfo::File,DtBaseFomDesc::copy(*file->fom()));

      // Now construct a reader object to read the packets from the file.
      return new DtLoggerFileReader(ioInfo,file);

   }
   catch(DtException& ex)
   {
      DtString output = DtSerializeException(ex);
      DtInfo << output << std::endl;
      return 0;
   }


}

#endif


int readFile(int argc,char** argv)
{
   DtCmdLine::CmdLine cmdLine("readFile","Example of how to read a logger file.",LOGGER_VERSION_STRING);
   DtCmdLine::UnlabeledValueArg<DtString> filenameArg("Filename","The name of the logger file to read.","","string");
   cmdLine.add(&filenameArg);
   cmdLine.parse(argc,argv);

   // HLA initialization
#if DtHLA
   DtExerciseConnInitializer exConnInit;
#if DtHLA
#if DtHLA_1516_EVOLVED
   exConnInit.setFedFileName("vr-link_evolved.xml");
#elif DtHLA_1516
   exConnInit.setFedFileName("vr-link.xml");
#else
   exConnInit.setFedFileName("vr-link.fed");
#endif
#endif
   theExerciseConn = new DtExerciseConn(exConnInit);
   theInteractionFactory = theExerciseConn->interactionFactory();
   theOnlineFom = DtLgrOnlineFomDesc::create(theExerciseConn);
   DtLgrHlaFileFormats::registerFormats();
#else
   DtLgrDisFileFormats::registerFormats();
#endif

   DtString filename(filenameArg.getValue());
   DtLoggerFileReader* reader = openFileForReading(filename);
   if(!reader)
   {
      DtInfo << "Unable to open file: " << filename << " for reading." << std::endl;
      return 1;
   }
   else
   {
      DtInfo << "Opened file: " << filename << " for reading." << std::endl;
   }

   //HLA hook up state for handle mapping.
#if DtHLA
   theMessageState = new DtLgrHlaMessageState();
   theMessageState->setInputInfo(reader->info());
   theMessageState->setOutputInfo(DtLgrHlaMessageIOInfo::create(
      DtMessageIOInfo::Network,theOnlineFom));
#endif


   //Buffer to store the messages
   DtMessageBuffer buffer;

   // Get the time of the last message in the file.
   DtAbsoluteTime lastTime = reader->lastMessageTime();

   // Tell the reader to read all messages up to and including the last time.
   reader->startReadMessages(lastTime);
   // Read until the end of the tape and the buffer is empty.
   // The second case is required for all messages with the timestamp
   // as the last time.
   while(reader->lastReadTime() != lastTime)
   {
      //Read a set of packets into the buffer
      //The number read is determined by the internal buffer size of the reader.
      reader->getNextMessages(buffer);

      // If no more messages break out.
      if(buffer.size() == 0) break;

#if DtHLA
      // This is an important and necessary step to convert an offline hla packet
      // to an online packet.  This is required for using VR-Link to create
      // interactions and such
      theMessageState->modifyMessages(buffer);
#endif

      //Iterate through all packets in the buffer.
      DtMessageBuffer::PacketList::iterator packetIterator;
      for(packetIterator = buffer.begin(); packetIterator != buffer.end();++packetIterator)
      {
         DtPacket* packet = *packetIterator;

         static int packetCount = 0;
         DtInfo <<
            "***********************************************" << std::endl <<
            "*  Packet #" << ++packetCount << " Type = " << packet->type() <<
            " at Time = " << packet->time().toString(2) << std::endl;

         readPacket(packet);
      }
      buffer.clear();
   }

   delete reader;
   return 0;
}

// The application entry point
int main(int argc,char** argv)
{
   return readFile(argc,argv);
}