#include <boost/mpl/not.hpp>
#include <boost/mpl/logical.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/remove_if.hpp>
#include <boost/mpl/for_each.hpp>

#include <typeinfo>
#include <iostream>
#include <iomanip>

using namespace std;
using namespace boost;

template<class H, class M>
class has_on_method_helper {
  typedef char no_t;
  struct yes_t { char _[2]; };

  typedef void (H::*MemFn)(const M& msg);
  template<MemFn mf> struct sfinae { typedef yes_t type; };

  template<class U>
      static typename sfinae<&U::on>::type dispatch(int);

  template<class U> static no_t dispatch(...);

public:
  static const bool value = (sizeof(dispatch<H>(1)) == sizeof(yes_t));
}; // has_on_method_helper

template<class H, class M>
struct has_on_method: public mpl::bool_<has_on_method_helper<H, M>::value> { };

struct M1 { };
struct M2 { };
struct M3 { };
struct M4 { };

typedef mpl::vector<M1, M2, M3, M4> PossibleMessages;

struct HandlesM1thruM3 {
  typedef HandlesM1thruM3 this_type;
  void on(const M1&);
  void on(const M2&);
  void on(const M3&);
  typedef mpl::remove_if< PossibleMessages
                        , mpl::not_<has_on_method<this_type, mpl::_> >
                        >::type MessageList;
}; // HandlesM1thruM3

struct HandlesOnlyM2andM4 {
  typedef  HandlesOnlyM2andM4 this_type;
  void on(const M2&);
  void on(const M4&);
  typedef mpl::remove_if< PossibleMessages
                        , mpl::not_<has_on_method<this_type, mpl::_> >
                        >::type MessageList;
}; // HandlesOnlyM2andM4

struct TypePrinter {
  template<class U>
  void operator()(U) { cout << ' ' << typeid(U).name(); }
}; // TypePrinter

int main() {
  cout << "HandlesM1thruM3::MessageList=";
  mpl::for_each<HandlesM1thruM3::MessageList>(TypePrinter());
  cout << endl;

  cout << "HandlesOnlyM2andM4::MessageList=";
  mpl::for_each<HandlesOnlyM2andM4::MessageList>(TypePrinter());
  cout << endl;
} // main