#ifndef MemberFunctionCheckerH
#define MemberFunctionCheckerH
/*-------------------------------------------------------------------------------------------------------------------------------------------
   MemberFunctionChecker.hpp
   from http://groups.google.com/group/comp.lang.c++.moderated/tree/browse_frm/thread/4f7c7a96f9afbe44/c95a7b4c645e449f#doc_e5fbc9305539f699
--------------------------------------------------------------------------------------------------------------------------------------------*/


namespace MemberFunctionChecker {

   template <typename Type>
   class has_member {
      class yes { char m;};
      class no { yes m[2];};
      struct BaseMixin { void operator()() {} };
      struct Base : public Type, public BaseMixin {};
      template <typename T, T t>  class Helper {};
      template <typename U>
      static no deduce(U*, Helper<void (BaseMixin::*)(), &U::operator()>* = 0);
      static yes deduce(...);
   public:
      static const bool result = sizeof(yes) == sizeof(deduce((Base*)(0)));
   };

   namespace details {
      template <typename type> class void_exp_result {};
      template <typename type, typename U> U const& operator,(U const&, void_exp_result<type>);
      template <typename type, typename U> U& operator,(U&, void_exp_result<type>);
      template <typename src_type, typename dest_type>
      struct clone_constness {
        typedef dest_type type;
      };
      template <typename src_type, typename dest_type>
      struct clone_constness<const src_type, dest_type> {
        typedef const dest_type type;
      };
   }

   template <typename type, typename call_details>
   struct is_call_possible {
   private:
      class yes {};
      class no { yes m[2]; };
      struct derived : public type {
        using type::operator();
        no operator()(...) const;
      };
      typedef typename details::clone_constness<type, derived>::type derived_type;
      template <typename T, typename due_type>
      struct return_value_check {
        static yes deduce(due_type);
        static no deduce(...);
      };
      template <typename T>
      struct return_value_check<T, void> {
        static yes deduce(details::void_exp_result<type>);
        static no deduce(...);
      };

      template <bool has, typename F>
      struct impl { static const bool value = false; };
      template <typename arg1, typename r>
      struct impl<true, r(arg1)> {
         static const bool value =
            sizeof(
               return_value_check<type, r>::deduce((
                        ((derived_type*)0)->operator()(*(arg1*)0),
                        details::void_exp_result<type>()))
            ) == sizeof(yes);
      };
      template <typename arg1, typename arg2, typename r>
      struct impl<true, r(arg1, arg2)> {
         static const bool value =
            sizeof(
               return_value_check<type, r>::deduce((
                        ((derived_type*)0)->operator()(*(arg1*)0, *(arg2*)0),
                        details::void_exp_result<type>()))
            ) == sizeof(yes);
      };
      template <typename arg1, typename arg2, typename arg3, typename r>
      struct impl<true, r(arg1, arg2, arg3)> {
         static const bool value =
            sizeof(
               return_value_check<type, r>::deduce(
                     (((derived_type*)0)->operator()(*(arg1*)0, *(arg2*)0, *(arg3*)0),
                        details::void_exp_result<type>()))
            ) == sizeof(yes);
      };
   public:
      static const bool value = impl<has_member<type>::result, call_details>::value;
   };

}
#endif