parametersystem.hpp

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*
  This file is part of the Open Porous Media project (OPM).
 
  OPM 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 2 of the License, or
  (at your option) any later version.
 
  OPM 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 OPM.  If not, see <http://www.gnu.org/licenses/>.
 
  Consult the COPYING file in the top-level source directory of this
  module for the precise wording of the license and the list of
  copyright holders.
*/
#ifndef OPM_PARAMETER_SYSTEM_HPP
#define OPM_PARAMETER_SYSTEM_HPP
 
#include <dune/common/classname.hh>
 
#include <cstring>
#include <functional>
#include <limits>
#include <set>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>
 
namespace Opm::Parameters {
 
namespace detail {
 
template <typename, class = void>
struct has_name : public std::false_type {};
 
template <typename T>
struct has_name<T, std::void_t<decltype(std::declval<T>().name)>>
: public std::true_type {};
 
template<class Parameter>
auto getParamName()
{
    if constexpr (has_name<Parameter>::value) {
        return Parameter::name;
    } else {
        std::string paramName = Dune::className<Parameter>();
        paramName.replace(0, std::strlen("Opm::Parameters::"), "");
        const auto pos = paramName.find_first_of('<');
        if (pos != std::string::npos) {
            paramName.erase(pos);
        }
        return paramName;
    }
}
 
template<class ParamType>
ParamType Get_(const std::string& paramName, ParamType defaultValue,
               bool errorIfNotRegistered);
 
void Hide_(const std::string& paramName);
 
bool HideIfRegistered_(const std::string& paramName);
 
bool IsSet_(const std::string& paramName, bool errorIfNotRegistered);
 
void Register_(const std::string& paramName,
               const std::string& paramTypeName,
               const std::string& defaultValue,
               const char* usageString);
 
void SetDefault_(const std::string& paramName,
                 const std::string& paramValue);
 
}
 
 
void printUsage(const std::string& helpPreamble,
                std::ostream& os,
                const std::string& errorMsg = "",
                const bool showAll = false);
 
using PositionalArgumentCallback = std::function<int(std::function<void(const std::string&,
                                                                        const std::string&)>,
                                                     std::set<std::string>&,
                                                     std::string&,
                                                     int,
                                                     const char**,
                                                     int,
                                                     int)>;
std::string
parseCommandLineOptions(int argc,
                        const char **argv,
                        const PositionalArgumentCallback& posArgCallback,
                        const std::string& helpPreamble = "");
 
bool parseParameterFile(const std::string& fileName, bool overwrite = true);
 
void printValues(std::ostream& os);
 
bool printUnused(std::ostream& os);
 
template <class Param>
auto Get(bool errorIfNotRegistered = true)
{
    using ParamType = std::conditional_t<std::is_same_v<decltype(Param::value),
                                                        const char* const>, std::string,
                                         std::remove_const_t<decltype(Param::value)>>;
    ParamType defaultValue = Param::value;
    return detail::Get_(detail::getParamName<Param>(),
                        defaultValue, errorIfNotRegistered);
}
 
template <class Param>
void SetDefault(decltype(Param::value) new_value)
{
    const std::string paramName = detail::getParamName<Param>();
    std::ostringstream oss;
    // full precision: the default stream setting of 6 significant digits
    // silently corrupts values on the text round trip
    if constexpr (std::is_floating_point_v<decltype(Param::value)>) {
        oss.precision(std::numeric_limits<decltype(Param::value)>::max_digits10);
    }
    oss << new_value;
    detail::SetDefault_(paramName, oss.str());
}
 
struct Parameter
{
    Parameter(const std::string& k, const std::string& v)
        : key(k), value(v)
    {}
 
    friend std::ostream& operator<<(std::ostream& os, const Parameter& param)
    {
        os << param.key << "=\"" << param.value << '"';
        return os;
    }
 
    bool operator==(const Parameter& setting) const
    {
        return setting.key == key
            && setting.value == value;
    }
 
    bool operator !=(const Parameter& setting) const
    {
        return !(*this == setting);
    }
 
    std::string key, value;
};
 
void getLists(std::vector<Parameter>& usedParams,
              std::vector<Parameter>& unusedParams);
 
void reset();
 
template <class Param>
bool IsSet(bool errorIfNotRegistered = true)
{
    return detail::IsSet_(detail::getParamName<Param>(), errorIfNotRegistered);
}
 
template <class Param>
void Register(const char* usageString)
{
    const std::string paramName = detail::getParamName<Param>();
    const auto defaultValue = Param::value;
    using ParamType = std::conditional_t<std::is_same_v<decltype(defaultValue),
                                                        const char* const>, std::string,
                                         std::remove_const_t<decltype(defaultValue)>>;
 
    std::ostringstream oss;
    oss << defaultValue;
    detail::Register_(paramName, Dune::className<ParamType>(), oss.str(), usageString);
}
 
template <class Param>
void Hide()
{
    detail::Hide_(detail::getParamName<Param>());
}
 
template <class Param>
bool HideIfRegistered()
{
    return detail::HideIfRegistered_(detail::getParamName<Param>());
}
 
bool IsRegistrationOpen();
 
void endRegistration();
 
} // namespace Opm::Parameters
 
#endif // OPM_PARAMETER_SYSTEM_HPP