Question

I can do this with a template specialization I think, for nestedness of 1,2,3 (most common cases) by respectively nesting 1,2,3 for loops and referring to the types by their typenames in stl…but for arbitrary depth, without use of the preprocessor, is there a way to do this? Maybe with mpl? Or would I need a preprocessor tool as well? Right now I am doing something like this:

template<typename T, int>
struct MapDump {};

template<typename T >
struct MapDump<T,1>
{
  static void dump(const T& map, string file, string header="")
  {
    if (!header.empty())
      cout << header << endl;

    for (typename T::const_iterator cIt = map.begin();
         cIt != map.end();
         ++cIt)
      cout << cIt->first << "," << cIt->second << endl;
  }
};

template<typename T >
struct MapDump<T,2>
{
  static void dump(const T& map, string file, string header="")
  {
    if (!header.empty())
      cout << header << endl;

    for (typename T::const_iterator it1 = map.begin();
         it1 != map.end();
         ++it1)
      for (typename T::mapped_type::const_iterator it2 = it1->second.begin();
           it2 != it1->second.end();
           ++it2)
        cout << it1->first << "," << it2->first << "," << it2->second << endl;
  }
};

which I can call with, for example:

  map<int, map<int, double> > m;
  m[1][1] = 1.0;
  m[1][2] = 1.0;
  m[2][1] = 2.0;
  m[2][2] = 2.0;

  MapDump< map<int, map<int, double> >, 2 >::dump(m, "test.csv");

(I stripped out the fstream stuff and left std::cout to simplify the sample code here) My question is, how can I go about specializing when, say, the last level mapped_type is a container type? For example map > is technically a 2-depth construct and not a one level construct…but my nest of 2 specialization wouldn’t compile for that type…any other suggestions on how to, perhaps abstract thsi further (figure out the depth of the construct at compile time as well) are welcome..thanks!

Answer 1

This performs the recursion over all nested types until it reaches a
non-nested type. It uses SFINAE to detect if there is a mapped_type
member typedef (You can use BOOST_HAS_XXX to create such a helper).

What it does not yet do is do collect the key values and pass them on
to the next level. You can either collect keys in a vector and keep
passing them down or figure out the nesting depth and use an
approximate tuple (this increases compile time complexity to n^2).

Do not use decltype and the for_each loop, if you want C++03
compatibility.

#include <map>
#include <iostream>

// sfinae to detect a mapped type
template<typename T>
struct has_mapped_type
{ 
private:
  typedef char one;
  typedef struct { char arr[2]; } two;
  template<typename U>
  struct wrap {};

  template<typename U>
  static one test(wrap<typename U::mapped_type>*);

  template<typename U>
  static two test(...);
public:
  static const bool value = sizeof(test<T>(0)) == 1;
};


template<typename T, bool has_mapped_type>
// false version
struct dump_impl {
  void operator()(const T& t) const {
    std::cout << t << std::endl;
  }
};

template<typename T>
// true version
struct dump_impl<T, true> 
  : dump_impl<
    typename T::mapped_type
    , has_mapped_type<typename T::mapped_type>::value
  > 
{
  void operator()(const T& t) const {
    for(auto& x : t) { 
      dump_impl<
        typename T::mapped_type
        , has_mapped_type<typename T::mapped_type>::value
        >::
        operator()(x.second);
    }
  }
};

template<typename T>
struct dump : public dump_impl<T, has_mapped_type<T>::value> {
  void operator()(const T& t) const {
    dump_impl<T, has_mapped_type<T>::value>::operator()(t);
  }
};

int main()
{
  std::map<int, std::map<int, double> > m;
  m[1][1] = 1.0;
  m[1][2] = 1.0;
  m[2][1] = 2.0;
  m[2][2] = 2.0;

  dump<decltype(m)>()(m);
  return 0;
}