callback_utils_select.hpp

Go to the documentation of this file.

 
#ifndef CALLBACK_UTILS_SELECT_HPP
#define CALLBACK_UTILS_SELECT_HPP
 
#include <cassert>
#include <utility>
#include <functional>
 
#include "callback.hpp"
 
namespace CallbackUtils {
 
namespace select
{
 
    template<typename AFields>
    class MultiSelectBase :
        virtual public Callback<AFields>
    {// {{{
        using typename Callback<AFields>::GrpProperties;
        static constexpr size_t buf_size = 64UL;
        size_t N_selects = 0UL;
        std::pair<void *, std::function<bool(void *, const GrpProperties &)>> selectors[buf_size];
    protected :
        void register_select (void *obj, std::function<bool(void *, const GrpProperties &)> fct)
        {
            selectors[N_selects++] = std::make_pair(obj, fct);
            assert(N_selects < buf_size);
        }
    public :
        bool grp_select (const GrpProperties &grp) const override final
        {
            for (size_t ii=0; ii != N_selects; ++ii)
                if (!selectors[ii].second(selectors[ii].first, grp))
                    return false;
            return true;
        }
    };// }}}
 
    template<typename AFields, typename Child>
    class MultiSelect :
        virtual public Callback<AFields>,
        virtual private MultiSelectBase<AFields>
    {// {{{
        using typename Callback<AFields>::GrpProperties;
        static bool this_grp_select_static (void *obj, const GrpProperties &grp)
        {
            Child *p = (Child *)obj;
            return p->this_grp_select(grp);
        }
    protected :
        virtual bool this_grp_select (const GrpProperties &grp) const = 0;
    public :
        MultiSelect ()
        {
            MultiSelectBase<AFields>::register_select(this, this_grp_select_static);
        }
    };// }}}
 
    template<typename AFields, typename Field>
    class Window :
        virtual public Callback<AFields>,
        private MultiSelect<AFields, Window<AFields, Field>>
    {// {{{
        friend MultiSelect<AFields, Window<AFields, Field>>;
        using typename Callback<AFields>::GrpProperties;
        static_assert(Field::dim == 1);
        static_assert(Field::type == FieldTypes::GrpFld);
        static_assert(std::is_floating_point_v<typename Field::value_type>);
 
        typename Field::value_type min_val, max_val;
 
        bool this_grp_select (const GrpProperties &grp) const override final
        {
            auto x = grp.template get<Field>();
            return x > min_val && x < max_val;
        }
    public :
        Window (typename Field::value_type min_val_, typename Field::value_type max_val_) :
            min_val { min_val_ }, max_val  { max_val_ }
        { }
    };// }}}
    
    template<typename AFields, typename Field>
    struct LowCutoff :
        virtual public Callback<AFields>,
        private Window<AFields, Field>
    {// {{{
        LowCutoff (typename Field::value_type min_val) :
            Window<AFields, Field> { min_val, std::numeric_limits<typename Field::value_type>::max() } { }
    };// }}}
    
    template<typename AFields, typename Field>
    struct HighCutoff :
        virtual public Callback<AFields>,
        private Window<AFields, Field>
    {// {{{
        HighCutoff (typename Field::value_type max_val) :
            Window<AFields, Field> { std::numeric_limits<typename Field::value_type>::min(), max_val } { }
    };// }}}
 
} // namespace select
 
} // namespace CallbackUtils
 
 
#endif // CALLBACK_UTILS_SELECT_HPP