data_manager.hh

Go to the documentation of this file.

#ifndef UTOPIA_DATAIO_DATA_MANAGER_HH
#define UTOPIA_DATAIO_DATA_MANAGER_HH
 
// stl includes for having shared_ptr, hashmap, vector, swap
#include <algorithm>
#include <memory>
#include <stdexcept>
#include <type_traits>
#include <unordered_map>
#include <vector>
 
// utopia includes
#include "../../core/logging.hh"
#include "../../core/type_traits.hh"
#include "../cfg_utils.hh"
#include "defaults.hh"
#include "utils.hh"
 
namespace Utopia
{
namespace DataIO
{
 
using namespace Utopia::Utils;
 
// Doxygen group for DataManager ++++++++++++++++++++++++++++++++++++++++++++++
template < class TaskType,
           class DeciderType,
           class TriggerType,
           class ExecutionProcessType >
struct DataManagerTraits
{
    using Task             = TaskType;
    using Decider          = DeciderType;
    using Trigger          = TriggerType;
    using ExecutionProcess = ExecutionProcessType;
};
 
template < class Traits >
class DataManager
{
  public:
    using Self = DataManager< Traits >;
 
    using Task = typename Traits::Task;
 
    using Decider = typename Traits::Decider;
 
    using Trigger = typename Traits::Trigger;
 
    using ExecutionProcess = typename Traits::ExecutionProcess;
 
    using TaskMap = std::unordered_map< std::string, std::shared_ptr< Task > >;
 
    using OrderedTaskMap = std::map< std::string, std::shared_ptr< Task > >;
 
    using DeciderMap =
        std::unordered_map< std::string, std::shared_ptr< Decider > >;
 
    using OrderedDeciderMap =
        std::map< std::string, std::shared_ptr< Decider > >;
 
    using TriggerMap =
        std::unordered_map< std::string, std::shared_ptr< Trigger > >;
 
    using OrderedTriggerMap =
        std::map< std::string, std::shared_ptr< Trigger > >;
 
    using AssocsMap =
        std::unordered_map< std::string, std::vector< std::string > >;
 
  protected:
    std::shared_ptr< spdlog::logger > _log;
 
    TaskMap _tasks;
 
    DeciderMap _deciders;
 
    TriggerMap _triggers;
 
    AssocsMap _decider_task_map;
 
    AssocsMap _trigger_task_map;
 
    ExecutionProcess _execution_process;
 
    // .. Construction Helpers ................................................
 
    template < typename ObjMap, typename KnownObjectsMap >
    ObjMap
    _setup_from_config(const Config& cfg, KnownObjectsMap&& known_objects)
    {
        _log->debug("Setting up name -> object map from config node ...");
 
        // Check whether the given configuration is valid
        if (not cfg)
        {
            throw std::invalid_argument("Received a zombie node for the setup "
                                        "of DataManager objects!");
        }
        else if (not cfg.IsMap())
        {
            throw std::invalid_argument("Expected a mapping for DataManager "
                                        "object setup, got:\n" +
                                        to_string(cfg));
        }
 
        // The name -> object map that is to be populated
        ObjMap map;
        _log->debug("Configuring DataManager objects ... (container size: {})",
                    known_objects.size());
 
        // Go over the known objects and decide whether to retain them
        // as they are or whether new objects need to be constructed from the
        // known ones
        // Depending on the name of the object, the name given in the
        // configuration, and the configuration itself, decide on
        // whether a new object needs to be constructed or can be
        // retained from the known objects.
        // If the configuration specifies a type, use that information
        // to either construct a new object from given arguments or
        // copy-construct one from an existing object
        for (const auto& node_pair : cfg)
        {
            // Unpack the (key node, value node) pair, i.e. the name of the
            // object that is to be configured and the corresponding
            // configuration node
            const auto  cfg_name = node_pair.first.as< std::string >();
            const auto& obj_cfg  = node_pair.second;
 
            const auto type_name = get_as< std::string >("type", obj_cfg);
 
            _log->debug("Attempting to build {} of type {} from config",
                        cfg_name,
                        type_name);
 
            if (known_objects.find(type_name) == known_objects.end())
            {
                throw std::invalid_argument("Error for node " + cfg_name +
                                            ": No 'type' node given");
            }
            else
            {
                if (obj_cfg["args"])
                {
                    _log->debug("  ... using given arguments from config ...");
                    map[cfg_name] =
                        known_objects[type_name](); // default construct
                    map[cfg_name]->set_from_cfg(obj_cfg["args"]);
                }
                else
                {
 
                    // if no args is given, do a default build because this
                    // not all of the deciders/triggers need an args node
                    _log->debug("... constructing {} of type {} without "
                                "config args because no node 'args' is "
                                "given for it in the config.",
                                cfg_name,
                                type_name);
 
                    map[cfg_name] = known_objects[type_name]();
                }
            }
        }
 
        return map;
    }
 
