offsetFile Example

Table of Contents

• Overview
• Usage
• Build and Run
• Behavior Details
• Code Structure
• Defaults
• Notes
• Source Code

Overview

The offsetFile example demonstrates how to read packets from a MAK Logger tape file (.lgr), apply a time offset to each packet, and write the modified packets to a new tape file. It supports both DIS and HLA logger formats, auto-detects the input file format, and preserves packet content while adjusting timestamps.

Key capabilities:

• Open a logger playback file and iterate through its packets.
• Apply a user-specified time offset to packet timestamps (clamped at zero).
• Write the modified packets efficiently in batches to a new logger record file.

Usage

Command line:

offsetFile [-o <offsetSeconds>] <readFile.lgr> <writeFile.lgr>

Parameters:

• -o, –Offset: Required. A double value specifying seconds to add to each packet timestamp. If result becomes negative, it is clamped to 0.
• Filename (unlabeled): The input .lgr file to read. If omitted, a default sample file for the active protocol (DIS/HLA variant) is used.
• Filename (unlabeled, second): The output .lgr file to write. If omitted, a filename based on the input (e.g., "<input>-Offset.lgr") is generated.

Examples:

# DIS build
offsetFileDIS.exe -o 5.0 ..\logger_tapes\bombMission2025-DIS.lgr ..\logger_tapes\adjusted.lgr

# HLA 1516e build
offsetFileHLA1516e.exe -o 2.5 ..\logger_tapes\bombMission2025-HLA4-NETN.lgr

Build and Run

• Open the corresponding Visual Studio project (e.g., __examples\simpleFileActions\offsetFileDIS.vcxproj__ or one of the HLA variants).
• Build the project in Visual Studio.
• Run from the IDE or a Developer Command Prompt.

Behavior Details

• File format detection:
  • Reads the magic number from the input file and verifies it matches a known DIS/HLA logger format. If unknown or corrupted, the tool aborts.
• Reading:
  • Creates a DtLoggerFileReader over the input file; for DIS uses DtLgrDisPlaybackFile, for HLA uses DtLgrHlaPlaybackFile with FOM details.
  • Reads messages up to the last timestamp in the file, pulling them in buffered batches.
• HLA-specific conversion:
  • For HLA builds, DtLgrHlaMessageState converts offline packets to online form to ensure valid handle mapping when creating interactions.
  • Exercise connection and FOM details are inferred from embedded config metadata (federation name, FOM version/modules, mapper settings).
• Offset application:
  • For each packet, a new packet is created with the same data/type/entity tracking ID, but time is adjusted by the requested offset.
  • Negative times after offset are clamped to 0.
  • The example prints the first before/after time seen in each read batch.
• Writing:
  • Uses DtLoggerFileWriter (DIS: DtLgrDisRecordFile, HLA: DtLgrHlaRecordFile) and outputs messages in batches for efficiency.
  • Writer is activated before writing and deactivated after completion.
• User interaction:
  • Press 'q' or Enter to stop early during processing.

Code Structure

• main(): Entry point; delegates to offsetFile(argc, argv).
• offsetFile(): Parses arguments, registers file formats, validates input, sets up reader/writer, processes packets, applies the offset, and writes output.
• keyCheck(): Checks for 'q' or Enter to allow early termination.
• openFileForReading()/openFileForWriting(): Protocol-specific helpers for DIS/HLA to create reader and writer instances.
• HLA helpers:
  • setConfigParameters(): Extracts configuration metadata from the tape to initialize the exercise connection.
  • readPacket(): Demonstrates creating and printing HLA interactions (optional display).

Defaults

If filenames are omitted:

• Input defaults to a protocol-specific sample file in "..\\logger_tapes\\...".
• Output defaults to "<inputBaseName>-Offset.lgr" alongside the input.

Notes

• The example focuses on timestamp manipulation only; packet content is not modified.
• HLA execution requires RTI compatibility; a mismatch throws DtVlRtiMismatchException.

Source Code

/*******************************************************************************
** Copyright (c) 1992-2025 MAK Technologies, Inc
** All rights reserved.
*******************************************************************************/

#include <lgrUtil/absoluteTime.h>
#include <lgrCore/lgrPlaybackInterface.h>
#include <lgrUtil/lgrPrint.h>
#include <lgrCore/lgrSimInterface.h>
#include <lgrCore/loggerPlaybackFile.h>

#include <vlutil/vlProcessControl.h>
#include <vlutil/vlPrint.h>
#include <vlutil/vlMiniDumper.h>
#include <cmdLine/cmdLine.h>
#include <lgrUtil/lgrVersion.h>

#if DtDIS
#include <vl/exerciseConnInitializerDIS.h>
#include <lgrSim/disLogger.h>
#include <lgrSim/lgrDisFileFormats.h>
#endif

#if DtHLA
#include <vl/exerciseConnInitializerHLA.h>
#include <lgrSim/hlaLogger.h>
#include <lgrSim/lgrHlaFileFormats.h>
#include <lgrSim/lgrHlaConfigData.h>
#include <vl/emptyFomMapper.h>
#endif
#include "vlutil/vlLogFileInfo.h"
#include "lgrUtil/svnRev.h"

