recordFile Example

The recordFile program creates a logger, opens a logger tape, and plays it back.

Periodic messages output the current tape time. If 'q' is pressed playback stops and the program exits\ immediately, otherwise it will continue to the end of the tape at which point it will exit.

---

The main application:

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

#include <lgrCore/lgrRecordInterface.h>
#include <lgrCore/lgrSimInterface.h>

#include <vlutil/vlProcessControl.h>
#include <vlutil/vlPrint.h>
#include <vlutil/vlMiniDumper.h>

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

#if DtHLA
#include <vl/exerciseConnInitializerHLA.h>
#include <lgrSim/hlaLogger.h>
#endif

#include <lgrUtil/lgrVersion.h>
#include <cmdLine/cmdLine.h>
#include "vlutil/vlLogFileInfo.h"
#include "lgrUtil/svnRev.h"

using namespace MAKLogger;

// Hard coded paths for files. Relative to the bin directories.
#if DtHLA
const char defaultFileName[] = ".\\outputFileHLA.lgr";
#endif

#if DtDIS
const char defaultFileName[] = ".\\outputFileDIS.lgr";
#endif

// Record time for 1 minute.
const double totalTimeToRecord = 60.0;

// Global variables.
DtLgrSimInterface* simInterface;
DtLgrRecordInterface* recInterface;

// Function creates the interfaces to the logger. Interfaces are how to
// control modules of the logger as well as get info about those modules.
void createInterfaces(DtLogger& logger)
{
   simInterface = DtLgrSimInterface::create(logger);
   assert(simInterface);
   recInterface = DtLgrRecordInterface::create(logger);
   assert(recInterface);
}

// Function for ticking the logger as well as updating the interfaces.  To get
// up to date information from the logger an interface must be updated.  If an
// interface is not updated messages from the logger will be remain in memory
// and eventually could result in the system running out of memory.  After
// every command sent by and interface the logger must be ticked to execute
// the command.  It is acceptable to send multiple command before ticking the
// logger.
void tickAndUpdate(DtLogger& logger)
{
   bool canContinue = logger.tick();
   if(!canContinue) return;

   assert(simInterface);
   simInterface->update();

   assert(recInterface);
   recInterface->update();
}

// Function foe checking if any keys in the array are pressed.
bool keyCheck(const char* keysToCheck)
{
   if(DtKbHit())
   {
      int c = DtGetCh();
      return strchr(keysToCheck,c) != 0;
   }
   return false;
}

// Example entry point
int recordFile(int argc, char** argv)
{

   DtCmdLine::CmdLine cmdLine("writeFile","Example of how to write a logger file.",LOGGER_VERSION_STRING);
   DtCmdLine::UnlabeledMultiArg<DtString> filenameArg("Filename","The name of the logger file to write.","string");
   DtString description = "Description text for the logger tape";
   cmdLine.add(&filenameArg);
   cmdLine.parse(argc,argv);

   std::vector<DtString> values = filenameArg.getValue();
   if(values.size() == 0)
   {
      values.push_back(defaultFileName);
   }
   DtString theFileName(values.front());

   // Initialize logger with default settings.
   DtExerciseConnInitializer exConnInit;

   // Create the logger based upon it's protocol. These helped sub classes
   // automatically register the protocol and provide additional utility
   // functions.
#if DtDIS
   DtDisLogger* aLogger = DtDisLogger::create(true);
#endif

#if DtHLA
   exConnInit.setFederateType("recordFile");
   exConnInit.setFederateName("recordFile");
   DtHlaLogger* aLogger = DtHlaLogger::create(true);
#endif

#if DtHLA
   // Set the default FED File, executable, and version
   exConnInit.setFedFileName( DtDefaultRpr2Fom );
   exConnInit.setExecName( "MAK-RPR-2.0" );
   exConnInit.setRprFomVersion( 2.0 );
   exConnInit.setRprFomRevision( 2 );
#ifdef DtHLA_1516_EVOLVED
   std::vector<DtString> fomModules;
   std::vector<DtString> fomModuleFromCommandLine;
   exConnInit.fomModules(fomModuleFromCommandLine);
   fomModules.push_back("MAK-VRFExt-6_evolved.xml");
   fomModules.push_back("MAK-DIGuy-7_evolved.xml");
   fomModules.push_back("MAK-LgrControl-2_evolved.xml");
   fomModules.push_back("MAK-VRFAggregate-3_evolved.xml");
   fomModules.push_back("MAK-DynamicTerrain-2_evolved.xml");
   fomModules.insert(fomModules.end(), fomModuleFromCommandLine.begin(), fomModuleFromCommandLine.end());
   exConnInit.setFomModules(fomModules);
#endif
#endif

   aLogger->connect(exConnInit);

   createInterfaces(*aLogger);
   tickAndUpdate(*aLogger);

   if(!simInterface->isConnected())
   {
      DtInfo << "Unable to connect." << std::endl;
      return 1;
   }

   recInterface->startNewFile(theFileName, description, true);
#if 0
   // Record to a multipart logger file
   recInterface->setRecordToMultipleFilesSettings( 10, "%FileDir%/%FileName%_%Index%.lgr" );
   tickAndUpdate(*aLogger);
   recInterface->recordToMultipleFiles( theFileName );
   tickAndUpdate(*aLogger);
#endif

   tickAndUpdate(*aLogger);

   if(!recInterface->isFileLoaded())
   {
      DtInfo << "Unable to start new file." << std::endl;
      return 1;
   }

   // Start recording.
   recInterface->record();
   tickAndUpdate(*aLogger);

   // Verify that it is recording.
   if(!recInterface->isRecording())
   {
      DtInfo << "Unable to start recording." << 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;

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

   while(recInterface->currentTime() < totalTimeToRecord)
   {
      tickAndUpdate(*aLogger);

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

   // Stop the recording.
   recInterface->stop(false);
   tickAndUpdate(*aLogger);

   // Close the file.
   recInterface->closeFile();
   tickAndUpdate(*aLogger);
   DtRestoreKbHit();

   DtDELETE(aLogger);

   return 0;

}

// The application entry point
int main(int argc,char** argv)
{
   // Used for error handling
   DtLogFileInfo::instance().setAppName("RecordFile");
   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 recordFile(argc,argv);
}