    TaskMap
    _filter_tasks_from_config(const Config& task_cfg, TaskMap& tasks)
    {
        // map to use in the end
        TaskMap map;
 
        if (not task_cfg)
        {
            throw std::invalid_argument(
                "Error: data_manager config node needs to contain a node "
                "'tasks' which it apparently is missing ");
        }
        if (not task_cfg.IsMap())
        {
            throw std::invalid_argument("Expected a mapping for DataManager "
                                        "task filtering, got:\n" +
                                        to_string(task_cfg));
        }
 
        for (const auto& node_pair : task_cfg)
        {
            // Unpack the (key node, value node) pair, i.e. the name of the
            // object that is to be configured and the corresponding
            // configuration node
            const auto  cfg_name = node_pair.first.as< std::string >();
            const auto& obj_cfg  = node_pair.second;
 
            _log->debug("Investigating task {} and checking if it is active ",
                        cfg_name);
 
            if (get_as< bool >("active", obj_cfg))
            {
 
                _log->debug("Task '{}' was marked as active; will be kept.",
                            cfg_name);
 
                if (tasks.find(cfg_name) == tasks.end())
                {
                    throw std::invalid_argument(
                        "Error, no task supplied to the datamanager is named " +
                        cfg_name);
                }
                else
                {
                    map[cfg_name] = tasks[cfg_name];
                }
            }
            else
            {
                // skip inactive tasks
                _log->debug("Task '{}' was marked as not active; skipping.",
                            cfg_name);
                continue;
            }
        }
 
        return map;
    }
 
    template < typename DTMap >
    AssocsMap
    _associate_from_config(const Config& task_cfg,
                           DTMap&&       dt_map,
                           std::string   lookup_key)
    {
        AssocsMap map;
 
        // error checking regarding the task_cfg node is done in the
        // _filter_tasks function, and hence does not need to be repeated here
 
        _log->debug("Building task to {} associations from given config ...",
                    lookup_key);
 
        // Iterate over the given configuration node, pull out the name of the
        // task and the name of the associated decider/trigger, and put the
        // AssocsMap together from this
        for (const auto& node_pair : task_cfg)
        {
            // Unpack the (key node, value node) pair
            const auto  task_name = node_pair.first.as< std::string >();
            const auto& task_cfg  = node_pair.second;
 
            // Find out if active; true by default
            const auto active = get_as< bool >("active", task_cfg, true);
 
            // Associate only if active
            if (not active)
            {
                _log->debug("Task '{}' was marked as not active; skipping.",
                            task_name);
                continue;
            }
 
            // Get the name of the trigger or decider to associate to
 
            const auto dt_to_associate_to =
                get_as< std::string >(lookup_key, task_cfg);
 
            // Find erroneous config namings for deciders/triggers
            if (dt_map.find(dt_to_associate_to) == dt_map.end())
            {
                this->_log->info(" Error for decider/trigger: {}",
                                 dt_to_associate_to);
                throw std::invalid_argument(
                    "Error when trying to associate tasks to deciders or "
                    "triggers: "
                    "Name in config does not match the name of a "
                    "decider/trigger known to the datamanager");
            }
            else
            {
                // dt_to_associate_to exists in the dt_map, we're good
                map[dt_to_associate_to].push_back(task_name);
 
                _log->debug("Associating task '{}' to {} '{}'.",
                            task_name,
                            lookup_key,
                            dt_to_associate_to);
            }
        }
 
        // Use the helper function to build the actual association map
        return map;
    }
 
  public:
    // -- Public interface ----------------------------------------------------
 
