command_line_arg_parser.h

Go to the documentation of this file.

 
#ifndef COMMAND_LINE_ARG_PARSER_H
#define COMMAND_LINE_ARG_PARSER_H
 
namespace argos {
   class CCommandLineArgParser;
}
 
#include <argos3/core/utility/datatypes/datatypes.h>
#include <argos3/core/utility/string_utilities.h>
#include <argos3/core/utility/logging/argos_log.h>
#include <vector>
#include <string>
#include <iostream>
 
namespace argos {
 
   class CCommandLineArgParser {
 
   public:
 
      CCommandLineArgParser();
 
      virtual ~CCommandLineArgParser();
 
      void AddFlag(char ch_short_option,
                   const std::string& str_long_option,
                   const std::string& str_description,
                   bool& b_flag) {
         m_vecArguments.push_back(
            new CArgument<bool>(
               ch_short_option,
               str_long_option,
               str_description,
               true,
               b_flag));
         b_flag = false;
      }
 
      template <typename T> void AddArgument(char ch_short_option,
                                             const std::string& str_long_option,
                                             const std::string& str_description,
                                             T& t_buffer) {
         m_vecArguments.push_back(
            new CArgument<T>(
               ch_short_option,
               str_long_option,
               str_description,
               false,
               t_buffer));
      }
 
      virtual void PrintUsage(CARGoSLog& c_log);
 
      virtual void Parse(SInt32 n_argc,
                         char** ppch_argv);
 
   private:
 
      void ParseLongOption (SInt32 n_argc,  char** ppch_argv);
      void ParseShortOption (SInt32 n_argc, char** ppch_argv);
      void ParseShortOptions(SInt32 n_argc, char** ppch_argv);
 
   private:
 
      class CAbstractArgument {
 
      public:
 
         virtual ~CAbstractArgument() {}
         virtual void Parse(const std::string& str_value) = 0;
 
      public:
 
         char        ShortOption;
         std::string LongOption;
         std::string Description;
         bool IsFlag;
 
      };
 
      template <typename T> class CArgument : public CAbstractArgument {
 
      public:
      
         CArgument(char ch_short_option,
                   const std::string& str_long_option,
                   const std::string& str_description,
                   bool b_is_flag,
                   T& t_buffer) :
            m_tBuffer(t_buffer) {
            ShortOption = ch_short_option;
            LongOption  = str_long_option;
            Description = str_description;
            IsFlag      = b_is_flag;
         }
      
         virtual void Parse(const std::string& str_value) {
            m_tBuffer = FromString<T>(str_value);
         }
 
         T& m_tBuffer;
      };
 
   private:
 
      std::vector<CAbstractArgument*> m_vecArguments;
      SInt32 m_nCurrentArgument;
 
   };
 
}
 
#endif