vreCommandLineProcessor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreCommandLineProcessor.h
//! \ingroup vreUtil
//! \brief Processes command line arguments for VREngage application
//!
//! This file contains the DtVreCommandLineProcessor class which handles command line
//! processing for the VREngage application. It supports various connection protocols
//! including DIS, HLA13, HLA1516, and HLA1516e, and enables automatic driver creation
//! and configuration based on command line arguments.
 
#pragma once
 
#include "vreUtil/export.h"
 
#include <vrvCore/DtStealthCommandLineProcessor.h>
#include <vrvCore/DtVrvApplicationConfiguration.h>
 
#include <vrvUtil/DtDisplayConfiguration.h>
#include <vrvUtil/DtVrvCommandLineParser.h>
 
#include <cmdLine/cmdArg.h>
#include <cmdLine/cmdLine.h>
 
namespace makVre
{
//! \brief Command line processor for the VREngage application
//!
//! This class processes command line arguments for the VREngage application
//! and configures the application accordingly. It extends the VR-Forces command
//! line processor with support for protocol-specific options (--dis, --hla13,
//! --hla1516, or --hla1516e). Using these options generates and auto-starts
//! a new driver using the supplied arguments.
class UTIL_DLL DtVreCommandLineProcessor : public makVrv::DtStealthCommandLineProcessor
{
protected:
   using DtAdditionalCommandsFcn =
      boost::function<void(std::vector<DtCmdLine::Arg*>&, makVrv::DtStealthCommandLineProcessor::StealthArgs&)>;
 
public:
   //! \brief Default constructor
   //!
   //! Creates a command line processor for VREngage and initializes the
   //! command line options
   DtVreCommandLineProcessor();
 
   //! \brief Virtual destructor
   //!
   //! Cleans up any resources allocated by the command line processor
   virtual ~DtVreCommandLineProcessor() override;
 
   //! \brief Processes command line arguments and updates application configuration
   //! \param appConfig Application configuration to update based on command line args
   //! \param argc Number of command line arguments
   //! \param argv Array of command line argument strings
   //!
   //! This method parses the command line arguments and modifies the application
   //! configuration accordingly. It handles protocol-specific options and creates
   //! drivers as needed.
   virtual void processCommandLine(makVrv::DtVrvApplicationConfiguration& appConfig, int argc, char** argv) override;
 
   //! \brief Removes any automatically created driver
   //!
   //! This method deletes any driver that was created by the command line processor
   //! for automatic connection startup
   virtual void removeAutoStartDriver();
 
   //! \brief Gets the name of the automatically created driver
   //! \return Name of the auto-start driver, or empty string if none created
   //!
   //! This method returns the name of the driver that was automatically created
   //! based on command line arguments
   const std::string& autoStartDriver() const { return myAutoStartDriver; }
 
   //! \brief Gets the initialization settings file path
   //! \return Path to the initialization settings file
   //!
   //! Returns the initialization settings file path specified on the command line
   std::string customSettingsFile() const;
 
   
   std::string customSettingsString() const;
 
   //! \brief Gets the station name
   //! \return Station name specified on the command line
   //!
   //! Returns the station name specified on the command line
   std::string stationName() const;
 
   //! \brief Gets the application mode
   //! \return Application mode specified on the command line
   //!
   //! Returns the application mode specified on the command line (e.g., air, ground, sensor)
   std::string applicationMode() const;
 
protected:
   //! \brief Base structure for protocol-independent parameters
   //!
   //! This struct contains parameters common to all protocol types and serves
   //! as a base class for protocol-specific parameter structures
   struct BaseArgs
   {
      virtual void processArgs(
         makVrv::DtVrvApplicationConfiguration& appConfig, StealthArgs& args, std::string& autoStartDriver) = 0;
      virtual std::string driverName() const = 0;
      virtual std::string driverClass() const = 0;
 
      DtVreCommandLineProcessor* myParser;
      DtCmdLine::ValueArg<int>* siteId;
      DtCmdLine::ValueArg<int>* appId;
      DtCmdLine::SwitchArg* useAbsoluteTimeStamps;
      DtCmdLine::ValueArg<int>* fileTransporterReceivePort;
   };
 
   //! \brief Structure containing DIS-specific parameters
   //!
   //! This structure extends BaseArgs with parameters specific to the
   //! Distributed Interactive Simulation (DIS) protocol
   struct DisArgs : public BaseArgs
   {
      virtual void processArgs(
         makVrv::DtVrvApplicationConfiguration& appConfig, StealthArgs& args, std::string& autoStartDriver) override;
      virtual std::string driverName() const override;
      virtual std::string driverClass() const override;
 
