Utopia::DataIO::DataManagerFactory< Model > Class Template Reference

Factory function which produces a Datamanager of type Default::DefaultDataManager<Model> from a config and argumets from which to construct writetasks. More...

#include <factory.hh>

Public Member Functions
template<typename... Args>
auto	operator() (const Config &conf, const std::tuple< Args... > &args, const Default::DefaultDecidermap< Model > &deciderfactories=Default::default_deciders< Model >, const Default::DefaultTriggermap< Model > &triggerfactories=Default::default_triggers< Model >)
	Builds a new datamanager from a config file and a tuple of tuples of arguments.

Private Member Functions
template<typename ArgTpl >
std::pair< std::string, std::shared_ptr< Default::DefaultWriteTask< Model > > >	_call_taskfactory (std::string typetag, ArgTpl &&arg_tpl)
	Function which calls the taskfactory with argument tuples, and takes care of using the correct type-tags.

Detailed Description

template<class Model>
class Utopia::DataIO::DataManagerFactory< Model >

Factory function which produces a Datamanager of type Default::DefaultDataManager<Model> from a config and argumets from which to construct writetasks.

Template Parameters

Model	Modeltype to use.
Args	Tuple types <TypeTag, std::string, argstypes_for_task...>

Parameters

model	Reference to the model the produced datamanagere shall belong to
w_args	Tuples, have to contain [tagtype, name, argumnets...]

Returns

auto DefaultDatamanager with DefaultWriteTasks produced from model

Member Function Documentation

_call_taskfactory()

template<class Model >

template<typename ArgTpl >

std::pair< std::string, std::shared_ptr< Default::DefaultWriteTask< Model > > > Utopia::DataIO::DataManagerFactory< Model >::_call_taskfactory ( std::string  typetag, ArgTpl &&  arg_tpl  )

inlineprivate

Function which calls the taskfactory with argument tuples, and takes care of using the correct type-tags.

Template Parameters

ArgTpl

automatically determined

Parameters

typetag	string indicating which type tag to use
arg_tpl	tuple of arguments to invoke the taskfactory with

Returns

Default::DefaultWriteTask<Model> produced by invoking the TaskFactory with the passed argument tuple

    {
 
        if (typetag == "plain")
        {
            DataIO::TaskFactory< Model, TypeTag::plain > factory;
 
            return std::apply(factory, std::forward< ArgTpl >(arg_tpl));
        }
        else if (typetag == "edge_property")
        {
            DataIO::TaskFactory< Model, TypeTag::edge_property > factory;
 
            return std::apply(factory, std::forward< ArgTpl >(arg_tpl));
        }
        else if (typetag == "vertex_descriptor")
        {
            DataIO::TaskFactory< Model, TypeTag::vertex_descriptor > factory;
 
            return std::apply(factory, std::forward< ArgTpl >(arg_tpl));
        }
        else if (typetag == "vertex_property")
        {
            DataIO::TaskFactory< Model, TypeTag::vertex_property > factory;
 
            return std::apply(factory, std::forward< ArgTpl >(arg_tpl));
        }
        else
        {
            DataIO::TaskFactory< Model, TypeTag::edge_descriptor > factory;
 
            return std::apply(factory, std::forward< ArgTpl >(arg_tpl));
        }
    }

operator()()

template<class Model >

template<typename... Args>

auto Utopia::DataIO::DataManagerFactory< Model >::operator() ( const Config &  conf, const std::tuple< Args... > &  args, const Default::DefaultDecidermap< Model > &  deciderfactories = Default::default_deciders<Model>, const Default::DefaultTriggermap< Model > &  triggerfactories = Default::default_triggers<Model>  )

inline

Builds a new datamanager from a config file and a tuple of tuples of arguments.

The latter are supplemented by the arguments given by the config, and then passed to the writetask factory, each. The result is then used for creating the datamanager. The arguments that need to be supplied in the code are

• function which returns the data source, preferably by reference. Mind that you need to use decltype(auto) as return type if using a lambda.
• the getter function which extracts data from the sources values, same thing as employed by dataset->write.
• callable to write group attribute or tuple containing (name, data) or 'Nothing{}' if no attributes are desired
• callable to write dataset attribute or tuple containing (name, data) or 'Nothing{}' if no attributes are desired

Template Parameters

Args	automatically determined

Parameters

conf	config node giving the 'data_manager' configuration nodes
args	tuple of argument tuples

Returns

