ArgumentsParser.h

Go to the documentation of this file.

/*
 *  CepGen: a central exclusive processes event generator
 *  Copyright (C) 2019-2025  Laurent Forthomme
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef CepGen_Utils_ArgumentsParser_h
#define CepGen_Utils_ArgumentsParser_h
 
#include <string>
 
#include "CepGen/Utils/Limits.h"
 
namespace cepgen {
  class ArgumentsParser {
  public:
    explicit ArgumentsParser(int argc, char* argv[]);
    template <typename... Args>
    inline ArgumentsParser& addArgument(Args&&... args) {
      params_.emplace_back(std::forward<Args>(args)...);
      params_.rbegin()->optional = false;
      return *this;
    }
    inline ArgumentsParser& addArgument(Args&&... args) {…}
    template <typename... Args>
    inline ArgumentsParser& addOptionalArgument(Args&&... args) {
      params_.emplace_back(std::forward<Args>(args)...);
      params_.rbegin()->optional = true;
      return *this;
    }
    inline ArgumentsParser& addOptionalArgument(Args&&... args) {…}
    ArgumentsParser& parse();                               
    std::string operator[](const std::string& name) const;  
    void dump() const;                                      
    void print_help() const;                                
    static void print_version();                            
    std::string help_message() const;                       
    inline bool debugging() const { return debug_req_; }    
    inline const std::vector<std::string>& extra_config() const { return extra_config_; }  
 
  private:
    class Parameter {
    public:
      explicit Parameter(const std::string&,
                         const std::string& = "",
                         std::string* = nullptr,
                         const std::string& = "");  
      explicit Parameter(const std::string&,
                         const std::string&,
                         unsigned int* = nullptr,
                         const unsigned int& = 0);  
      explicit Parameter(const std::string&,
                         const std::string&,
                         int* = nullptr,
                         const int& = 0);  
      explicit Parameter(const std::string&,
                         const std::string&,
                         bool* = nullptr,
                         const bool& = false);  
      explicit Parameter(const std::string&,
                         const std::string&,
                         double* = nullptr,
                         const double& = -999.999);  
      explicit Parameter(const std::string&,
                         const std::string&,
                         std::vector<std::string>* = nullptr,
                         const std::vector<std::string>& = {});  
      explicit Parameter(const std::string&,
                         const std::string&,
                         std::vector<int>* = nullptr,
                         const std::vector<int>& = {});  
      explicit Parameter(const std::string&,
                         const std::string&,
                         std::vector<double>* = nullptr,
                         const std::vector<double>& = {});  
      explicit Parameter(const std::string&,
                         const std::string&,
                         Limits* = nullptr,
                         const Limits& = Limits{});  
 
      Parameter& parse();  
      inline bool boolean() const { return bool_variable_ != nullptr; }  
      bool matches(const std::string&) const;  
 
      // parameters attributes
      std::vector<std::string> name;  
      std::string description;        
      std::string value;              
      bool optional{true};            
 
    private:
      // parameters containers
      std::string* str_variable_{nullptr};                   
      double* float_variable_{nullptr};                      
      int* int_variable_{nullptr};                           
      unsigned int* uint_variable_{nullptr};                 
      bool* bool_variable_{nullptr};                         
      Limits* lim_variable_{nullptr};                        
      std::vector<std::string>* vec_str_variable_{nullptr};  
      std::vector<int>* vec_int_variable_{nullptr};          
      std::vector<double>* vec_float_variable_{nullptr};     
    };
    using ParametersCollection = std::vector<Parameter>;  
 
    const std::string command_name_;
    bool help_req_{false}, version_req_{false}, debug_req_{false};
    ParametersCollection params_;
    std::vector<std::pair<std::string, std::string> > args_;
    std::vector<std::string> add_ons_;
    std::vector<std::string> extra_config_;
  };
}  // namespace cepgen
 
#endif
    inline const std::vector<std::string>& extra_config() const { return extra_config_; }   {…}
  class ArgumentsParser {…};