      DtCmdLine::ValueArg<int>* port;
      DtCmdLine::ValueArg<int>* exerciseId;
      DtCmdLine::ValueArg<int>* disVersion;
      DtCmdLine::ValueArg<std::string>* destinationAddress;
      DtCmdLine::ValueArg<std::string>* deviceAddress;
      DtCmdLine::ValueArg<std::string>* subnetMask;
      DtCmdLine::ValueArg<std::string>* hostAddress;
      DtCmdLine::ValueArg<std::string>* reportedHostAddress;
      DtCmdLine::ValueArg<std::string>* appIdRange;
      DtCmdLine::ValueArg<int>* sessionId;
      DtCmdLine::ValueArg<int>* receiveBufferSize;
      DtCmdLine::ValueArg<int>* sendBufferSize;
      DtCmdLine::SwitchArg* useAsynchIO;
      DtCmdLine::SwitchArg* useIpv6;
      DtCmdLine::ValueArg<int>* multicastTTL;
      DtCmdLine::MultiArg<std::string>* multicastAddresses;
      DtCmdLine::ValueArg<double>* defaultObjectTimeout;
   };
 
   //! \brief Structure containing HLA 1.3 specific parameters
   //!
   //! This structure extends BaseArgs with parameters specific to the
   //! High Level Architecture (HLA) 1.3 protocol
   struct Hla13Args : public BaseArgs
   {
      virtual void processArgs(
         makVrv::DtVrvApplicationConfiguration& appConfig, StealthArgs& args, std::string& autoStartDriver) override;
      virtual void setupHlaConfiguration(makVrv::DtConfiguration& config, StealthArgs& args);
      virtual std::string driverName() const override;
      virtual std::string driverClass() const override;
 
      DtCmdLine::ValueArg<std::string>* execName;
      DtCmdLine::ValueArg<std::string>* fedFileName;
      DtCmdLine::ValueArg<std::string>* fomMapperLibName;
      DtCmdLine::ValueArg<std::string>* fomMapperInitData;
      DtCmdLine::ValueArg<std::string>* hostAddress;
      DtCmdLine::ValueArg<std::string>* reportedHostAddress;
      DtCmdLine::ValueArg<int>* sessionId;
      DtCmdLine::ValueArg<double>* rprFomVersion;
      DtCmdLine::ValueArg<int>* rprFomRevision;
      DtCmdLine::SwitchArg* useAdvisories;
      DtCmdLine::SwitchArg* useGeographicDdm;
      DtCmdLine::ValueArg<std::string>* federateType;
   };
 
   //! \brief Structure containing HLA 1516 specific parameters
   //!
   //! This structure extends Hla13Args with parameters specific to the
   //! High Level Architecture (HLA) 1516 protocol
   struct Hla1516Args : public Hla13Args
   {
      virtual std::string driverName() const override;
      virtual std::string driverClass() const override;
   };
 
   //! \brief Structure containing HLA 1516e specific parameters
   //!
   //! This structure extends Hla13Args with parameters specific to the
   //! High Level Architecture (HLA) 1516e protocol
   struct Hla1516eArgs : public Hla13Args
   {
      virtual void setupHlaConfiguration(makVrv::DtConfiguration& config, StealthArgs& args) override;
 
      virtual std::string driverName() const override;
      virtual std::string driverClass() const override;
 
      DtCmdLine::MultiArg<std::string>* fomModule;
      DtCmdLine::ValueArg<std::string>* federateName;
      DtCmdLine::ValueArg<std::string>* localSettingsDesignator;
   };
 
   //! \brief Structure containing VREngage specific parameters
   //!
   //! This structure extends StealthArgs with parameters specific to VREngage
   //! and VR-Forces, as well as connection-specific parameters. Based on
   //! the VR-Forces DtVrfGuiCommandLineParser::VrfGuiArgs structure.
   struct VreArgs : public makVrv::DtStealthCommandLineProcessor::StealthArgs
   {
      DtCmdLine::SwitchArg* disMode;
      DtCmdLine::SwitchArg* hla13Mode;
      DtCmdLine::SwitchArg* hla1516Mode;
      DtCmdLine::SwitchArg* hla1516eMode;
      DtCmdLine::SwitchArg* enableSensorFX;
 
      DtCmdLine::ValueArg<std::string>* customSettingsFile;
      DtCmdLine::ValueArg<std::string>* customSettingsString;
      DtCmdLine::ValueArg<std::string>* stationName;
 
      makVrv::SwitchArg* airMode;
      makVrv::SwitchArg* groundMode;
      makVrv::SwitchArg* sensorMode;
 
      DtCmdLine::ValueArg<std::string>* applicationModeArg;
      makVrv::SwitchArg* enableAdminMode;
      makVrv::SwitchArg* disableEscapeKeyArg;
 
      makVrv::SwitchArg* windowedMode;
 
      std::vector<BaseArgs*> additionalArguments;
   };
 