    template < class Model, typename... Args >
    void
    operator()(Model&& model, Args&&... args)
    {
        _execution_process(
            *this, std::forward< Model >(model), std::forward< Args >(args)...);
    }
 
    // .. Getters .............................................................
 
    DeciderMap&
    get_deciders()
    {
        return _deciders;
    }
 
    TaskMap&
    get_tasks()
    {
        return _tasks;
    }
 
    TriggerMap&
    get_triggers()
    {
        return _triggers;
    }
 
    AssocsMap&
    get_decider_task_map()
    {
        return _decider_task_map;
    }
 
    AssocsMap&
    get_trigger_task_map()
    {
        return _trigger_task_map;
    }
 
    const std::shared_ptr< spdlog::logger >&
    get_logger() const
    {
        return _log;
    }
 
    // .. Rule of Five ........................................................
 
    DataManager() = default;
 
    DataManager(const DataManager& other) = default;
 
    DataManager(DataManager&& other) = default;
 
    DataManager&
    operator=(const DataManager& other) = default;
 
    DataManager&
    operator=(DataManager&& other) = default;
 
    virtual ~DataManager() = default;
 
    // .. Constructors ........................................................
 
    DataManager(
        const Config& cfg,
        TaskMap       tasks,
        std::unordered_map< std::string,
                            std::function< std::shared_ptr< Decider >() > >
            deciders,
        std::unordered_map< std::string,
                            std::function< std::shared_ptr< Trigger >() > >
                         triggers,
        ExecutionProcess execproc) :
        // Get the global data manager logger
        _log(spdlog::get("data_mngr")),
        _tasks(_filter_tasks_from_config(cfg["tasks"], tasks)),
        _deciders(_setup_from_config< DeciderMap >(cfg["deciders"], deciders)),
        _triggers(_setup_from_config< TriggerMap >(cfg["triggers"], triggers)),
        // Create maps: decider/trigger -> vector of task names
        _decider_task_map(
            _associate_from_config(cfg["tasks"], _deciders, "decider")),
        _trigger_task_map(
            _associate_from_config(cfg["tasks"], _triggers, "trigger")),
        _execution_process(execproc)
    {
        // nothing remains to be done here
    }
 
    DataManager(OrderedTaskMap                       tasks,
                OrderedDeciderMap                    deciders,
                OrderedTriggerMap                    triggers,
                ExecutionProcess                     execproc,
                std::map< std::string, std::string > decider_task_assocs = {},
                std::map< std::string, std::string > trigger_task_assocs = {}) :
        // Get the global data manager logger
        _log(spdlog::get("data_mngr")),
        _tasks(TaskMap(tasks.begin(), tasks.end())),
        _deciders(DeciderMap(deciders.begin(), deciders.end())),
        _triggers(TriggerMap(triggers.begin(), triggers.end())),
        // Create maps: decider/trigger -> vector of task names
        _decider_task_map(_DMUtils::build_task_association_map< AssocsMap >(
            tasks, deciders, decider_task_assocs)),
        _trigger_task_map(_DMUtils::build_task_association_map< AssocsMap >(
            tasks, triggers, trigger_task_assocs)),
        _execution_process(execproc)
    {
        _log->info("DataManager setup with {} task(s), {} decider(s), and "
                   "{} trigger(s).",
                   _tasks.size(),
                   _decider_task_map.size(),
                   _trigger_task_map.size());
    }
 
    // .. Helper Methods ......................................................
 
    void
    swap(DataManager& other)
    {
        if (this == &other)
        {
            return;
        }
 
        using std::swap;
        swap(_log, other._log);
        swap(_tasks, other._tasks);
        swap(_deciders, other._deciders);
        swap(_triggers, other._triggers);
        swap(_decider_task_map, other._decider_task_map);
        swap(_trigger_task_map, other._trigger_task_map);
    }
};
 
// ++ Default DataManager +++++++++++++++++++++++++++++++++++++++++++++++++++++
 
namespace Default
{
template < typename Model >
using DefaultDataManager =
    DataManager< DataManagerTraits< Default::DefaultWriteTask< Model >,
                                    Default::Decider< Model >,
                                    Default::Trigger< Model >,
                                    Default::DefaultExecutionProcess > >;
} // namespace Default
 
} // namespace DataIO
} // namespace Utopia
 
#endif // UTOPIA_DATAIO_DATAMANAGER_HH