defaults.hh

Go to the documentation of this file.

#ifndef UTOPIA_DATAIO_DATA_MANAGER_DEFAULTS_HH
#define UTOPIA_DATAIO_DATA_MANAGER_DEFAULTS_HH
 
#include <boost/hana/ext/std/tuple.hpp>
#include <boost/hana/fold.hpp>
#include <boost/hana/zip.hpp>
#include <unordered_map>
 
#include "../cfg_utils.hh"
#include "write_task.hh"
 
namespace Utopia
{
namespace DataIO
{
namespace Default
{
 
// =============================================================================
// ================================ Writer Tasks ===============================
// =============================================================================
 
using DefaultBaseGroupBuilder =
    std::function< std::shared_ptr< HDFGroup >(std::shared_ptr< HDFGroup >&&) >;
 
template < typename Model >
using DefaultDataWriter =
    std::function< void(std::shared_ptr< HDFDataset >&, Model&) >;
 
template < typename Model >
using DefaultBuilder = std::function< std::shared_ptr< HDFDataset >(
    std::shared_ptr< HDFGroup >&, Model&) >;
 
template < typename Model >
using DefaultAttributeWriterGroup =
    std::function< void(std::shared_ptr< HDFGroup >&, Model&) >;
 
template < typename Model >
using DefaultAttributeWriterDataset =
    std::function< void(std::shared_ptr< HDFDataset >&, Model&) >;
 
template < typename Model >
using DefaultWriteTask = WriteTask< DefaultBaseGroupBuilder,
                                    DefaultDataWriter< Model >,
                                    DefaultBuilder< Model >,
                                    DefaultAttributeWriterGroup< Model >,
                                    DefaultAttributeWriterDataset< Model > >;
 
// =============================================================================
// ================================ Execution Process ==========================
// =============================================================================
 
struct DefaultExecutionProcess
{
    template < class Datamanager, class Model >
    void
    operator()(Datamanager& dm, Model& m)
    {
        auto& tasks = dm.get_tasks();
        for (auto& taskpair : tasks)
        {
            // TODO Instead of nullptr-check, check boolean?!
            if (taskpair.second->base_group == nullptr)
            {
                taskpair.second->base_group =
                    taskpair.second->build_basegroup(m.get_hdfgrp());
            }
        }
        for (auto& [name, trigger] : dm.get_triggers())
        {
            if ((*trigger)(m))
            {
                for (auto& taskname : dm.get_trigger_task_map()[name])
                {
                    // using this ref variable avoids recomputing 
                    // 'taskname''s hash all the time, should give minor 
                    // performance improvement
                    auto& task = tasks[taskname];
 
                    task->active_dataset =
                        task->build_dataset(
                            task->base_group, m);
 
                    if (task->write_attribute_basegroup)
                    {
                        task->write_attribute_basegroup(
                            task->base_group, m);
                    }
                }
            }
        }
 
        for (auto& [name, decider] : dm.get_deciders())
        {
            if ((*decider)(m))
            {
                for (auto& taskname : dm.get_decider_task_map()[name])
                {
                    auto& task = tasks[taskname];
 
                    task->write_data(task->active_dataset,
                                                m);
                    if (task->write_attribute_active_dataset)
                    {
                        task->write_attribute_active_dataset(
                            task->active_dataset, m);
                    }
                }
            }
        }
    }
};
 
 
// =============================================================================
// ================================ Decider ====================================
// =============================================================================
 
template<typename Model> 
struct Decider {
 
    virtual bool operator()(Model&) = 0; 
    virtual void set_from_cfg(const Config&) = 0;
 
    Decider()                      = default;
    Decider(const Decider&) = default;
    Decider(Decider&&)      = default;
    Decider&
    operator=(const Decider&) = default;
    Decider&
    operator=(Decider&&) = default; 
    virtual ~Decider() = default;
};
 
 
 
template < typename Model >
struct IntervalDecider : Decider< Model >
{
 
    using Base = Decider< Model >;
 
    std::list< std::array< std::size_t, 3 > > intervals;
 
    virtual bool
    operator()(Model& m) override
    {
        // Are at the end of the current interval; pop it, such that
        // at next invocation the front is the new interval
        if (intervals.size() != 0 and m.get_time() == intervals.front()[1])
        {
            intervals.pop_front();
        }
 
        if (intervals.size() != 0)
        {
            const auto [start, stop, step] = intervals.front();
            // Check if within [start, end) interval
            if ((m.get_time() >= start) and (m.get_time() < stop) and
                ((m.get_time() - start) % step == 0))
            {
                return true;
            }
        }
        return false;
    }
    virtual void
    set_from_cfg(const Config& cfg) override
    {
        auto tmp = get_as< std::list< std::vector< std::size_t > > >(
            "intervals", cfg);
        for (std::vector< std::size_t > tmp_interval : tmp)
        {
            if (tmp_interval.size() == 2)
            {
                tmp_interval.push_back(1);
            }
            else if (tmp_interval.size() != 3)
            {
                throw Utopia::KeyError("intervals", cfg,
                    fmt::format("Array of unexpected length {}! "
                        "Expected array of length 2 or 3 [start, stop, step] "
                        "with step optional (default 1).",
                        tmp_interval.size())
                    );
            }
 
            std::array< std::size_t, 3 > interval;
            std::copy(tmp_interval.begin(), tmp_interval.end(),
                      interval.begin());
            intervals.push_back(interval);
        }
    }
 