   //! \brief Updates application configuration based on parsed arguments
   //! \param appConfig Application configuration to update
   //! \param args Parsed command line arguments
   //!
   //! This method updates the application configuration based on the command line
   //! arguments that have been parsed into the VreArgs structure
   virtual void processArgs(makVrv::DtVrvApplicationConfiguration& appConfig, VreArgs& args);
 
   //! \brief Creates a new driver after removing existing VR-Forces drivers
   //! \param appConfig Application configuration
   //! \param config Driver configuration
   //! \param baseArgs Base arguments for driver creation
   //! \param autoStarted Output parameter to store the name of the created driver
   //!
   //! This method removes all existing drivers created by VR-Forces from the
   //! drivers path and creates a new driver based on the provided configuration
   virtual void createDriver(const makVrv::DtVrvApplicationConfiguration& appConfig,
      const makVrv::DtConfiguration& config, BaseArgs* baseArgs, std::string& autoStarted);
 
   //! \brief Creates a new driver file with specific name and class
   //! \param app Application configuration
   //! \param config Driver configuration
   //! \param driverName Name for the driver
   //! \param driverClass Class of the driver
   //! \param fullName Output parameter to store the full path of the created driver
   //! \return Name of the created driver
   //!
   //! This method creates a new driver file based on the provided configuration,
   //! with the specified name and class
   virtual std::string createDriver(const makVrv::DtVrvApplicationConfiguration& app,
      const makVrv::DtConfiguration& config, const std::string& driverName, const std::string& driverClass,
      std::string& fullName);
 
   //! \brief Generates a filename for a new auto-start driver file
   //! \param app Application configuration
   //! \param driverClass Class of the driver
   //! \param driverName Name of the driver
   //! \return Generated filename for the driver
   //!
   //! This method generates an appropriate filename for a new auto-start driver file
   virtual std::string createDriverFileName(
      const makVrv::DtVrvApplicationConfiguration& app, const std::string& driverClass, const std::string& driverName);
 
protected:
   //! \name Protocol-Specific Argument Handlers
   //! \brief Methods to add protocol-specific flags to the parser
   //!
   //! These methods are called when the optional flags "--dis", "--hla13", etc. are
   //! found on the command line to add protocol-specific command line arguments.
   //! @{
 
   //! \brief Adds DIS-specific command line arguments
   //! \param argumentOrder Vector of arguments to append to
   //! \param args VreArgs structure to update with new arguments
   virtual void addDisCommandArguments(std::vector<DtCmdLine::Arg*>& argumentOrder, VreArgs& args);
 
   //! \brief Adds HLA 1.3 specific command line arguments
   //! \param argumentOrder Vector of arguments to append to
   //! \param args VreArgs structure to update with new arguments
   virtual void addHla13CommandArguments(std::vector<DtCmdLine::Arg*>& argumentOrder, VreArgs& args);
 
   //! \brief Adds HLA 1516 specific command line arguments
   //! \param argumentOrder Vector of arguments to append to
   //! \param args VreArgs structure to update with new arguments
   virtual void addHla1516CommandArguments(std::vector<DtCmdLine::Arg*>& argumentOrder, VreArgs& args);
 
   //! \brief Adds HLA 1516e specific command line arguments
   //! \param argumentOrder Vector of arguments to append to
   //! \param args VreArgs structure to update with new arguments
   virtual void addHla1516eCommandArguments(std::vector<DtCmdLine::Arg*>& argumentOrder, VreArgs& args);
   //! @}
 
   //! \brief Adds command line arguments common to all HLA versions
   //! \param argumentOrder Vector of arguments to append to
   //! \param args VreArgs structure to update with new arguments
   //! \param hlaArgs HLA-specific arguments structure to update
   //!
   //! This method adds command line arguments that are common to all HLA versions
   virtual void addHlaCommandArguments(std::vector<DtCmdLine::Arg*>& argumentOrder, VreArgs& args, Hla13Args* hlaArgs);
 
   //! \brief Sets up default argument values
   //! \param args VreArgs structure to set up defaults for
   //! \param argumentOrder Vector of arguments to append to
   //!
   //! This method initializes default values for any command line arguments
   //! not explicitly specified by the user
   virtual void setupArguments(VreArgs& args, std::vector<DtCmdLine::Arg*>& argumentOrder);
 
   //! \brief Map of command names to handler functions for additional commands
   std::map<std::string, DtAdditionalCommandsFcn> myAdditionalCommands;
 
   //! \brief Name of the automatically created driver
   std::string myAutoStartDriver;
 
   //! \brief List of additional command line arguments
   std::vector<DtCmdLine::Arg*> myAdditionalCommandLineArguments;
 
   //! \brief Current application mode
   std::string myApplicationMode;
};
 
} // namespace makVre