Create class based on variadic templates

Question

Lets imagine that we have several data flows and we need unite them to one. Capacity of flows (and type) is known at application level. So we need class that incapsulates all other classes that relates to each data flow and produces common frame based on return type of data flows. Each data flow class have next interface:

// note that there are several classes with similar interface
class FlowOne {
  using return_type = some_data;

  return_type get();
};

Main flow class will look like:

template <typename... Args>
class Main {
  using return_type = *based on Args::return_type*;
  return_type get();
};

So, here is a question: how to define Main::return_type - that should be a tuple of return_type-s from its Args? Is it possible?

Thanks

Why not use `auto get()` and let the compiler figure it out? — Stephen Newell, Sep 22 '22 at 13:09
Is your goal to get `Main::get` to return a collection of all of the `FlowXXX::get` returns? — NathanOliver, Sep 22 '22 at 13:09
you mean something like `std::tuple` ? Did you try anything? — 463035818_is_not_an_ai, Sep 22 '22 at 13:09
@AndrejLevkovitch Then you probably want `using return_type = std::tuple;` — NathanOliver, Sep 22 '22 at 13:10
@463035818_is_not_a_number nope, just because I can't find cases like this in documentation — Andrej Levkovitch, Sep 22 '22 at 13:11

Stack Danny · Accepted Answer · 2022-09-22T13:28:10.323

You can expand Args... to be std::tuple<Args...> and declare a member of that type. Now your Main class has a tuple of all Flow types:

template <typename... Args>
struct Main {
    using tuple_type = std::tuple<Args...>;
    tuple_type members;

the next step is to make a get() function that returns the .get() of all members. This can be achieved with std::apply to iterate over the tuple, and call .get() on each object. Keep in mind that, if your final get() functions return a reference, this get() should also return one (meaning auto& or auto&&).

auto get() {
    return std::apply([](auto&&... member) {
        return std::make_tuple(member.get()...);
    }, this->members);
}

As you can see, if we say decltype(get) on the member function, it will be equal to the std::tuple of Flow types:

struct FlowOne {
    using return_type = int;

    return_type get() {
        return {};
    }
};
struct FlowTwo {
    using return_type = double;
    return_type get() {
        return {};
    }
};

int main() {
    Main<FlowOne, FlowTwo> main;
    auto get = main.get();

    static_assert(std::is_same_v<decltype(get), std::tuple<int, double>>);
}

if you still wish to define a Main::return_type, you can use this using statement:

using return_type = std::tuple<typename Args::return_type...>;

we have to add typename here, because return_type is a dependant type of Args. You can read more about this on this post

Try out the full code on godbolt.

Adrian Maire · Answer 2 · 2022-09-22T14:09:22.190

This calls all the flows and return a tuple with all the return values:

template <typename... Args>
class Main 
{
public:
    // Return tuple, with all the results of the Args::get()
    // e.g. if Args is <FlowOne, FlowTwo>, then tuple<int,float>
    using merged_type = std::tuple<decltype(Args::get())...>;
    
    merged_type get()
    {
        return {Args::get()...};
    }
};

Here is a full and working example:

#include <iostream>
#include <tuple>

struct FlowOne 
{
  using return_type = int;

  static return_type get()
  { 
      return 42; 
  }
};

struct FlowTwo 
{
  using return_type = float;

  static return_type get()
  {
      return 42.1;
  }
};

template <typename... Args>
class Main 
{
public:
    using merged_type = std::tuple<decltype(Args::get())...>;
    merged_type get()
    {
        return {Args::get()...};
    }
};

int main()
{
    const auto ret = Main<FlowOne, FlowTwo>().get();
    
    std::cout << std::get<0>(ret) << std::endl;
    std::cout << std::get<1>(ret) << std::endl;
}

You can test it here: https://onlinegdb.com/3nG0ffBUd

yeah, I see your point, but idea is __return all flow values__ at Main::get() call. Also type of flow data can be same for several flows. Anyway, thanks — Andrej Levkovitch, Sep 22 '22 at 13:46
@AndrejLevkovitch: Let me know if my update match better your need. — Adrian Maire, Sep 22 '22 at 14:11

Create class based on variadic templates

2 Answers2