swh:1:snp:f521c49ab17ef7db6ec70b2430e1ed203f50383f
Tip revision: d700910e846d5f79d5b5a78b8a58230075845cc6 authored by Dominik Kern on 22 November 2021, 14:27:13 UTC
Merge branch 'HM_optional_input_parameter_for_staggered_scheme' into 'master'
Merge branch 'HM_optional_input_parameter_for_staggered_scheme' into 'master'
Tip revision: d700910
ConfigTree-impl.h
/**
* \file
* \copyright
* Copyright (c) 2012-2021, OpenGeoSys Community (http://www.opengeosys.org)
* Distributed under a Modified BSD License.
* See accompanying file LICENSE.txt or
* http://www.opengeosys.org/project/license
*
*/
#include <sstream>
#include <utility>
#include "ConfigTree.h"
namespace BaseLib
{
//! Wraps a pair of iterators for use as a range in range-based for-loops.
template <typename Iterator>
class Range
{
public:
explicit Range(Iterator begin, Iterator end)
: begin_(std::move(begin)), end_(std::move(end))
{
}
Iterator begin() const { return begin_; }
Iterator end() const { return end_; }
std::size_t size() const { return std::distance(begin_, end_); }
bool empty() const { return size() == 0; }
private:
Iterator begin_;
Iterator end_;
};
template <typename T>
T ConfigTree::getConfigParameter(std::string const& param) const
{
if (auto p = getConfigParameterOptional<T>(param))
{
return *p;
}
error("Key <" + param + "> has not been found");
}
template <typename T>
T ConfigTree::getConfigParameter(std::string const& param,
T const& default_value) const
{
if (auto p = getConfigParameterOptional<T>(param))
{
return *p;
}
return default_value;
}
template <typename T>
std::optional<T> ConfigTree::getConfigParameterOptional(
std::string const& param) const
{
checkUnique(param);
return getConfigParameterOptionalImpl(param, static_cast<T*>(nullptr));
}
template <typename T>
std::optional<T> ConfigTree::getConfigParameterOptionalImpl(
std::string const& param, T* /*unused*/) const
{
if (auto p = getConfigSubtreeOptional(param))
{
return p->getValue<T>();
}
return std::nullopt;
}
template <typename T>
std::optional<std::vector<T>> ConfigTree::getConfigParameterOptionalImpl(
std::string const& param, std::vector<T>* /*unused*/) const
{
if (auto p = getConfigSubtreeOptional(param))
{
std::istringstream sstr{p->getValue<std::string>()};
std::vector<T> result;
T value;
while (sstr >> value)
{
result.push_back(value);
}
if (!sstr.eof()) // The stream is not read until the end, must be an
// error. result contains number of read values.
{
error("Value for key <" + param + "> `" + shortString(sstr.str()) +
"' not convertible to a vector of the desired type."
" Could not convert token no. " +
std::to_string(result.size() + 1) + ".");
return std::nullopt;
}
return std::make_optional(result);
}
return std::nullopt;
}
template <typename T>
Range<ConfigTree::ValueIterator<T>> ConfigTree::getConfigParameterList(
std::string const& param) const
{
checkUnique(param);
markVisited<T>(param, Attr::TAG, true);
auto p = tree_->equal_range(param);
return Range<ValueIterator<T>>(ValueIterator<T>(p.first, param, *this),
ValueIterator<T>(p.second, param, *this));
}
template <typename T>
T ConfigTree::peekConfigParameter(std::string const& param) const
{
checkKeyname(param);
if (auto p = tree_->get_child_optional(param))
{
try
{
return p->get_value<T>();
}
catch (boost::property_tree::ptree_bad_data const&)
{
error("Value for key <" + param + "> `" + shortString(p->data()) +
"' not convertible to the desired type.");
}
}
else
{
error("Key <" + param + "> has not been found");
}
}
template <typename T>
void ConfigTree::checkConfigParameter(std::string const& param,
T const& value) const
{
if (getConfigParameter<T>(param) != value)
{
error("The value of key <" + param + "> is not the expected one.");
}
}
template <typename Ch>
void ConfigTree::checkConfigParameter(std::string const& param,
Ch const* value) const
{
if (getConfigParameter<std::string>(param) != value)
{
error("The value of key <" + param + "> is not the expected one.");
}
}
template <typename T>
T ConfigTree::getValue() const
{
if (have_read_data_)
{
error("The data of this subtree has already been read.");
}
have_read_data_ = true;
if (auto v = tree_->get_value_optional<T>())
{
return *v;
}
error("Value `" + shortString(tree_->data()) +
"' is not convertible to the desired type.");
}
template <typename T>
T ConfigTree::getConfigAttribute(std::string const& attr) const
{
if (auto a = getConfigAttributeOptional<T>(attr))
{
return *a;
}
error("Did not find XML attribute with name '" + attr + "'.");
}
template <typename T>
T ConfigTree::getConfigAttribute(std::string const& attr,
T const& default_value) const
{
if (auto a = getConfigAttributeOptional<T>(attr))
{
return *a;
}
return default_value;
}
template <typename T>
std::optional<T> ConfigTree::getConfigAttributeOptional(
std::string const& attr) const
{
checkUniqueAttr(attr);
auto& ct = markVisited<T>(attr, Attr::ATTR, true);
if (auto attrs = tree_->get_child_optional("<xmlattr>"))
{
if (auto a = attrs->get_child_optional(attr))
{
++ct.count; // count only if attribute has been found
if (auto v = a->get_value_optional<T>())
{
return std::make_optional(*v);
}
error("Value for XML attribute '" + attr + "' `" +
shortString(a->data()) +
"' not convertible to the desired type.");
}
}
return std::nullopt;
}
template <typename T>
ConfigTree::CountType& ConfigTree::markVisited(std::string const& key,
Attr const is_attr,
bool const peek_only) const
{
auto const type = std::type_index(typeid(T));
auto p = visited_params_.emplace(std::make_pair(is_attr, key),
CountType{peek_only ? 0 : 1, type});
if (!p.second)
{ // no insertion happened
auto& v = p.first->second;
if (v.type == type)
{
if (!peek_only)
{
++v.count;
}
}
else
{
error("There already was an attempt to obtain key <" + key +
"> with type '" + v.type.name() + "' (now: '" + type.name() +
"').");
}
}
return p.first->second;
}
} // namespace BaseLib