NamedParameter.h

Go to the documentation of this file.

#ifndef AMPGEN_NAMEDPARAMETER_H
#define AMPGEN_NAMEDPARAMETER_H
// author: Jonas Rademacker (Jonas.Rademacker@bristol.ac.uk)
// status:  Mon 9 Feb 2009 19:17:56 GMT
 
#include <stddef.h>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
#include <iomanip>
#include <map>
#include <cstring>
 
#include "AmpGen/MsgService.h"
#include "AmpGen/OptionsParser.h"
#include "AmpGen/Utilities.h"
#include "AmpGen/MetaUtils.h"
 
namespace AmpGen {
  template <class T> class [[deprecated]] NamedParameter {
  protected:
    std::string m_name;          
    std::string m_helpString;    
    std::vector<T> m_valueArray; 
 
    bool setFromOptionsParser() {
      auto parser = OptionsParser::getMe();
      auto line = parser->find(m_name);
      if(line == parser->end()) return false;
      const std::vector<std::string> &vsl = line->second;
      if(vsl.size() < 2) return false; // first element is parameter name
      m_valueArray.clear();
      m_valueArray.resize(vsl.size() - 1);
      for(unsigned int i = 1; i < vsl.size(); i++) {
        bool status = true;
        T tmpVal = lexical_cast<T>(vsl[i], status);
        if(status == false) {
          ERROR("Failed to parse token: " << vsl[i] << " for parameter: " << m_name);
          continue;
        }
        setVal(tmpVal, i - 1);
      }
      return true;
    }
 
  public:
    NamedParameter(const std::string &name, const T &def = T(), const std::string &helpString = "") : m_name(name), m_helpString(helpString) {
      setVal(def);
      setFromOptionsParser();
      if(OptionsParser::printHelp()) help(def);
      DEBUG(*this);
    }
    NamedParameter(const std::string &name, const std::vector<T> &defVec, const std::string &helpString = "") : m_name(name), m_helpString(helpString) {
      setVal(defVec);
      setFromOptionsParser();
      if(OptionsParser::printHelp()) help(defVec.size() > 0 ? defVec[0] : T());
    }
    void help(const T &def) {
      std::string type = type_string<T>();
      if(type == "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >") type = "string";
      std::cout << " " << bold_on << std::left << std::setw(27) << m_name << bold_off << std::setw(20) << "[" + type + "]";
      auto tokens = split(m_helpString, '\n');
      if(tokens.size() == 0) std::cout << std::endl;
      for(size_t i = 0; i < tokens.size(); ++i) {
        if(i == 0) {
          std::cout << tokens[i];
          if(def != T()) std::cout << " (default = " << def << ")";
          std::cout << std::endl;
        } else
          std::cout << std::string(48, ' ') << tokens[i] << std::endl;
      }
    }
 
    size_t size() const { return m_valueArray.size(); }
 
    const T getVal(int i = 0) const {
      if(i < 0 || i >= (int)m_valueArray.size()) {
        ERROR("Parameter name \"" << name() << "\". Index: " << i << " out of range [ " << 0 << " , " << m_valueArray.size());
        throw std::runtime_error("array index out of bounds");
      }
      return m_valueArray[i];
    }
 
    operator T() const { return getVal(); }
    operator T() { return getVal(); }
    template <class G> bool operator==(const G &other) const { return getVal() == other; }
    template <class G> bool operator!=(const G &other) const { return getVal() != other; }
    const std::vector<T> &getVector() const { return m_valueArray; }
 
    void setVal(const T &val, int i = 0) {
      if(i < 0) return;
      if(i >= (int)m_valueArray.size()) { m_valueArray.resize(i + 1); }
      m_valueArray[i] = val;
    }
    void setVal(const std::vector<T> &valList) { m_valueArray = valList; }
 
    operator std::vector<T>() const { return getVector(); }
    NamedParameter<T> &operator=(const T &d) {
      setVal(d, 0);
      return *this;
    }
    NamedParameter<T> &operator=(const std::vector<T> &v) {
      setVal(v);
      return *this;
    }
    const std::string &name() const { return m_name; }
 
    static std::vector<T> getVectorArgument(const std::string &name, const T &default_value) {
      std::vector<T> return_container;
      unsigned int x = 0;
      T obj = default_value;
      do {
        obj = AmpGen::NamedParameter<T>(name + std::to_string(x++), default_value);
        if(obj != T()) return_container.push_back(obj);
      } while(obj != default_value);
      return return_container;
    }
  };
  template <typename T> std::ostream &operator<<(std::ostream &os, const NamedParameter<T> &np);
  template <typename... T> std::string optionalHelpString(const std::string &header, const T &...args);
}
 
template <typename T> std::ostream &AmpGen::operator<<(std::ostream &os, const AmpGen::NamedParameter<T> &np) {
  os << np.name();
  for(size_t i = 0; i < np.size(); i++) {
    if(i == 0) os << " = ";
    os << np.getVal(i);
    if(i != np.size()) os << " ";
  }
  return os;
}
 
template <typename... T> std::string AmpGen::optionalHelpString(const std::string &header, const T &...args) {
  std::stringstream rt;
  rt << header;
  for_each(std::make_tuple(args...), [&rt](const auto &f) mutable { rt << "\n\033[3m " << f.first << "\033[0m: " << f.second; });
  return rt.str();
}
 
#endif