ParametersList.h

Go to the documentation of this file.

/*
 *  CepGen: a central exclusive processes event generator
 *  Copyright (C) 2018-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_Core_ParametersList_h
#define CepGen_Core_ParametersList_h
 
#include <map>
#include <string>
#include <unordered_map>
 
#include "CepGen/Utils/Limits.h"
 
#define REGISTER_CONTENT_TYPE                                            \
  __TYPE_ENUM(bool, bool_values_, "bool")                                \
  __TYPE_ENUM(int, int_values_, "int")                                   \
  __TYPE_ENUM(unsigned long long, ulong_values_, "ulong")                \
  __TYPE_ENUM(double, dbl_values_, "float")                              \
  __TYPE_ENUM(std::string, str_values_, "str")                           \
  __TYPE_ENUM(Limits, lim_values_, "Limits")                             \
  __TYPE_ENUM(ParametersList, param_values_, "Params")                   \
  __TYPE_ENUM(std::vector<int>, vec_int_values_, "vint")                 \
  __TYPE_ENUM(std::vector<double>, vec_dbl_values_, "vfloat")            \
  __TYPE_ENUM(std::vector<std::string>, vec_str_values_, "vstr")         \
  __TYPE_ENUM(std::vector<Limits>, vec_lim_values_, "VLimits")           \
  __TYPE_ENUM(std::vector<ParametersList>, vec_param_values_, "VParams") \
  __TYPE_ENUM(std::vector<std::vector<double> >, vec_vec_dbl_values_, "vvfloat")
#define REGISTER_CONTENT_TYPE                                            \ …
 
namespace cepgen {
  const auto MODULE_NAME = "mod_name";  
  class ParametersList {
    template <typename T>
    struct default_arg {
      static T get() { return T(); }  
    };
 
  public:
    ParametersList() = default;
    ParametersList(const ParametersList&);  
    ~ParametersList() = default;  // required for unique_ptr initialisation! avoids cleaning all individual objects
    ParametersList& operator=(const ParametersList&) = default;  
 
    bool hasName() const;                                           
    std::string name(const std::string& default_value = "") const;  
    ParametersList& setName(const std::string&);                    
 
    bool operator==(const ParametersList&) const;                                  
    bool operator!=(const ParametersList& oth) const { return !operator==(oth); }  
    ParametersList diff(const ParametersList&) const;  
 
    ParametersList& feed(const std::string&);  
 
    template <typename T>
    bool has(const std::string& key) const;
    size_t erase(const std::string&);
    template <typename T>
    size_t erase(const std::string&);
 
    template <typename T>
    const ParametersList& fill(const std::string& key, T& value) const {
      if (has<T>(key))
        value = get<T>(key);
      return *this;
    }
    const ParametersList& fill(const std::string& key, T& value) const  {…}
    template <typename T>
    T get(const std::string& key, const T& def = default_arg<T>::get()) const;
    template <typename T, typename U>
    U getAs(const std::string& key, const U& def = default_arg<U>::get()) const {
      return static_cast<U>(get<T>(key, static_cast<T>(def)));
    }
    U getAs(const std::string& key, const U& def = default_arg<U>::get()) const  {…}
    template <typename T>
    T& operator[](const std::string& key);
    template <typename T>
    ParametersList& set(const std::string&, const T&);  
    template <typename T, typename U>
    ParametersList& setAs(const std::string& key, const U& value) {
      return set<T>(key, static_cast<T>(value));
    }
    ParametersList& setAs(const std::string& key, const U& value) {…}
    ParametersList& rename(const std::string&, const std::string&);  
    ParametersList& operator+=(const ParametersList& oth);           
    ParametersList operator+(const ParametersList& other) const;     
    bool empty() const;                                              
 
    template <typename T>
    std::vector<std::string> keysOf() const;  
    std::vector<std::string> keys(bool name_key = true) const;
    std::string getString(const std::string& key, bool wrap = false) const;
    inline std::string getNameString(bool wrap = false) const { return getString(MODULE_NAME, wrap); }
    std::string serialise() const;  
 
    friend std::ostream& operator<<(std::ostream&,
                                    const ParametersList&);  
    const ParametersList& print(std::ostream&) const;        
    std::string print(bool compact = false) const;           
 
  private:
    std::map<std::string, ParametersList> param_values_;
    std::unordered_map<std::string, bool> bool_values_;
    std::unordered_map<std::string, int> int_values_;
    std::unordered_map<std::string, unsigned long long> ulong_values_;
    std::unordered_map<std::string, double> dbl_values_;
    std::unordered_map<std::string, std::string> str_values_;
    std::unordered_map<std::string, Limits> lim_values_;
    std::unordered_map<std::string, std::vector<int> > vec_int_values_;
    std::unordered_map<std::string, std::vector<double> > vec_dbl_values_;
    std::unordered_map<std::string, std::vector<std::string> > vec_str_values_;
    std::unordered_map<std::string, std::vector<Limits> > vec_lim_values_;
    std::unordered_map<std::string, std::vector<ParametersList> > vec_param_values_;
    std::unordered_map<std::string, std::vector<std::vector<double> > > vec_vec_dbl_values_;
  };
 
#define __TYPE_ENUM(type, map, name)                                          \
  template <>                                                                 \
  bool ParametersList::has<type>(const std::string&) const;                   \
  template <>                                                                 \
  type ParametersList::get<type>(const std::string&, const type&) const;      \
  template <>                                                                 \
  type& ParametersList::operator[]<type>(const std::string&);                 \
  template <>                                                                 \
  ParametersList& ParametersList::set<type>(const std::string&, const type&); \
  template <>                                                                 \
  std::vector<std::string> ParametersList::keysOf<type>() const;              \
  template <>                                                                 \
  size_t ParametersList::erase<type>(const std::string&);
#define __TYPE_ENUM(type, map, name)                                          \ …
  REGISTER_CONTENT_TYPE
#undef __TYPE_ENUM
}  // namespace cepgen
 
#endif
    ParametersList diff(const ParametersList&) const;   {…}
  class ParametersList {…};