templated alias for member functions with different return types

Question

If have the following problem

    class a;
    class b;
    class c;
    class db {
        ...
        const std::set<a*>& get_all_a();
        const std::vector<b*>& get_all_b();
        const custom_c_container& obtain_all_the_cs();
        ...
    }

I have a long function, that needs to do something similar (I can write a template, which takes the type a, b or c, for that) for each of those 3 datasets and has a instance of db. The only issue is the data-access. I would like to solve that by writing something to the effect of:

    template<class data_type>
    auto get_data();

    template<>
    std::result_of<decltype(&db::get_all_a)(db)>::type get_data<a> 
        = std::mem_fn(&db::get_all_a);

There are probably multiple reasons this fails, but I hope it does show what I'm trying to achieve.

As suggested I will add a desired usage example:

    template<class data_type>
    void process(db& my_db) {
        for(auto& item : get_data<data_type>(my_db) {
            //... some processing ...
        }
    }
    ...
    void process_all() {
        db my_db = get_db();
        process<a>(my_db);
        process<b>(my_db);
        process<c>(my_db);
    }

Answer 1

C++17 solution:

template <class data_type>
decltype(auto) get_data()
{
         if constexpr(std::is_same_v<data_type, a>) { return get_all_a(); }
    else if constexpr(std::is_same_v<data_type, b>) { return get_all_b(); }
    else                                            { return get_all_c(); }
} 

---

C++14 solution:

template <typename> 
struct dispatch;

template <> 
struct dispatch<a> { decltype(auto) get(db& x) { return x.get_all_a(); } };

template <> 
struct dispatch<b> { decltype(auto) get(db& x) { return x.get_all_b(); } };

template <> 
struct dispatch<c> { decltype(auto) get(db& x) { return x.get_all_c(); } };

template <class data_type>
decltype(auto) get_data()
{
    return dispatch<data_type>{}.get(db);
}

---

C++11 solution:

template <typename> 
struct dispatch;

template <> 
struct dispatch<a> 
{ 
    auto get(db& x) -> decltype(x.get_all_a()) { return x.get_all_a(); } 
};

template <> 
struct dispatch<b> 
{ 
    auto get(db& x) -> decltype(x.get_all_b()) { return x.get_all_b(); } 
};

template <> 
struct dispatch<c> 
{ 
    auto get(db& x) -> decltype(x.get_all_c()) { return x.get_all_c(); } 
};

template <class data_type>
auto get_data() -> decltype(dispatch<data_type>{}.get(db))
{
    return dispatch<data_type>{}.get(db);
}