exportFileToDatabase Example

The exportToDatabase program creates a logger, opens a logger tape, and exports it to a MS Access database.

You must have a MS Access data source named "Logger MS Access ODBC" (or change the code accordingly). See the User Guide for instructions on how to set up the data source.

---

The main application:

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

#include <lgrUtil/absoluteTime.h>
#include <lgrCore/lgrPlaybackInterface.h>
#include <lgrUtil/lgrPrint.h>
#include <lgrCore/lgrSimInterface.h>
#include <lgrSqlExporter/lgrSqlExportSettings.h>
#include <lgrCore/lgrEditorInterface.h>
#include <lgrSim/lgrHlaFilterByClass.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>
#endif

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

using namespace MAKLogger;

// Hard coded paths for files. Relative to the bin directories.

#ifdef DtHLA
#ifdef DtHLA_1516
#ifdef DtHLA_1516_EVOLVED
const char defaultFileName[] = "..\\logger_tapes\\makland2016-HLAe-RPR20.lgr";

#else // DtHLA_1516 && !DtHLA_1516_EVOLVED
const char defaultFileName[] = "..\\logger_tapes\\makland2016-HLA516-RPR20.lgr";
#endif // DtHLA_1516_EVOLVED
#else // !DtHLA_1516
const char defaultFileName[] = "..\\logger_tapes\\makland2016-HLA13-RPR20.lgr";
#endif // DtHLA_1516
#else // !DtHLA
const char defaultFileName[] = "..\\logger_tapes\\makland2016-DIS.lgr";
#endif // DtHLA



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

// Add the database export to the editor interface.
#if DtDIS
#include <lgrSqlExporter/lgrDisSqlExporter.h>
typedef DtLgrDisSqlExporter TheExporter;
#elif DtHLA
#include <lgrSqlExporter/lgrHlaSqlExporter.h>
typedef DtLgrHlaSqlExporter TheExporter;
#endif
void addDatabaseExport(DtLgrEditorInterface* editorInterface)
{

   DtString fileFormat = TheExporter::theExportName();
   DtString fileFilter = "";

   // Do not offset the times.
   bool offsetData = false;

   // Do not generate extra data.
   bool generateData = false;

   // Export both selection and whole file.
   DtLgrEditorInterface::ExportType exportType = DtLgrEditorInterface::UserExport;

   DtLgrPacketPrinter* printer(0);

   printer = TheExporter::create();

   if(editorInterface)
   {
      editorInterface->addExportType(fileFormat,fileFilter,offsetData,generateData,
         exportType,std::auto_ptr<DtLgrPacketPrinter>(printer));
   }
}

// Capture export signals
class DtExportSlots
{
public:
   DtExportSlots()
      : myExportComplete(false)
      , myExportCanceled(false)
   {}
   ~DtExportSlots() {}

   void clearSignals()
   {
      myExportComplete = false;
      myExportCanceled = false;
   }

   bool MyExportComplete() const { return myExportComplete; }
   void MyExportComplete(bool val) { myExportComplete = val; }
   bool MyExportCanceled() const { return myExportCanceled; }
   void MyExportCanceled(bool val) { myExportCanceled = val; }

public:

      void exportCompleted(const DtString& exportType)
      {
         myExportComplete = true;
      }
      void exportCanceled(const DtString& exportType)
      {
         myExportCanceled = true;
      }

protected:
   bool myExportComplete;
   bool myExportCanceled;
};

