callback_utils_chunk.hpp

Go to the documentation of this file.

 
#ifndef CALLBACK_UTILS_CHUNK_HPP
#define CALLBACK_UTILS_CHUNK_HPP
 
#include <string>
 
#include "callback.hpp"
 
namespace CallbackUtils {
 
namespace chunk {
 
    template<typename AFields>
    class SingleGrp :
        virtual public Callback<AFields>
    {// {{{
        const std::string grp_fname;
    public :
        SingleGrp (const std::string &grp_fname_) :
            grp_fname(grp_fname_)
        { }
 
        bool grp_chunk (size_t chunk_idx, std::string &fname) const override final
        {
            fname = grp_fname;
            return !chunk_idx;
        }
    };// }}}
 
    template<typename AFields>
    class SinglePrt :
        virtual public Callback<AFields>
    {// {{{
        const std::string prt_fname;
    public :
        SinglePrt (const std::string &prt_fname_) :
            prt_fname(prt_fname_)
        { }
        bool prt_chunk (size_t chunk_idx, std::string &fname) const override final
        {
            fname = prt_fname;
            return !chunk_idx;
        }
    };// }}}
 
    template<typename AFields>
    class MultiGrp :
        virtual public Callback<AFields>
    {// {{{
        const std::string grp_fname;
        const size_t min_idx, max_idx;
    public :
        MultiGrp (const std::string &grp_fname_, size_t max_idx_, size_t min_idx_=0UL) :
            grp_fname(grp_fname_), min_idx(min_idx_), max_idx(max_idx_)
        { }
 
        bool grp_chunk (size_t chunk_idx, std::string &fname) const override final
        {
            char buf[grp_fname.size()+10];
            std::sprintf(buf, grp_fname.c_str(), min_idx+chunk_idx);
            fname = std::string(buf);
            return min_idx+chunk_idx <= max_idx;
        }
    };// }}}
 
    template<typename AFields>
    class MultiPrt :
        virtual public Callback<AFields>
    {// {{{
        const std::string prt_fname;
        const size_t min_idx, max_idx;
    public :
        MultiPrt (const std::string &prt_fname_, size_t max_idx_, size_t min_idx_=0UL) :
            prt_fname(prt_fname_), min_idx(min_idx_), max_idx(max_idx_)
        { }
 
        bool prt_chunk (size_t chunk_idx, std::string &fname) const override final
        {
            char buf[prt_fname.size()+10];
            std::sprintf(buf, prt_fname.c_str(), min_idx+chunk_idx);
            fname = std::string(buf);
            return min_idx+chunk_idx <= max_idx;
        }
    };// }}}
 
    template<typename AFields>
    struct Single :
        virtual public Callback<AFields>,
        public SingleGrp<AFields>, public SinglePrt<AFields>
    {// {{{
        Single (const std::string &grp_fname,
                const std::string &prt_fname) :
            SingleGrp<AFields>(grp_fname), SinglePrt<AFields>(prt_fname) { }
    };// }}}
 
    template<typename AFields>
    struct Multi :
        virtual public Callback<AFields>,
        public MultiGrp<AFields>, public MultiPrt<AFields>
    {// {{{
        Multi (const std::string &grp_fname, size_t grp_max_idx,
               const std::string &prt_fname, size_t prt_max_idx) :
            MultiGrp<AFields>(grp_fname, grp_max_idx),
            MultiPrt<AFields>(prt_fname, prt_max_idx) { }
    };// }}}
 
} // namespace chunk
 
} // namespace CallbackUtils
 
#endif // CALLBACK_UTILS_CHUNK_HPP