callback_utils_grp_action.hpp

Go to the documentation of this file.

 
#ifndef CALLBACK_UTILS_GRP_ACTION_HPP
#define CALLBACK_UTILS_GRP_ACTION_HPP
 
#include <cassert>
#include <functional>
#include <vector>
#include <type_traits>
#include <cstdio>
 
#include "callback.hpp"
 
namespace CallbackUtils {
 
namespace grp_action {
 
    template<typename AFields>
    class MultiGrpActionBase :
        virtual public Callback<AFields>
    {// {{{
        using typename Callback<AFields>::GrpProperties;
 
        static constexpr size_t buf_size = 64UL;
        size_t N_actions = 0UL;
        std::pair<void *, std::function<void(void *, const GrpProperties &)>> grp_actions[buf_size];
    protected :
        void register_fct (void *obj, std::function<void(void *, const GrpProperties &)> fct)
        {
            grp_actions[N_actions++] = std::make_pair(obj, fct);
            assert(N_actions < buf_size);
        }
    public :
        void grp_action (const GrpProperties &grp) override final
        {
            for (size_t ii=0; ii != N_actions; ++ii)
                grp_actions[ii].second(grp_actions[ii].first, grp);
        }
    };// }}}
 
    template<typename AFields, typename Child>
    class MultiGrpAction :
        virtual public Callback<AFields>,
        virtual private MultiGrpActionBase<AFields>
    {// {{{
        using typename Callback<AFields>::GrpProperties;
        static void this_grp_action_static (void *obj, const GrpProperties &grp)
        {
            Child *p = (Child *)obj;
            p->this_grp_action(grp);
        }
    protected :
        virtual void this_grp_action (const GrpProperties &grp) = 0;
    public :
        MultiGrpAction ()
        {
            MultiGrpActionBase<AFields>::register_fct(this, this_grp_action_static);
        }
    };// }}}
 
    template<typename AFields, typename Tdata>
    class StoreGrpHomogeneous :
        virtual public Callback<AFields>,
        private MultiGrpAction<AFields, StoreGrpHomogeneous<AFields, Tdata>>
    {// {{{
        friend MultiGrpAction<AFields, StoreGrpHomogeneous<AFields, Tdata>>;
        using typename Callback<AFields>::GrpProperties;
        std::vector<Tdata> &data;
        void this_grp_action (const GrpProperties &grp) override final
        {
            data.push_back(grp_reduce(grp));
        }
    protected :
        virtual Tdata grp_reduce (const GrpProperties &grp) const = 0;
    public :
        StoreGrpHomogeneous (std::vector<Tdata> &data_) :
            data(data_)
        { }
    };// }}}
 
    template<typename AFields, typename Field, typename storeasT = typename Field::value_type>
    class StoreGrpProperty :
        virtual public Callback<AFields>,
        private StoreGrpHomogeneous<AFields, storeasT>
    {// {{{
        static_assert(Field::dim == 1, "Currently not implemented, could probably be done");
        static_assert(std::is_arithmetic_v<storeasT>);
        storeasT grp_reduce (const typename Callback<AFields>::GrpProperties &grp) const override final
        {
            return grp.template get<Field>();
        }
    public :
        StoreGrpProperty (std::vector<storeasT> &data) :
            StoreGrpHomogeneous<AFields, storeasT>(data)
        { }
    };// }}}
 
} // namespace grp_action
 
} // namespace CallbackUtils
 
#endif // CALLBACK_UTILS_GRP_ACTION_HPP