using namespace MAKLogger;

// Hard coded paths for files. Relative to the bin directories.
#if DtDIS
const char defaultFileName[] = "..\\logger_tapes\\bombMission2025-DIS.lgr";
#elif DtHLA_4
const char defaultFileName[] = "..\\logger_tapes\\bombMission2025-HLA4-NETN.lgr";
//#elif DtHLA_1516_EVOLVED     // no default logger tape provided for HLA 1516 Evolved protocol
//const char defaultFileName[] = "..\\logger_tapes\<lgr filename>";
//#elif DtHLA_1516     // no default logger tape provided for HLA 1516 protocol
//const char defaultFileName[] = "..\\logger_tapes\<lgr filename>";
//#else     // no default logger tape provided for HLA 1.3 protocol
//const char defaultFileName[] = "..\\logger_tapes\<lgr filename>";
#endif

bool fileTypeMatches(DtString& filename);
void setConfigParameters(DtExerciseConnInitializer& exConnInit, const DtFilename& filename);
bool keyCheck(const char* keysToCheck);

int playFile(int argc, char** argv)
{
   DtCmdLine::CmdLine cmdLine("playFile","Example of how to play a logger file.",LOGGER_VERSION_STRING);
   DtCmdLine::UnlabeledMultiArg<DtString> filenameArg("Filename","The name of the logger file to play.","string");
   DtCmdLine::ValueArg<double> playbackSpeed("s","speed", "The playback speed.",false, 1.0,"double");
   cmdLine.add(&filenameArg);
   cmdLine.add(playbackSpeed);
   cmdLine.parse(argc,argv);

   std::vector<DtString> values = filenameArg.getValue();
   if(values.size() == 0)
   {
#ifdef DtHLA_4
      values.push_back(defaultFileName);
#elif DtHLA_1516_EVOLVED
      DtInfo << "Please provide a logger file using the HLA 1516 Evolved protocol to read." << std::endl;
      return 1;
#elif DtDIS
      values.push_back(defaultFileName);
#elif DtHLA_1516
      DtInfo << "Please provide a logger file using the HLA 1516 protocol to read." << std::endl;
      return 1;
#else
      DtInfo << "Please provide a logger file using the HLA 1.3 protocol to read." << std::endl;
      return 1;
#endif
   }
   DtFilename filename(values.front().c_str());

   try
   {

   // Initialize logger with settings retrieved from file.
   DtExerciseConnInitializer exConnInit;

   // Create the logger based upon it's protocol. These helper sub classes
   // automatically register the protocol and provide additional utility
   // functions.
#if DtDIS
   // Create a DIS logger
   DtDisLogger* aLogger = DtDisLogger::create(true);
#else
   exConnInit.setFederateType("playFile");
   exConnInit.setFederateName("playFile");
   // Create a HLA logger
   DtHlaLogger* aLogger = DtHlaLogger::create(true);
#endif

   if (!fileTypeMatches(filename))
   {
      DtInfo << "Unable to process file (" <<
         filename.c_str() << "): file format designator does not match, unknown or corrupted." << std::endl;
      return 1;
   }

#if DtHLA
   // Extract the configuration data from the file
   setConfigParameters(exConnInit, filename);
#endif

   aLogger->connect(exConnInit);

   DtLgrSimInterface* simInterface = DtLgrSimInterface::create(*aLogger);
   aLogger->tick();
   simInterface->update();
   if(!simInterface->isConnected())
   {
      DtInfo << "Unable to connect." << std::endl;
      return 1;
   }
   delete simInterface;

   // Create Playback interface for controlling playback.
   DtLgrPlaybackInterface* pbInterface = DtLgrPlaybackInterface::create(*aLogger);
   if(!pbInterface)
   {
      DtInfo << "Error: Unable to create playback interface." << std::endl;
      return 1;
   }

   // Tell the logger to open a file.
   pbInterface->openFile(filename, true);
   // Process Commands
   aLogger->tick();
   // Update interface
   pbInterface->update();

   // Check to see if file was loaded.
   if(!pbInterface->isFileLoaded())
   {
      DtInfo << "Unable to open file: " << filename << "." << std::endl;
      return 1;
   }

   if (playbackSpeed.isSet())
   {
      DtInfo << "Setting playback speed to " << playbackSpeed.getValue() << std::endl;
      pbInterface->setPlaybackSpeed(playbackSpeed.getValue(), false);
   }

   DtInfo << "Playing file: " << filename << "." << std::endl;
   DtInfo << "Press 'q' or 'enter' to quit." << std::endl;

   // Tell the logger to play.
   pbInterface->play();
   // Process Commands
   aLogger->tick();
   // Update interface
   pbInterface->update();

   // Check to see if playback was started.
   if(!pbInterface->isPlaying())
   {
      DtInfo << "Unable to play file." << std::endl;
      return 1;
   }

   // The number of seconds between print outs.
   double printDelay = 1.0;
   double printLoopTotal = 0;

   // The time of a loop.
   double loopDelay = .1;

   // Execution loop.
   while(pbInterface->isPlaying())
   {
      // Tick logger
      aLogger->tick();
      // Update Interface
      pbInterface->update();

      if(printLoopTotal >= printDelay)
      {
         DtInfo << "Current Time = " << pbInterface->currentTime() << "." << std::endl;
         printLoopTotal = 0.0;
      }
      printLoopTotal += loopDelay;
      DtSleep(loopDelay);
      // Break out if q or enter was pressed.
      if(keyCheck("q\r")) break;
   }

   // Check to see if the logger is still playing.
   if(pbInterface->isPlaying())
   {
      DtInfo << "Stopping playback." << std::endl;
      pbInterface->stop();
      // Make the logger stop.
      aLogger->tick();
   }

   DtInfo << "Finished playing file." << std::endl;
   DtRestoreKbHit();

   delete pbInterface;
   delete aLogger;

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

   return 0;
}

int main(int argc, char** argv)
{
   // Used for error handling
   DtLogFileInfo::instance().setAppName("PlayFile");
   DtLogFileInfo::instance().setProtocol(DT_PROTOCOL_SHORT_NAME);
   DtLogFileInfo::instance().setSvnRev(SVN_REV);
   DtLogFileInfo::instance().setVersion(LOGGER_VERSION_STRING);

   DtINIT_MINIDUMPER(DtLogFileInfo::instance().getFullString().c_str());
   return playFile(argc,argv);
}

bool keyCheck(const char* keysToCheck)
{
   if(DtKbHit())
   {
      char c = DtGetCh();
      return strchr(keysToCheck,c) != 0;
   }
   return false;
}

// Check that the file type matches one of the tape formats
bool fileTypeMatches(DtString& filename)
{
   unsigned int magic = 0;
   std::ifstream fs;
   fs.open(filename.c_str(),std::ios::binary );

   if(!fs.is_open() || !fs.good())
   {
      DtInfo << "Unable to open file: " << filename << "." << std::endl;
      exit(1);
   }

   fs.read((char*)&magic,4);

   magic = (magic >> 24) | ((magic >> 8) & 0xFF00) |
      ((magic << 8) & 0xFF0000) | (magic << 24);

   // File formats must be registered for this check to work
#if DtDIS
   return DtString("Unknown") != DtLgrDisFileFormats::versionString(magic);
#else
   return DtString("Unknown") != DtLgrHlaFileFormats::versionString(magic);
#endif
}

#if DtHLA
// Add the specific parameters for the tape.
void setConfigParameters(DtExerciseConnInitializer& exConnInit, const DtFilename& filename)
{
   // Open the file and grab the config meta data
   DtLoggerPlaybackFile* file = 0;
   try
   {
      file = new DtLoggerPlaybackFile(DtString(filename.c_str()), false, true);
   }
   catch(DtException& ex)
   {
      DtString output = DtSerializeException(ex);
      DtInfo << output << std::endl;
   }

   const DtPacket* configPacket =
      file->formatter()->metaData()->getMetaData(DtLoggerFileMetaData::StartOfFile,
      DtPacket::Type_ConfigData);

   DtLgrHlaConfigData configData;
   if(configPacket)
   {
      configData.deserialize(configPacket->data());
   }

   // Use the config meta data to set the exercise connection initializer
   // that select things like the FOM version, FOM file name, etc.
   if (!configData.fomVersion().isEmpty())
      exConnInit.setRprFomVersion(configData.fomVersion().toDouble());

   if (!configData.fomMapperName().isEmpty())
   {
      exConnInit.setFomMapperLibName(configData.fomMapperName());
      if (!configData.fomMapperInitData().isEmpty())
      {
         exConnInit.setFomMapperInitData((void*)configData.fomMapperInitData().c_str());
      }
   }

   if (!configData.emptyFomMapper().isEmpty() && configData.emptyFomMapper() != "0")
   {
      exConnInit.setFomMapper(new DtEmptyFomMapper());
   }

   exConnInit.setExecName(configData.federationName());

   DtFilename fedFile(configData.fedFile().c_str());
   fedFile.stripPath();
   exConnInit.setFedFileName(fedFile);

#if DtHLA_1516_EVOLVED
   std::vector<DtString> fomModNames;
   configData.getFomModules(fomModNames);
   int numberModules = fomModNames.size();
   if (numberModules > 0)
   {
      for (int fmIndex=0; fmIndex < numberModules; ++fmIndex)
      {
         DtFilename fmFilename(fomModNames[fmIndex].c_str());
         fmFilename.stripPath();
         fomModNames[fmIndex] = fmFilename;
      }
      exConnInit.setFomModules(fomModNames);
   }

   if (!configData.mim().isEmpty())
   {
      DtFilename mim(configData.mim().c_str());
      mim.stripPath();
      exConnInit.setMimModule(mim);
   }
#endif

   delete file;
}
#endif