callback_utils_prt_action.hpp

Go to the documentation of this file.

 
#ifndef CALLBACK_UTILS_PRT_ACTION_HPP
#define CALLBACK_UTILS_PRT_ACTION_HPP
 
#include "callback.hpp"
#include "callback_utils_grp_action.hpp"
 
namespace CallbackUtils {
 
namespace prt_action {
 
    template<typename AFields, typename Tdata>
    class StorePrtHomogeneous :
        virtual public Callback<AFields>,
        private grp_action::MultiGrpAction<AFields, StorePrtHomogeneous<AFields, Tdata>>
    {// {{{
        friend grp_action::MultiGrpAction<AFields, StorePrtHomogeneous<AFields, Tdata>>;
        using typename Callback<AFields>::GrpProperties;
        using typename Callback<AFields>::PrtProperties;
 
        // some functionality to figure out whether Tdata has the method
        // void prt_insert (size_t grp_idx, const GrpProperties &grp,
        //                  const PrtProperties &prt, coord_t Rsq)
        // from https://stackoverflow.com/questions/87372/check-if-a-class-has-a-member-function-of-a-given-signature
        template<typename, typename T>
        struct has_prt_insert { static_assert(std::integral_constant<T, false>::value); };
 
        template<typename C, typename Ret, typename... Args>
        class has_prt_insert<C, Ret(Args...)>
        {
            template<typename T>
            static constexpr auto check (T *)
                -> typename std::is_same<
                                decltype(std::declval<T>().prt_insert(std::declval<Args>()...)),
                                Ret
                            >::type;
            
            template<typename>
            static constexpr std::false_type check(...);
 
            using type = decltype(check<C>(0));
        public :
            static constexpr bool value = type::value;
        };
 
 
        std::vector<Tdata> &data;
 
        void this_grp_action (const GrpProperties &grp) override final
        {
            if constexpr (std::is_constructible_v<Tdata, const GrpProperties &>)
            {
                static_assert(!std::is_default_constructible_v<Tdata>);
                data.emplace_back(grp);
            }
            else
                data.emplace_back();
        }
    protected :
        virtual void prt_insert (size_t grp_idx, const GrpProperties &grp,
                                 const PrtProperties &prt, coord_t Rsq,
                                 Tdata &data_item)
        {
            assert(("Need to override CallbackUtils::StorePrtHomogeneous<AFields,Tdata>::prt_insert if Tdata does not implement prt_insert method.", false));
        }
 
    public :
        StorePrtHomogeneous (std::vector<Tdata> &data_) :
            data(data_)
        { }
 
        void prt_action (size_t grp_idx, const GrpProperties &grp,
                         const PrtProperties &prt, coord_t Rsq) override final
        {
            if constexpr (has_prt_insert<Tdata, void(size_t, const GrpProperties &,
                                                     const PrtProperties &, coord_t)>::value)
                data[grp_idx].prt_insert(grp_idx, grp, prt, Rsq);
            else
                prt_insert(grp_idx, grp, prt, Rsq, data[grp_idx]);
        }
    };// }}}
 
} // namespace prt_action
 
 
} // namespace CallbackUtils
 
#endif // CALLBACK_UTILS_PRT_ACTION_HPP