Utilities

Provides a number of helper functions for the datamanager class. More...

Collaboration diagram for Utilities:

Classes
struct	Utopia::DataIO::_DMUtils::all_callable< T >
	Metafunction for use with boost hana, check if all T are callable types. More...

Functions
template<class ValType , class KVPairs , class ObjMap >
void	Utopia::DataIO::_DMUtils::unpack_shared (KVPairs &&kv_pairs, ObjMap &&map)
	Helper function to unpack (key, value) container into a map of shared pointers of a type.
template<class ObjMap , class ValType , class KVPairs >
ObjMap	Utopia::DataIO::_DMUtils::unpack_shared (KVPairs &&kv_pairs)
	Helper function to unpack (key, value) container into an empty map of shared pointers of a type.
template<class AssocsMap , class NamedTasks , class NamedDTMap , class Assocs >
AssocsMap	Utopia::DataIO::_DMUtils::build_task_association_map (const NamedTasks &tasks, const NamedDTMap &named_dts, Assocs assocs=Assocs{})
	Build an association map, i.e., a map that associates a decider/trigger name with a collection of tasknames.

Detailed Description

Provides a number of helper functions for the datamanager class.

Here some utility functions for the datamanager are implemented.

Function Documentation

build_task_association_map()

template<class AssocsMap , class NamedTasks , class NamedDTMap , class Assocs >

AssocsMap Utopia::DataIO::_DMUtils::build_task_association_map	(	const NamedTasks &	tasks,
		const NamedDTMap &	named_dts,
		Assocs	assocs = Assocs{}
	)

Build an association map, i.e., a map that associates a decider/trigger name with a collection of tasknames.

The Association Map is built from a map that associates names to tasks, a map that associates names and deciders/triggers, and a map or vector of pairs that associates each taskname with the name of a trigger/decider functor. If this last argument is not given, then a bijective association is attempted in which each task is associated with a trigger/decider that correponds to its position in the "named_dts" argument. This means that "tasks" and "named_dts" needs to be of equal length. If this is violated the function throws. If the "assocs" argument is given, the requirement of equal length is not necessary, because it specifies this bijective mapping. Note that this means that the "assocs" argument maps one decider/triggername to a taskname, and tasknames may repeat, while decider/triggernames do not.

Template Parameters

AssocsMap	Final map that maps names of deciders/triggers to a collection of task names
NamedTasks	automatically determined
NamedDTMap	automatically determined
Assocs	automatically determined

Parameters

tasks	map or vector of pairs containing (name, task).
named_dts	map or vector of pairs containing (name, decider/trigger)
assocs	map or vector of pairs containing (taskname, decider-/triggername).

Returns

AssocsMap Map that maps a name of a decider/trigger to a vector of tasknames. This argument is optional: If it is not given, then the function will try to associate tasks and deciders/triggers one by one in a bijective way in the order given. If that fails, an error is thrown.

                                                            {})
{
 
    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;
}

unpack_shared() [1/2]

template<class ObjMap , class ValType , class KVPairs >

ObjMap Utopia::DataIO::_DMUtils::unpack_shared

(

KVPairs &&

kv_pairs

)

Helper function to unpack (key, value) container into an empty map of shared pointers of a type.

Template Parameters

ObjMap	The name -> object map to create
ValType	Used in make_shared<ValType> call
KVPairs	Container of (key, value) pairs. Can also be a tuple.

Parameters

kv_pairs

The container of (key, value) pairs to unpack into a new map of type ObjMap

Returns

ObjMap The newly created and populated map

{
    ObjMap map;
    unpack_shared< ValType >(kv_pairs, map);
    return map;
}

unpack_shared() [2/2]

template<class ValType , class KVPairs , class ObjMap >

void Utopia::DataIO::_DMUtils::unpack_shared	(	KVPairs &&	kv_pairs,
		ObjMap &&	map
	)

Helper function to unpack (key, value) container into a map of shared pointers of a type.

Template Parameters

ValType	Used in make_shared<ValType> call
KVPairs	Container of (key, value) pairs. Can also be a tuple.
ObjMap	The name -> object map type

Parameters

kv_pairs

The container of (key, value) pairs to unpack into a new map of type ObjMap

{
    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);
        }
    }
}