int exportFile(int argc, char** argv)
{
   DtCmdLine::CmdLine cmdLine("exportFileToDatabase","Example of how to export a logger file to a database.",LOGGER_VERSION_STRING);
   DtCmdLine::UnlabeledMultiArg<DtString> filenameArg("Filename","The name of the logger file to export.","string");
   DtCmdLine::ValueArg<DtString> odbcDriverArg("d","odbcDriver","The name of the odbc driver.",false, "Microsoft Access Driver (*.mdb)", "string");
   DtCmdLine::ValueArg<DtString> odbcDataSourceArg("s","odbcSource","The name of the odbc data source.",false, "Logger MS Access ODBC", "string");
   DtCmdLine::ValueArg<DtString> odbcServerArg("r","odbcServer","The odbc server.",false, "localhost", "string");
   DtCmdLine::ValueArg<DtString> odbcUserArg("u","odbcUser","The odbc user name.",false, "root", "string");
   DtCmdLine::ValueArg<DtString> odbcPasswdArg("p","odbcPasswd","The odbc passwd.",false, "", "string");

   cmdLine.add(&filenameArg);
   cmdLine.add(&odbcDriverArg);
   cmdLine.add(&odbcDataSourceArg);
   cmdLine.add(&odbcServerArg);
   cmdLine.add(&odbcUserArg);
   cmdLine.add(&odbcPasswdArg);
   cmdLine.parse(argc,argv);

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

   try
   {
      // 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
   // Create a DIS logger
   DtDisLogger* aLogger = DtDisLogger::create(true);
#else
   // Create a HLA logger
   DtHlaLogger* aLogger = DtHlaLogger::create(true);

#ifdef DtHLA_1516
#ifdef DtHLA_1516_EVOLVED
   exConnInit.setFedFileName("VR-Link_evolved.xml");
#else // DtHLA_1516 && !DtHLA_1516_EVOLVED
   exConnInit.setFedFileName("VR-Link.xml");
#endif // DtHLA_1516_EVOLVED
#else // !DtHLA_1516
   exConnInit.setFedFileName("VR-Link.fed");
#endif // DtHLA_1516
#endif // DtDIS

   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 to open file
   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);
   // 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;
   }

   // Configure export settings (these are for HLA 1.3 and export to Microsoft Access database)
   DtSqlExportSettings mySettings;
   mySettings.setDriver(odbcDriverArg.getValue());
   mySettings.setServerName(odbcServerArg.getValue());
   mySettings.setUserName(odbcUserArg.getValue());
   mySettings.setPassword(odbcPasswdArg.getValue());
   mySettings.setDataSource(odbcDataSourceArg.getValue());
#ifdef DtHLA
#ifdef DtHLA_1516
#ifdef DtHLA_1516_EVOLVED
   mySettings.setOmtFile("VR-Link_evolved.xml");
#else // DtHLA_1516 && !DtHLA_1516_EVOLVED
   mySettings.setOmtFile("VR-Link.xml");
#endif // DtHLA_1516_EVOLVED
#else // !DtHLA_1516
   mySettings.setOmtFile("VR-Link.omt");
#endif // DtHLA_1516
#endif // DtHLA
   mySettings.setShortTableNames(1);
   mySettings.setGenerateInstanceTable(1);
   mySettings.setGenerateCheckpointTable(1);
   mySettings.setGenerateLargeSubcomponentTables(1);
   mySettings.setLargeSubcomponentThreshold(50);

#ifdef DtHLA
   // Add a class filter to remove updates of the specified class
   DtLgrHlaFilterByClass* classFilter = DtLgrHlaFilterByClass::create();
#ifdef DtHLA_1516
   classFilter->setFilterObjectClass("HLAobjectRoot.BaseEntity.PhysicalEntity.Platform.Aircraft", true);
#else // !DtHLA_1516
   classFilter->setFilterObjectClass("ObjectRoot.BaseEntity.PhysicalEntity.Platform.Aircraft", true);
#endif // DtHLA_1516
   mySettings.packetFilters().push_back(classFilter);
#endif // DtHLA

   DtString dest = mySettings.encodeDestination();


   // Create Editor interface for controlling export.
   DtLgrEditorInterface* editorInterface = DtLgrEditorInterface::create(*aLogger);
   if(!editorInterface)
   {
      DtInfo << "Error: Unable to create editor interface." << std::endl;
      return 1;
   }

   // Add the database export
   addDatabaseExport(editorInterface);

   // Add slots to capture result of export operation
   DtExportSlots exportSlots;

   DtConnect(editorInterface->exportCompletedSignal, &exportSlots, &DtExportSlots::exportCompleted);
   DtConnect(editorInterface->exportCanceledSignal, &exportSlots, &DtExportSlots::exportCanceled);

   editorInterface->exportFile("Database",dest,false,false);

   DtInfo << "Exporting file: " << filename << "." << std::endl;
   DtInfo << "Wait ...\n";

   // Export operation is processed within the single tick
   // Tick logger
   aLogger->tick();

   // Update Interface
   pbInterface->update();
   editorInterface->update();

   // Check to see if the logger is still completed the export.
   if (exportSlots.MyExportCanceled())
   {
      DtInfo << "Export was canceled." << std::endl;
   }
   else if(!exportSlots.MyExportComplete())
   {
      DtInfo << "Stopping export." << std::endl;
      editorInterface->cancelLongOperation();
      // Make the logger stop.
      aLogger->tick();
   }

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

   delete pbInterface;
   delete editorInterface;
   delete aLogger;

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

   return 0;
}

int main(int argc, char** argv)
{
   DtINIT_MINIDUMPER( "ExportFile" );
   return exportFile(argc,argv);
}