overload.h

//BEGIN OVERLOAD
namespace overload
{
  namespace detail
  {
    template <typename... Args>
    struct non_const_overload
    {
      template <typename R, typename C>
      constexpr auto operator()(R (C::*ptr)(Args...)) const noexcept -> decltype(ptr)
      { return ptr; }
      
      template <typename R, typename C>
      static constexpr auto of(R (C::*ptr)(Args...)) noexcept -> decltype(ptr)
      { return ptr; }
    };
    
    template <typename... Args>
    struct const_overload
    {
      template <typename R, typename C>
      constexpr auto operator()(R (C::*ptr)(Args...) const) const noexcept -> decltype(ptr)
      { return ptr; }
      
      template <typename R, typename C>
      static constexpr auto of(R (C::*ptr)(Args...) const) noexcept -> decltype(ptr)
      { return ptr; }
    };
    
    template <typename... Args>
    struct overload : const_overload<Args...>, non_const_overload<Args...>
    {
      using const_overload<Args...>::of;
      using const_overload<Args...>::operator();
      using non_const_overload<Args...>::of;
      using non_const_overload<Args...>::operator();
      
      template <typename R>
      constexpr auto operator()(R (*ptr)(Args...)) const noexcept -> decltype(ptr)
      { return ptr; }
      
      template <typename R>
      static constexpr auto of(R (*ptr)(Args...)) noexcept -> decltype(ptr)
      { return ptr; }
    };
    template <typename R, typename C, typename... Args>
    struct non_const_overload_r_c
    {
      constexpr auto operator()(R (C::*ptr)(Args...)) const noexcept -> decltype(ptr)
      { return ptr; }
      
      static constexpr auto of(R (C::*ptr)(Args...)) noexcept -> decltype(ptr)
      { return ptr; }
    };
    
    template <typename R, typename C, typename... Args>
    struct const_overload_r_c
    {
      constexpr auto operator()(R (C::*ptr)(Args...) const) const noexcept -> decltype(ptr)
      { return ptr; }
      
      static constexpr auto of(R (C::*ptr)(Args...) const) noexcept -> decltype(ptr)
      { return ptr; }
    };
    
    template <typename R, typename C, typename... Args>
    struct overload_r_c : const_overload_r_c<R, C, Args...>, non_const_overload_r_c<R, C, Args...>
    {
      using const_overload_r_c<R, C, Args...>::of;
      using const_overload_r_c<R, C, Args...>::operator();
      using non_const_overload_r_c<R, C, Args...>::of;
      using non_const_overload_r_c<R, C, Args...>::operator();
      
      constexpr auto operator()(R (*ptr)(Args...)) const noexcept -> decltype(ptr)
      { return ptr; }
      
      static constexpr auto of(R (*ptr)(Args...)) noexcept -> decltype(ptr)
      { return ptr; }
    };
 
  }
 
  template <typename... Args> constexpr __attribute__((__unused__)) detail::overload_r_c<Args...> overload_r_c = {};
  template <typename... Args> constexpr __attribute__((__unused__)) detail::overload<Args...> overload = {};
  template <typename... Args> constexpr __attribute__((__unused__)) detail::const_overload<Args...> const_overload = {};
  template <typename... Args> constexpr __attribute__((__unused__)) detail::non_const_overload<Args...> non_const_overload = {};
}
//END OVERLOAD