How do I get the `.which()` of a particular type in a boost::variant?

Question

Say I have:

typedef boost::variant<int, float, std::string> moog;

Given an instance of moog I can get the .which() for its type, e.g.:

moog foo = ...;
foo.which(); //0 for int, 1 for float, 2 for std::string

What's the best way to get the .which() given the type itself? e.g. something like:

moog.MAGIC<int>(); // 0
moog.MAGIC<float>(); // 1
moog.MAGIC<std::string>(); // 2

I figure I can instantiate a moog and do it that way (untested, example only):

template <class Variant, class Which>
size_t MAGIC() {
    Which w;
    Variant foo = w;
    return foo.which(); 
}

MAGIC<moog, int>(); // 0
MAGIC<moog, float>(); // 1
MAGIC<moog, std::string>(); // 2

However, this is clunky as it requires instantiating two objects. It also won't work for classes without a default constructor.

Answer 1

If you can use C++11:

template <std::size_t, typename, typename...> struct find_;

template <std::size_t pos, typename T, typename Other, typename... Args>
struct find_<pos, T, Other, Args...> : find_<pos+1, T, Args...> {};
template <std::size_t pos, typename T, typename... Args>
struct find_<pos, T, T, Args...> : std::integral_constant<std::size_t, pos> {};
template <std::size_t pos, typename T>
struct find_<pos, T> : std::integral_constant<std::size_t, std::size_t(-1)> {};

template <typename T, typename... Args>
using find = find_<0, T, Args...>;

template <typename, typename> struct IndexInVariant;

template <typename T, typename... Types>
struct IndexInVariant<boost::variant<Types...>, T> :
    find<typename std::remove_cv<T>::type, Types...> {};

Usage:

IndexInVariant< boost::variant<int, float, std::string>, std::string >::value // 2

IndexInVariant< boost::variant<int, float, std::string>, char >::value // -1

Demo.

Answer 2

Since you're already using boost you might as well use boost::mpl

#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/distance.hpp>
#include <boost/mpl/find.hpp>

template <class Variant, class Which>
size_t MAGIC()
{
  return boost::mpl::distance
         <typename boost::mpl::begin<typename Variant::types>::type,
          typename boost::mpl::find<typename Variant::types, Which>::type
         >::type::value;
}

---

Edit

P0W proposed a version that returns -1 if the type is not found instead of the last index of the typessequence which is obviously a better thing:

template <class Variant, class Which>
int MAGIC()
{
  size_t pos = boost::mpl::distance
         <typename boost::mpl::begin<typename Variant::types>::type,
          typename boost::mpl::find<typename Variant::types, Which>::type
         >::type::value ;

  size_t last= boost::mpl::distance
         <typename boost::mpl::begin<typename Variant::types>::type,
          typename boost::mpl::end<typename Variant::types>::type
         >::type::value;

         return pos != last ? pos : -1 ;
}