ArgumentsParser.h

Go to the documentation of this file.

/*
 *  CepGen: a central exclusive processes event generator
 *  Copyright (C) 2019-2024  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 <map>
#include <string>
 
#include "CepGen/Utils/Limits.h"
 
namespace cepgen {
  class ArgumentsParser {
  public:
    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;
    }
    template <typename... Args>
    inline ArgumentsParser& addOptionalArgument(Args&&... args) {
      params_.emplace_back(std::forward<Args>(args)...);
      params_.rbegin()->optional = true;
      return *this;
    }
    ArgumentsParser& parse();                             
    std::string operator[](std::string name) const;       
    void dump() const;                                    
    void print_help() const;                              
    void print_version() const;                           
    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:
      Parameter(std::string, std::string = "", std::string* = nullptr, std::string = "");
      Parameter(std::string name, std::string, unsigned int* = nullptr, unsigned int = 0);
      Parameter(std::string, std::string, int* = nullptr, int = 0);
      Parameter(std::string, std::string, bool* = nullptr, bool = false);
      Parameter(std::string, std::string, double* = nullptr, double = -999.999);
      Parameter(std::string, std::string, std::vector<std::string>* = nullptr, std::vector<std::string> = {});
      Parameter(std::string, std::string, std::vector<int>* = nullptr, std::vector<int> = {});
      Parameter(std::string, std::string, std::vector<double>* = nullptr, std::vector<double> = {});
      Parameter(std::string, std::string, Limits* = nullptr, 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};     
    };
    typedef std::vector<Parameter> ParametersCollection;  
 
    std::string command_name_;
    const ParametersCollection help_str_;
    const ParametersCollection version_str_;
    const ParametersCollection config_str_;
    const ParametersCollection debug_str_;
    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> extra_config_;
  };
}  // namespace cepgen
 
#endif