The logger dump packet printers:
/****************************************************************************** ** 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 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 <lgrDisEntityTracker.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_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) //Test to see if packet is larger than Maximum { DtLgrPrinter::warning("Invalid PDU size, checkpoint data invalid/corrupted."); return; } 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::printEntityTablePacket(const DtPacket& packet) { std::ios_base::fmtflags original_flags = outputStream().flags(); DtLgrDisEntityTracker tracker; DtLgrEntityTracker& baseTracker = tracker; tracker.decodePacket(&packet); outputStream() << std::setfill(' ') << std::left; outputStream() << "******** Type=EntityTable " << " Count=" << std::setw(6) << baseTracker.entityCount() << " ****************************************" << std::endl; DtLgrDisEntityTracker::EntryHandle entryIter = tracker.begin(); DtLgrDisEntityTracker::EntryHandle entryEnd = tracker.end(); for ( ; entryIter != entryEnd; ++entryIter) { outputStream() << " " << std::setw(6) << entryIter << " Type: " << std::setw(20) << baseTracker.entityType(entryIter) << " Force: " << std::setw(2) << baseTracker.entityForce(entryIter) << std::setiosflags(std::ios::fixed) << std::setprecision(2) << std::right << " First: " << std::setw(10) << baseTracker.entityFirstTime(entryIter) << " Last: " << std::setw(10) << baseTracker.entityLastTime(entryIter) << " Name: " << std::left << baseTracker.entityName(entryIter) << std::endl; } outputStream().flags(original_flags); } 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() ); if(!pdu) { DtLgrPrinter::warning("Error creating PDU."); return; } } else { pdu = new DtUnknownPdu(disMsg.netPduHeader(),(DtBufferPtr)packet.data() ); } ++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
/******************************************************************************* ** 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 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 <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_IndexTable] = &DtLgrHlaPacketPrinter::printIndexTablePacket; myPrintFunctionMap[DtPacket::Type_Pause] = &DtLgrHlaPacketPrinter::printPausePacket; myPrintFunctionMap[DtPacket::Type_Unpause] = &DtLgrHlaPacketPrinter::printUnpausePacket; } // // Destructor // DtLgrHlaPacketPrinter::~DtLgrHlaPacketPrinter() { endPrinting(); } 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() << "FederateName:" << config.federateName().string() << std::endl; #if DtHLA_1516_EVOLVED outputStream() << "FederateType:" << config.federateType().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); } 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 params; 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::printEntityTablePacket(const DtPacket& packet) { std::ios_base::fmtflags original_flags = outputStream().flags(); DtLgrEntityTracker tracker; 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); } 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; } DtRegionDescSet regionSet; if (hlaInfo.getInteractionDDMRegionDescSet(regionSet) > 0) { printRegionDescriptorSet(regionSet); } 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; } delete params; outputStream().flags(original_flags); } 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; } DtRegionDescSet regionSet; if (hlaInfo.getObjectDDMRegionDescSet(regionSet) > 0) { printRegionDescriptorSet(regionSet); } 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 params; 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