    IntervalDecider()                       = default;
    IntervalDecider(const IntervalDecider&) = default;
    IntervalDecider(IntervalDecider&&)      = default;
    IntervalDecider&
    operator=(const IntervalDecider&) = default;
    IntervalDecider&
    operator=(IntervalDecider&&) = default;
    virtual ~IntervalDecider()   = default;
};
 
template < typename Model >
struct OnceDecider : Decider< Model >
{
    using Base = Decider< Model >;
    std::size_t time;
 
    virtual bool
    operator()(Model& m) override
    {
        return (m.get_time() == time);
    }
 
    virtual void
    set_from_cfg(const Config& cfg) override
    {
        time = get_as< std::size_t >("time", cfg);
    }
 
    OnceDecider() = default;
 
    OnceDecider(const OnceDecider&) = default;
    OnceDecider(OnceDecider&&)      = default;
    OnceDecider&
    operator=(const OnceDecider&) = default;
    OnceDecider&
    operator=(OnceDecider&&) = default;
    virtual ~OnceDecider()   = default;
};
 
template < typename Model >
struct AlwaysDecider : Decider< Model >
{
    using Base = Decider< Model >;
 
    virtual bool
    operator()(Model&) override
    {
        return true;
    }
 
    // dummy implementation of 
    virtual void
    set_from_cfg(const Config&) override {}
 
    AlwaysDecider() = default;
 
    AlwaysDecider(const AlwaysDecider&) = default;
    AlwaysDecider(AlwaysDecider&&)      = default;
    AlwaysDecider&
    operator=(const AlwaysDecider&) = default;
    AlwaysDecider&
    operator=(AlwaysDecider&&) = default;
    virtual ~AlwaysDecider()   = default;
};
 
template < typename Model, typename... Deciders >
struct CompositeDecider : Decider< Model >
{
    using Base = Decider< Model >;
 
    std::tuple< Deciders... > held_deciders;
 
    virtual bool
    operator()(Model& m) override
    {
        return boost::hana::fold(
            held_deciders, false, [&m](bool res, auto&& decider) {
                return (res or decider(m));
            });
    }
 
    virtual void
    set_from_cfg(const Config& cfg) override
    {
        // BAD: User has to be smart about it, because it breaks
        // if args are not the same order as Deciders...
        std::array< const Config&, sizeof...(Deciders) > configs;
 
        // make the args node for each decider into an array
        auto conf_it = configs.begin();
 
        for (auto it = cfg.begin(); it != cfg.end(); ++it, ++conf_it)
        {
            *conf_it = it->second["args"];
        }
 
        // then iterate over the zipped confs and deciders and built the
        // deciders with their respective config
        boost::hana::for_each(boost::hana::zip(configs, held_deciders),
                              [](auto&& conf_dcd_pair) {
                                  auto&& [c, d] = conf_dcd_pair;
                                  d.set_from_cfg(c);
                              });
    }
 
    CompositeDecider()                        = default;
    CompositeDecider(const CompositeDecider&) = default;
    CompositeDecider&
    operator=(const CompositeDecider&) = default;
    CompositeDecider&
    operator=(CompositeDecider&&) = default;
    virtual ~CompositeDecider()   = default;
};
 
// =============================================================================
// =========================== Default type maps  ==============================
// =============================================================================
 
template < typename Model >
using DefaultDecidermap = std::unordered_map<
    std::string,
    std::function< std::shared_ptr< Decider< Model > >() > >;
 
template < typename Model >
static DefaultDecidermap<Model> default_deciders{
    { std::string("always"),
      []() { return std::make_shared< AlwaysDecider< Model > >(); } },
    { std::string("once"),
      []() { return std::make_shared< OnceDecider< Model > >(); } },
    { std::string("interval"),
      []() { return std::make_shared< IntervalDecider< Model > >(); } }
};
 
// =============================================================================
// ================================ Triggers
// ===================================
// =============================================================================
 
template < typename Model >
using Trigger = Decider< Model >;
 
template < typename Model >
using IntervalTrigger = IntervalDecider< Model >;
 
template < typename Model >
using BuildOnceTrigger = OnceDecider< Model >;
 
template < typename Model >
using BuildAlwaysTrigger = AlwaysDecider< Model >;
 
template < typename Model, typename... Deciders >
using CompositeTrigger = CompositeDecider< Model, Deciders... >;
 
template < typename Model >
using DefaultTriggermap = DefaultDecidermap< Model >;
template < typename Model >
static DefaultTriggermap<Model> default_triggers = default_deciders< Model >;
 
} // namespace Default
} // namespace DataIO
} // namespace Utopia
 
#endif