#include <iostream>
#include <type_traits>

template <typename R, typename... T>
struct is_one_of {
  static constexpr bool value = false;
};

template <typename R, typename F, typename S, typename... T>
struct is_one_of<R, F, S, T...>
  : public std::conditional <std::is_same<F, S>::value || is_one_of<F, T...>::value, R, std::false_type >
{
  static constexpr bool value =
    std::is_same<F, S>::value || is_one_of<F, T...>::value;
};

template < typename ...Types> struct type_list {};

template <typename T>
struct message
{
  T payload;
};

struct is_ll_payload {};
struct is_ss_payload {};

struct payload_ll_1{};
struct payload_ll_2{};
using ll_payload_list = type_list< payload_ll_1, payload_ll_2 >;

struct payload_ss_1{};
struct payload_ss_2{};
using ss_payload_list = type_list < payload_ss_1, payload_ss_2 >;


struct A {
  template < typename T>
  void f_generic( const message<T>& msg, std::false_type )
  {
    std::cout << "false type\n";
  }

  template < typename T>
  void f_generic( const message<T>& msg, is_ll_payload )
  {
    std::cout << "ll payload\n";
  }

  template < typename T>
  void f_generic( const message<T>& msg, is_ss_payload )
  {
    std::cout << "ss payload\n";
  }

  template < typename T >
  void f( const message<T>& msg )
  {
    std::cout << "f\n";

    f_generic( msg, typename is_one_of< is_ll_payload, T, ll_payload_list >::type() );
    f_generic( msg, typename is_one_of< is_ss_payload, T, payload_ss_1, payload_ss_2 >::type() );
  }
};

int main()
{
  std::cout << "start\n";

  A a;

  message<payload_ll_1> msg_ll;
  message<payload_ss_1> msg_ss;

  a.f( msg_ll );
  a.f( msg_ss );

  return 0;
}