cfg_utils.hh

Go to the documentation of this file.

#ifndef DATAIO_CFG_UTILS_HH
#define DATAIO_CFG_UTILS_HH
 
#include <list>
#include <sstream>
 
#include <boost/core/demangle.hpp>
#include <armadillo>
#include <yaml-cpp/yaml.h>
 
#include "../core/exceptions.hh"
#include "../core/string.hh"
#include "../core/types.hh"
 
namespace Utopia
{
namespace DataIO
{
 
// end group ConfigUtilities
// .. Config reading helper functions .........................................
 
// TODO Make this an actual Utopia exception
template < class Exc >
YAML::Exception
improve_yaml_exception(const Exc&    e,
                       const Config& node,
                       std::string   prefix = {})
{
    // The string stream for the new, improved error message
    std::stringstream e_msg;
    e_msg << prefix << " ";
    e_msg << "Got " << boost::core::demangle(typeid(e).name()) << ". ";
 
    // Create a custom error message depending on whether the node is a
    // zombie or a mark is available
    if (not node)
    {
        // Was a zombie
        e_msg << "The given node was a Zombie! Check that the key you are "
                 "trying to read from actually exists. ";
    }
    else if (not node.Mark().is_null())
    {
        // A mark is available to use as a hint
        // NOTE Mark() provides the line and column in the config file, if
        //      available, i.e.: if not a zombie node
        e_msg << "Check that the corresponding line of the config file "
                 "matches the desired read operation or type conversion. ";
    }
 
    // Give some information on the node's content:
    e_msg << "The content of the node is:" << std::endl << YAML::Dump(node);
 
    // Return the custom exception object; can be thrown on other side
    return YAML::Exception(node.Mark(), e_msg.str());
}
 
 
std::string
to_string(const Config& node)
{
    std::stringstream s;
    s << YAML::Dump(node);
    return s.str();
}
 
} // namespace DataIO
 
// NOTE All code below is not inside the Utopia::DataIO namespace to make
//      includes into models more convenient.
 
 
template < typename ReturnType >
ReturnType
get_as(const std::string& key, const DataIO::Config& node)
{
    try
    {
        return node[key].template as< ReturnType >();
    }
    catch (YAML::Exception& e)
    {
        if (not node[key])
        {
            throw KeyError(key, node);
        }
        // else: throw an improved error message
        throw DataIO::improve_yaml_exception(e, node,
                                             "Could not read key '" + key +
                                             "' from given config node!");
    }
    catch (std::exception& e)
    {
        // Some other exception; provide at least some info and context
        std::cerr << boost::core::demangle(typeid(e).name())
                  << " occurred during reading key '" << key
                  << "' from config!" << std::endl;
 
        // Re-throw the original exception
        throw;
    }
    catch (...)
    {
        throw std::runtime_error("Unexpected exception occurred during "
                                 "reading key '" + key + "'' from config!");
    }
}
 
template < typename ReturnType >
ReturnType
get_as(const std::string& key, const DataIO::Config& node, ReturnType fallback)
{
    try
    {
        return get_as< ReturnType >(key, node);
    }
    catch (KeyError&)
    {
        return fallback;
    }
    // All other errors will (rightly) be thrown
}
 
// end group ConfigUtilities
// Armadillo-related specialization
// TODO These should be implemented specializations of the get_as function!
namespace DataIO
{
 
 
template < typename CVecT, DimType dim = 0 >
CVecT
get_as_arma_vec(const std::string& key, const DataIO::Config& node)
{
    // Extract the field vector element type; assuming Armadillo interface
    using element_t = typename CVecT::elem_type;
 
    // Check if it can be constructed from a vector
    if constexpr (std::is_constructible< CVecT, std::vector< element_t > >())
    {
        return get_as< std::vector< element_t > >(key, node);
    }
    else
    {
        static_assert(dim > 0,
                      "Need template argument dim given if target type is not "
                      "constructible from std::vector.");
 
        // Needs to be constructed element-wise
        CVecT      cvec;
        const auto vec = get_as< std::array< element_t, dim > >(key, node);
 
        for (DimType i = 0; i < dim; i++)
        {
            cvec[i] = vec[i];
        }
 
        return cvec;
    }
}
} // namespace DataIO
 
 
 
template < DimType dim >
SpaceVecType< dim >
get_as_SpaceVec(const std::string& key, const DataIO::Config& node)
{
    return DataIO::get_as_arma_vec< SpaceVecType< dim >, dim >(key, node);
}
 
 
template < DimType dim >
MultiIndexType< dim >
get_as_MultiIndex(const std::string& key, const DataIO::Config& node)
{
    return DataIO::get_as_arma_vec< MultiIndexType< dim >, dim >(key, node);
}
 
// end group ConfigUtilities
// -- INTERNALLY USED Functions to work with Config trees ---------------------
 
namespace _internal {
 
 
template<class T, class Keys = std::list<std::string> >
Config __recursive_setitem (Config d,
                            Keys&& key_sequence,
                            const T& val)
{
    // Get the next key
    std::string key;
    while (key.empty() and not key_sequence.empty()) {
        key = key_sequence.front();
        key_sequence.pop_front();
    }
    if (key.empty()) {
        throw std::invalid_argument(
            "During recursive_setitem, failed to retrieve a valid key for "
            "continuing recursion. Make sure the given key sequence ("
            + join(key_sequence, " -> ") + ") contains no empty elements!"
        );
    }
 
    // Check for end of recursion
    if (key_sequence.empty()) {
        if (d.IsScalar()) {
            // Discard the scalar and replace it with an empty mapping
            d = Config{};
        }
        d[key] = val;
        return d;
    }
 
    // Continue recursion, creating the intermediate node if it does not exist
    if (not d[key]) {
        d[key] = Config{};
    }
    d[key] = __recursive_setitem(d[key], std::forward<Keys>(key_sequence),
                                 val);
    return d;
}
 
 
 
Config recursive_getitem (const Config& d,
                          const std::vector<std::string>& key_sequence)
{
    using Utopia::KeyError;
    using Utopia::join;
 
    Config rv = YAML::Clone(d);
    for (const auto& key : key_sequence ) {
        try {
            rv = get_as<Config>(key, rv);
        }
        catch (KeyError& err) {
            throw KeyError(
                key, rv,
                "recursive_getitem failed for key or key sequence '"
                + join(key_sequence, " -> ") + "'!"
            );
        }
    }
    return rv;
}
 
 
Config recursive_getitem (const Config& d,
                          const std::string& key_sequence,
                          const std::string& delims = ".")
{
    return recursive_getitem(d, split(key_sequence, delims));
}
 
 
 
template<class T>
void recursive_setitem (Config& d,
                        std::list<std::string> key_sequence,
                        const T val)
{
    if (key_sequence.empty()) {
        throw std::invalid_argument(
            "Key sequence for recursive_setitem may not be empty!"
        );
    }
    d = __recursive_setitem(YAML::Clone(d), std::move(key_sequence), val);
}
 
 
template<class T>
void recursive_setitem (Config& d,
                        const std::string& key_sequence,
                        const T val,
                        const std::string& delims = ".")
{
    recursive_setitem(
        d, split<std::list<std::string>>(key_sequence, delims), val
    );
}
 
} // namespace _internal
} // namespace Utopia
 
#endif // DATAIO_CFG_UTILS_HH