utils.hh

Go to the documentation of this file.

#ifndef UTOPIA_DATAIO_DATA_MANAGER_UTILS_HH
#define UTOPIA_DATAIO_DATA_MANAGER_UTILS_HH
 
#include "../../core/type_traits.hh"
#include "../../core/zip.hh"
#include "../cfg_utils.hh"
 
namespace Utopia
{
namespace DataIO
{
namespace _DMUtils
{
 
template < typename... T >
struct all_callable
    : std::conjunction< Utopia::Utils::is_callable< T >... >
{
};
 
template < class ValType, class KVPairs, class ObjMap >
void
unpack_shared(KVPairs&& kv_pairs, ObjMap&& map)
{
    using namespace Utopia::Utils;
 
    // Distinguish between tuple-like key value pairs and others
    if constexpr (has_static_size_v< remove_qualifier_t< KVPairs > >)
    {
        using std::get; // enable ADL
 
        // Build map from given key value pairs
        boost::hana::for_each(kv_pairs, [&](auto&& kv) {
            // Check if the deduced kv type is a base class of the
            // given target ValType
            if constexpr (std::is_base_of_v<
                              ValType,
                              std::tuple_element_t<
                                  1,
                                  remove_qualifier_t< decltype(kv) > > >)
            {
                map[get< 0 >(kv)] = std::make_shared< std::tuple_element_t<
                    1,
                    remove_qualifier_t< decltype(kv) > > >(get< 1 >(kv));
            }
            else
            {
                map[get< 0 >(kv)] = std::make_shared< ValType >(get< 1 >(kv));
            }
        });
    }
    else
    {
        for (const auto& [k, v] : kv_pairs)
        {
            map[k] = std::make_shared< ValType >(v);
        }
    }
}
 
template < class ObjMap, class ValType, class KVPairs >
ObjMap
unpack_shared(KVPairs&& kv_pairs)
{
    ObjMap map;
    unpack_shared< ValType >(kv_pairs, map);
    return map;
}
 
template < class AssocsMap, class NamedTasks, class NamedDTMap, class Assocs >
AssocsMap
build_task_association_map(const NamedTasks& tasks,
                           const NamedDTMap& named_dts,
                           Assocs            assocs = Assocs{})
{
 
    AssocsMap map;
 
    // Check if helpers and tasks can be associated one by one bijectivly, if
    // not, demand a map explicitly giving associations to be given, which can
    // be used for association
 
    if (tasks.size() != named_dts.size())
    {
        if (assocs.size() == 0)
        {
            throw std::invalid_argument(
                "Error, explicit associations have to be given when mapping "
                "unequal numbers of decider or trigger functions and tasks.");
        }
        else
        {
            for (auto&& [taskname, dt_name] : assocs)
            {
                map[dt_name].push_back(taskname);
            }
        }
    }
    else
    {
 
        for (auto&& [namedtask, namedhelper] : Itertools::zip(tasks, named_dts))
        {
            map[namedhelper.first].push_back(namedtask.first);
        }
    }
 
    return map;
}
 
} // namespace _DMUtils
} // namespace DataIO
} // namespace Utopia
 
#endif // UTOPIA_DATAIO_DATA_MANAGER_UTILS_HH