Template recursion differentiating between datatypes in a boot::tuple

Question

Problem: I need a functional object of A to recurse for data types of boost::tuple but do something else for all other data types of the incoming member t.

class A{
public:
    template<typename T>
    void operator()(T& t) const{
//      if (t == tuple){
//          recurse
//      } else{
//          doSomething
//      }
    }
};

class B{
    void init(){
        boost::tuple<int, float> a;
        boost::tuple< boost::tuple<int, std::string>, float > b;

        boost::fusion::for_each(a, A());
        boost::fusion::for_each(b, A());
    }
};

What I tried was setting up static functions for all possible incoming data types above the declaration of A but than I was not able to get back into the recursive function, because those statics did not know class A. My second approach was to implement static functions for all possible data types returning true for boost::tuple and false for any other (pretty much like in the example). But than I couldn't implement a for_each call, because (even though it was wrapped by the if case) my IDE says there was no matching function call (which is true for types of int, float and string).

Answer 1

If I understood your question correctly, you could just provide two overloads of the call operator, one which accepts instantiations of boost::tuple and would call boost::fusion::for_each() on that tuple, and another fallback one that would accept any kind of argument, and perform concrete operations on "leaf" types:

class A
{
public:
    template<typename T>
    void operator()(T& t) const
    {
        // Do something
    }

    template<typename... Ts>
    void operator ()(boost::tuple<Ts...>& t) const
    {
        // Recurse
        boost::fusion::for_each(t, A());
    }
};

In the above example I am using C++11's variadic templates, so you will need a C++11-compliant compiler for that to work (and don't forget to specify the flag -std=c++11 or -std=c++0x in the command line).