Generics types in a queue

Question

I get a queue of events which must contain a class with generic variables. In order to do that I tried to use the tuples. I used variadic templates to generate my tuples but I can't put them in my queue because of their types which aren't the same. Could you give me some advise about how to do this?

#include <type_traits>
#include <iostream>

#include <vector>
#include <iostream>
#include <tuple>
#include <utility>

#include <queue>

class Logs
{
public:
  Logs() {}    

  template <class T, class... Values>
  void write(T data, Values&&... values) {
    auto save = std::tuple_cat(_t, std::make_tuple(data)); // I would like to save the return in a variable class
    write(values...);
  }

  void write() {
    // the end
    // _queue.push(save);
  }
std::tuple& getTuple() { return _t;}
private:
  std::tuple<> _t;
  std::queue<std::tuple<>> _queue;

};


#include <iostream>

int main(int ac, char **av) {
  Logs log;
  Logs log2;

  log.write(4, "42");
  log.write(Logs(), 4.5f, 42, "toto");
  log.write({"hello", "titi"}, 84, "foo");
  // std::cout << std::get<0>(log.getTuple()) << std::endl;
  return 0;
}

Which could be the type of _t and _queue ? I would like to push in my queue get one time a std::tuple<int, std::string, Log. float, ...> then a std::tuple<std::vector<std::string>, int, long>, etc. .

Answer 1

You could use a union as the type of your std::queue, like this:

#include <iostream>
#include <queue>

typedef union Data {
   int i;
   float f;
   char str[20];
   struct foo {
       int a;
       char c;
   } foo;
   struct bar {
       int a;
       double d;
   } bar;
} data;  

int main () {

  std::queue<data> q;
  data mydata;
  mydata.i = 5;
  q.push(mydata);

  data mydata1;
  mydata1.f = 3.14;
  q.push(mydata1);

  data mydata2;
  strcpy(mydata2.str, "foo");
  q.push(mydata2);

  data mydata3;
  mydata3.foo.a = 1;
  mydata3.foo.c = 'a';
  q.push(mydata3);

  data mydata4;
  mydata4.bar.a = 7;
  mydata4.bar.d = 2.78;
  q.push(mydata4);

  int i = 0;
  while(!q.empty()) {
      if(i == 0) {
        std::cout << ' ' << q.front().i;
      } else if(i == 1) {
        std::cout << ' ' << q.front().f;
      } else if(i == 2) {
        std::cout << ' ' << q.front().str;
      } else if(i == 3) {
        std::cout << ' ' << q.front().foo.a << " " << q.front().foo.c;
      } else if(i == 4) {
        std::cout << ' ' << q.front().bar.a << " " << q.front().bar.d;
      } else {
        std::cout << "I do not know what the item has\n";
      }
      q.pop();
      ++i;
  }

  return 0;
}

However, consider that you can not easily use an std::string for example inside a union, either a std::tuple, thus you have to re-think if you can give a shot for the boost::variant, because as you see the code is becoming easily non-maintainable.