namespace boost{
namespace container{
namespace detail{
namespace has_member_function_callable_with {

struct dont_care
{
   dont_care(...);
};

struct private_type
{
   static private_type p;
   private_type const &operator,(int) const;
};

typedef char yes_type;      
typedef char (&no_type)[2]; 

template<typename T>
no_type is_private_type(T const &);
yes_type is_private_type(private_type const &);

}}}}  


namespace boost{
namespace container{
namespace detail{

template <typename Type>
class has_member_function_named_func
{
   struct BaseMixin
   {
      void func();
   };

   struct Base : public Type, public BaseMixin {};
   template <typename T, T t> class Helper{};

   template <typename U>
   static has_member_function_callable_with::no_type  deduce
      (U*, Helper<void (BaseMixin::*)(), &U::func>* = 0);
   static has_member_function_callable_with::yes_type deduce(...);

   public:
   static const bool value =
      sizeof(has_member_function_callable_with::yes_type) == sizeof(deduce((Base*)(0)));
};

template<typename Fun, bool HasFunc
         , class P0 = void , class P1 = void , class P2 = void>
struct has_member_function_callable_with_func_impl;


template<typename Fun , class P0 , class P1 , class P2>
struct has_member_function_callable_with_func_impl
   <Fun, false , P0 , P1 , P2>
{
   static const bool value = false;
};


}}}  

namespace boost{
namespace container{
namespace detail{


template<typename Fun>
struct funwrap1_func: Fun
{
   using Fun::func;
   has_member_function_callable_with::private_type
      func( has_member_function_callable_with::dont_care);
};

template<typename Fun , class P0>
struct has_member_function_callable_with_func_impl
   <Fun, true , P0 , void , void>
{

   static funwrap1_func<Fun> &fun;

   static P0 & p0;

   static bool const value = (sizeof(has_member_function_callable_with::no_type) ==
                              sizeof(has_member_function_callable_with::is_private_type
                                       ( (fun.func(  p0 ), 0) )
                                    )
                              );
};

}}}  

namespace boost{
namespace container{
namespace detail{


template<typename Fun>
struct funwrap2_func: Fun
{
   using Fun::func;
   has_member_function_callable_with::private_type
      func( has_member_function_callable_with::dont_care , has_member_function_callable_with::dont_care);
};

template<typename Fun , class P0 , class P1>
struct has_member_function_callable_with_func_impl
   <Fun, true , P0 , P1 , void>
{

   static funwrap2_func<Fun> &fun;

   static P0 & p0; static P1 & p1;

   static bool const value = (sizeof(has_member_function_callable_with::no_type) ==
                              sizeof(has_member_function_callable_with::is_private_type
                                       ( (fun.func(  p0 , p1 ), 0) )
                                    )
                              );
};
}}}  

namespace boost{
namespace container{
namespace detail{


template<typename Fun>
struct funwrap3_func: Fun
{
   using Fun::func;
   has_member_function_callable_with::private_type
      func( has_member_function_callable_with::dont_care
          , has_member_function_callable_with::dont_care
          , has_member_function_callable_with::dont_care);
};

template<typename Fun , class P0 , class P1 , class P2>
struct has_member_function_callable_with_func_impl
   <Fun, true , P0 , P1 , P2 >
{

   static funwrap3_func<Fun> &fun;

   static P0 & p0; static P1 & p1; static P2 & p2;

   static bool const value = (sizeof(has_member_function_callable_with::no_type) ==
                              sizeof(has_member_function_callable_with::is_private_type
                                       ( (fun.func(  p0 , p1 , p2 ), 0) )
                                    )
                              );
};

template<typename Fun, typename Arg
         , class P0 = void , class P1 = void>
struct has_member_function_callable_with_func
   : public has_member_function_callable_with_func_impl
      <Fun, has_member_function_named_func<Fun>::value, Arg
      , P0 , P1 >
{};

}}}  


struct functor
{
   void func(const int&);
   void func(const int&, const int&);
   void func(const int&, const int&, const int&);
};

struct functor2
{
   void func(char*);
   void func(int, char*);
   void func(int, char*, double);
   void func(const int&, char*, void *);
};

struct functor3
{

};

struct functor4
{
   template<class T>
   void func(int, const T &);

   template<class T>
   void func(const T &);

   template<class T, class U>
   void func(int, const T &, const U &);
};

int main()
{
   using namespace boost::container::detail;

   {
   int check1[ has_member_function_callable_with_func<functor,  int>::value   ? 1 : -1];
   int check2[!has_member_function_callable_with_func<functor,  char*>::value ? 1 : -1];
   int check3[!has_member_function_callable_with_func<functor2, int>::value   ? 1 : -1];
   int check4[ has_member_function_callable_with_func<functor2, char*>::value ? 1 : -1];
   int check5[!has_member_function_callable_with_func<functor3, int>::value   ? 1 : -1];
   int check6[!has_member_function_callable_with_func<functor3, char*>::value ? 1 : -1];
   int check7[ has_member_function_callable_with_func<functor4, int>::value ? 1 : -1];
   int check8[ has_member_function_callable_with_func<functor4, char*>::value ? 1 : -1];
   }

   {
   int check1[ has_member_function_callable_with_func<functor,  int, int>::value   ? 1 : -1];
   int check2[!has_member_function_callable_with_func<functor,  int, char*>::value ? 1 : -1];
   int check3[!has_member_function_callable_with_func<functor2, int, int>::value   ? 1 : -1];
   int check4[ has_member_function_callable_with_func<functor2, int, char*>::value ? 1 : -1];
   int check5[!has_member_function_callable_with_func<functor3, int, int>::value   ? 1 : -1];
   int check6[!has_member_function_callable_with_func<functor3, int, char*>::value ? 1 : -1];
   int check7[ has_member_function_callable_with_func<functor4, int, char*>::value ? 1 : -1];
   }

   {
    int check1[ has_member_function_callable_with_func<functor,  int, int, int>::value   ? 1 : -1];
    int check2[!has_member_function_callable_with_func<functor,  int, char*, int>::value ? 1 : -1];
    int check3[!has_member_function_callable_with_func<functor2, int, int, int>::value   ? 1 : -1];
    int check4[ has_member_function_callable_with_func<functor2, int, char*, void*>::value ? 1 : -1];
    int check5[!has_member_function_callable_with_func<functor3, int, int, int>::value   ? 1 : -1];
    int check6[!has_member_function_callable_with_func<functor3, int, char*, void*>::value ? 1 : -1];
    int check7[ has_member_function_callable_with_func<functor4, int, char*, int>::value ? 1 : -1];
   }   

   return 0;

}