auto DefaultDatamanager<Model> with the tasks built from config and arguments

    {
        // Get the global data manager logger
        const auto _log = spdlog::get("data_mngr");
 
        if constexpr (sizeof...(Args) == 0)
        {
            _log->info("Empty argument tuple for DataManager factory, "
                       "building default ...");
            return Default::DefaultDataManager< Model >{};
        }
        else
        {
            // read the tasks from the config into a map
            // has the consequence that the ordering need to match
            std::map< std::string, Config > tasknodes;
            for (auto&& node : conf["tasks"])
            {
                _log->info("Name of current task: {}",
                           node.first.as< std::string >());
 
                tasknodes[node.first.as< std::string >()] = node.second;
            }
 
            // this transforms the tuple of argument tuples std::tuple< Args...
            // >
            std::unordered_map<
                std::string,
                std::shared_ptr< Default::DefaultWriteTask< Model > > >
                tasks;
 
            boost::hana::for_each(
                args,
                // function gets a tuple representing arguments for the
                // writetask extracts config-supplied arguments from the
                // respective config node if the latter is found, puts them in
                // their correct place, then forwards the rest to the
                // taksfactory. If no config node for a given taskname is found,
                // exception is thrown
                [&](const auto& arg_tpl) {
                    using std::get;
                    std::string name          = "";
                    std::string name_in_tpl   = get< 0 >(arg_tpl);
                    auto        tasknode_iter = tasknodes.find(name_in_tpl);
 
                    // find the current task in the config, if not found throw
                    if (tasknode_iter != tasknodes.end())
                    {
                        name = tasknode_iter->first;
                    }
                    else
                    {
                        // .. and throw if it is not
                        throw std::invalid_argument(
                            "A task with name '" + name_in_tpl +
                            "' was not found in the config!");
                    }
 
                    // read out the typetag from the config
                    std::string typetag = "";
                    if (not tasknode_iter->second["typetag"])
                    {
                        typetag = "plain";
                    }
                    else
                    {
                        get_as< std::string >("typetag", tasknode_iter->second);
                    }
 
                    // make a tuple of types from the argtuple except the first
                    // element which is the sentinel name
                    auto type_tuple = boost::hana::transform(
                        boost::hana::remove_at(arg_tpl,
                                               boost::hana::size_t< 0 >{}),
                        [](auto&& t) {
                            return boost::hana::type_c<
                                std::decay_t< decltype(t) > >;
                        });
 
                    constexpr bool is_all_callable =
                        decltype(boost::hana::unpack(
                            type_tuple,
                            boost::hana::template_<
                                _DMUtils::all_callable >))::type::value;
 
                    // all arguments are callables
                    if constexpr (is_all_callable)
                    {
                        _log->info("Building write task '{}' via factory ...",
                                   name);
                        tasks.emplace(_call_taskfactory(typetag, arg_tpl));
                    }
                    // not all-callable arguments
                    else
                    {
 
                        // extract arguments from the configfile
                        auto config_args = std::make_tuple(
                            // name
                            name_in_tpl,
                            // basegroup_path
                            get_as< std::string >("basegroup_path",
                                                  tasknode_iter->second),
                            // dataset_descriptor
                            DatasetDescriptor{
                                get_as< std::string >("dataset_path",
                                                      tasknode_iter->second),
                                (tasknode_iter->second["capacity"]
                                     ? get_as< std::vector< hsize_t > >(
                                           "capacity", tasknode_iter->second)
                                     : std::vector< hsize_t >{}),
                                (tasknode_iter->second["chunksize"]
                                     ? get_as< std::vector< hsize_t > >(
                                           "chunksize", tasknode_iter->second)
                                     : std::vector< hsize_t >{}),
                                (tasknode_iter->second["compression"]
                                     ? get_as< int >("compression",
                                                     tasknode_iter->second)
                                     : 0) });
 
                        // remove the sentinel name and concat the tuples, which
                        // then is forwarded to args
                        auto full_arg_tpl = std::tuple_cat(
                            config_args,
                            boost::hana::remove_at(arg_tpl,
                                                   boost::hana::size_t< 0 >{}));
 
                        _log->info("Building write task '{}' via factory ...",
                                   name);
 
                        tasks.emplace(_call_taskfactory(typetag, full_arg_tpl));
                    }
                });
 
            _log->info("Forwarding arguments to DataManager constructor ...");
            // then produce default datamanager with all default deciders,
            // triggers etc
 
            return Default::DefaultDataManager< Model >(
                conf,
                tasks,
                deciderfactories,
                triggerfactories,
                Default::DefaultExecutionProcess());
        }
    }

---

The documentation for this class was generated from the following file:

• include/utopia/data_io/data_manager/factory.hh