Move to template type deduction for function signature

include/chaiscript/dispatchkit/callable_traits.hpp

@@ -1,107 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-#ifndef CHAISCRIPT_CALLABLE_TRAITS_HPP_
-#define CHAISCRIPT_CALLABLE_TRAITS_HPP_
-
-#include <memory>
-
-namespace chaiscript {
-  namespace dispatch {
-    namespace detail {
-
-      template<typename Class, typename ... Param>
-      struct Constructor
-      {
-        template<typename ... Inner>
-        constexpr Class operator()(Inner&& ... inner) const {
-          return Class(std::forward<Inner>(inner)...);
-        }
-      };
-
-      template<typename Ret, typename Class, typename ... Param>
-      struct Const_Caller
-      {
-        constexpr explicit Const_Caller(Ret (Class::*t_func)(Param...) const) : m_func(t_func) {}
-
-        template<typename ... Inner>
-        constexpr Ret operator()(const Class &o, Inner&& ... inner) const {
-          return (o.*m_func)(std::forward<Inner>(inner)...);
-        }
-
-        Ret (Class::*m_func)(Param...) const;
-      };
-
-      template<typename Ret, typename ... Param>
-      struct Fun_Caller
-      {
-        constexpr explicit Fun_Caller(Ret( * t_func)(Param...) ) : m_func(t_func) {}
-
-        template<typename ... Inner>
-        constexpr Ret operator()(Inner&& ... inner) const {
-          return (m_func)(std::forward<Inner>(inner)...);
-        }
-
-        Ret(*m_func)(Param...);
-      };
-
-      template<typename Ret, typename Class, typename ... Param>
-      struct Caller
-      {
-        constexpr explicit Caller(Ret (Class::*t_func)(Param...)) : m_func(t_func) {}
-
-        template<typename ... Inner>
-        constexpr Ret operator()(Class &o, Inner&& ... inner) const {
-          return (o.*m_func)(std::forward<Inner>(inner)...);
-        }
-
-        Ret (Class::*m_func)(Param...);
-      };
-
-      template<typename T>
-        struct Arity
-        {
-        };
-
-      template<typename Ret, typename ... Params>
-      struct Arity<Ret (Params...)>
-        {
-          static const size_t arity = sizeof...(Params);
-        };
-
-
-      template<typename T>
-        struct Function_Signature
-        {
-        };
-
-      template<typename Ret, typename ... Params>
-      struct Function_Signature<Ret (Params...)>
-        {
-          typedef Ret Return_Type;
-          typedef Ret (Signature)(Params...);
-        };
-
-      template<typename Ret, typename T, typename ... Params>
-      struct Function_Signature<Ret (T::*)(Params...) const>
-        {
-          typedef Ret Return_Type;
-          typedef Ret (Signature)(Params...);
-        };
-
-
-      template<typename T>
-        struct Callable_Traits
-        {
-          typedef typename Function_Signature<decltype(&T::operator())>::Signature Signature;
-          typedef typename Function_Signature<decltype(&T::operator())>::Return_Type Return_Type;
-        };
-    }
-  }
-}
-
-#endif
-

include/chaiscript/dispatchkit/function_call.hpp

@@ -18,7 +18,6 @@
 #include "boxed_cast.hpp"
 #include "function_call_detail.hpp"
 #include "proxy_functions.hpp"
-#include "callable_traits.hpp"
 
 namespace chaiscript {
 class Boxed_Value;
@@ -32,6 +31,15 @@ namespace chaiscript
 {
   namespace dispatch
   {
+    namespace detail
+    {
+      template<typename Ret, typename ... Param>
+        constexpr auto arity(Ret (*)(Param...)) noexcept
+      {
+        return sizeof...(Param);
+      }
+    }
+
     /// Build a function caller that knows how to dispatch on a set of functions
     /// example:
     /// std::function<void (int)> f =
@@ -43,7 +51,7 @@ namespace chaiscript
       {
         const bool has_arity_match = std::any_of(funcs.begin(), funcs.end(),
             [](const Const_Proxy_Function &f) {
-              return f->get_arity() == -1 || size_t(f->get_arity()) == chaiscript::dispatch::detail::Arity<FunctionType>::arity;
+              return f->get_arity() == -1 || size_t(f->get_arity()) == detail::arity(static_cast<FunctionType *>(nullptr));
             });
 
         if (!has_arity_match) {

include/chaiscript/dispatchkit/function_signature.hpp

@@ -0,0 +1,124 @@
+#ifndef CHAISCRIPT_FUNCTION_SIGNATURE_HPP
+#define CHAISCRIPT_FUNCTION_SIGNATURE_HPP
+
+#include <type_traits>
+
+namespace chaiscript::dispatch::detail {
+  template<typename ... Param>
+    struct Function_Params
+    {
+    };
+
+  template<typename Ret, typename Params, bool IsNoExcept = false, bool IsMember = false, bool IsMemberObject = false, bool IsObject = false>
+    struct Function_Signature {
+      using Param_Types = Params;
+      using Return_Type = Ret;
+      constexpr static const bool is_object = IsObject;
+      constexpr static const bool is_member_object = IsMemberObject;
+      constexpr static const bool is_noexcept = IsNoExcept;
+      template<typename T>
+        constexpr Function_Signature(T &&) noexcept {}
+      constexpr Function_Signature() noexcept = default;
+    };
+
+  // Free functions
+
+  template<typename Ret, typename ... Param>
+    Function_Signature(Ret (*f)(Param...)) -> Function_Signature<Ret, Function_Params<Param...>>;
+
+  template<typename Ret, typename ... Param>
+    Function_Signature(Ret (*f)(Param...) noexcept) -> Function_Signature<Ret, Function_Params<Param...>, true>;
+
+  // no reference specifier
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) volatile) -> Function_Signature<Ret, Function_Params<volatile Class &, Param...>, false, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) volatile noexcept) -> Function_Signature<Ret, Function_Params<volatile Class &, Param...>, true, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) volatile const) -> Function_Signature<Ret, Function_Params<volatile const Class &, Param...>, false, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) volatile const noexcept) -> Function_Signature<Ret, Function_Params<volatile const Class &, Param...>, true, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) ) -> Function_Signature<Ret, Function_Params<Class &, Param...>, false, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) noexcept) -> Function_Signature<Ret, Function_Params<Class &, Param...>, true, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) const) -> Function_Signature<Ret, Function_Params<const Class &, Param...>, false, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) const noexcept) -> Function_Signature<Ret, Function_Params<const Class &, Param...>, true, true>;
+
+  // & reference specifier
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) volatile &) -> Function_Signature<Ret, Function_Params<volatile Class &, Param...>, false, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) volatile & noexcept) -> Function_Signature<Ret, Function_Params<volatile Class &, Param...>, true, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) volatile const &) -> Function_Signature<Ret, Function_Params<volatile const Class &, Param...>, false, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) volatile const & noexcept) -> Function_Signature<Ret, Function_Params<volatile const Class &, Param...>, true, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) & ) -> Function_Signature<Ret, Function_Params<Class &, Param...>, false, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) & noexcept) -> Function_Signature<Ret, Function_Params<Class &, Param...>, true, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) const &) -> Function_Signature<Ret, Function_Params<const Class &, Param...>, false, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) const & noexcept) -> Function_Signature<Ret, Function_Params<const Class &, Param...>, true, true>;
+
+  // && reference specifier
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) volatile &&) -> Function_Signature<Ret, Function_Params<volatile Class &&, Param...>, false, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) volatile && noexcept) -> Function_Signature<Ret, Function_Params<volatile Class &&, Param...>, true, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) volatile const &&) -> Function_Signature<Ret, Function_Params<volatile const Class &&, Param...>, false, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) volatile const && noexcept) -> Function_Signature<Ret, Function_Params<volatile const Class &&, Param...>, true, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) &&) -> Function_Signature<Ret, Function_Params<Class &&, Param...>, false, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) && noexcept) -> Function_Signature<Ret, Function_Params<Class &&, Param...>, true, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) const &&) -> Function_Signature<Ret, Function_Params<const Class &&, Param...>, false, true>;
+
+  template<typename Ret, typename Class, typename ... Param>
+    Function_Signature(Ret (Class::*f)(Param ...) const && noexcept) -> Function_Signature<Ret, Function_Params<const Class &&, Param...>, true, true>;
+
+  template<typename Ret, typename Class>
+    Function_Signature(Ret (Class::*f)) -> Function_Signature<Ret, Function_Params<Class &>, true, true, true>;
+
+  template<typename Func>
+    Function_Signature(Func &&) -> Function_Signature<
+    typename decltype(Function_Signature{&std::decay_t<Func>::operator()})::Return_Type,
+             typename decltype(Function_Signature{&std::decay_t<Func>::operator()})::Param_Types,
+             decltype(Function_Signature{&std::decay_t<Func>::operator()})::is_noexcept,
+             false,
+             false,
+             true
+               >;
+}
+
+#endif

include/chaiscript/dispatchkit/proxy_constructors.hpp

@@ -19,11 +19,12 @@ namespace chaiscript
   {
     namespace detail
     {
-
       template<typename Class, typename ... Params  >
         Proxy_Function build_constructor_(Class (*)(Params...))
         {
-          auto call = dispatch::detail::Constructor<Class, Params...>();
+          auto call = [](auto && ... param){
+            return Class(std::forward<decltype(param)>(param)...);
+          };
 
           return Proxy_Function(
             chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Class (Params...), decltype(call)>>(call));

include/chaiscript/dispatchkit/proxy_functions.hpp

@@ -664,7 +664,7 @@ namespace chaiscript
       protected:
         Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions) const override
         {
-          return detail::call_func(detail::Function_Signature<Func>(), m_f, params, t_conversions);
+          return detail::call_func(static_cast<Func *>(nullptr), m_f, params, t_conversions);
         }
 
       private:
@@ -716,7 +716,7 @@ namespace chaiscript
       protected:
         Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions) const override
         {
-          return detail::call_func(detail::Function_Signature<Func>(), m_f.get(), params, t_conversions);
+          return detail::call_func(static_cast<Func *>(nullptr), m_f.get(), params, t_conversions);
         }
 
 

include/chaiscript/dispatchkit/proxy_functions_detail.hpp

@@ -21,7 +21,6 @@
 #include "boxed_value.hpp"
 #include "handle_return.hpp"
 #include "type_info.hpp"
-#include "callable_traits.hpp"
 
 namespace chaiscript {
 class Type_Conversions_State;
@@ -91,7 +90,7 @@ namespace chaiscript
 
 
       template<typename Callable, typename Ret, typename ... Params, size_t ... I>
-        Ret call_func(const chaiscript::dispatch::detail::Function_Signature<Ret (Params...)> &, 
+        Ret call_func(Ret (*)(Params...), 
                       std::index_sequence<I...>, const Callable &f,
                       const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions)
         {
@@ -105,7 +104,7 @@ namespace chaiscript
       /// if any unboxing fails the execution of the function fails and
       /// the bad_boxed_cast is passed up to the caller.
       template<typename Callable, typename Ret, typename ... Params>
-        Boxed_Value call_func(const chaiscript::dispatch::detail::Function_Signature<Ret (Params...)> &sig, const Callable &f,
+        Boxed_Value call_func(Ret (*sig)(Params...), const Callable &f,
             const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions)
         {
           if constexpr (std::is_same_v<Ret, void>) {

include/chaiscript/dispatchkit/register_function.hpp

@@ -15,9 +15,54 @@
 
 #include "bind_first.hpp"
 #include "proxy_functions.hpp"
+#include "function_signature.hpp"
 
 namespace chaiscript
 {
+  namespace dispatch::detail
+  {
+    template<typename Obj, typename Param1, typename ... Rest>
+      Param1 get_first_param(Function_Params<Param1, Rest...>, Obj &&obj)
+      {
+        return static_cast<Param1>(std::forward<Obj>(obj));
+      }
+
+    template<typename Func, bool Is_Noexcept, bool Is_Member, bool Is_MemberObject, bool Is_Object, typename Ret, typename ... Param>
+      auto make_callable_impl(Func &&func, Function_Signature<Ret, Function_Params<Param...>, Is_Noexcept, Is_Member, Is_MemberObject, Is_Object>)
+      {
+        if constexpr (Is_MemberObject) {
+          // we now that the Param pack will have only one element, so we are safe expanding it here
+          return Proxy_Function(chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Attribute_Access<Ret, std::decay_t<Param>...>>(std::forward<Func>(func)));
+        } else if constexpr (Is_Member) {
+          auto call = [func = std::forward<Func>(func)](auto && obj, auto && ... param) noexcept(Is_Noexcept) -> decltype(auto) {
+            return (( get_first_param(Function_Params<Param...>{}, obj).*func )(std::forward<decltype(param)>(param)...));
+          };
+          return Proxy_Function(
+              chaiscript::make_shared<dispatch::Proxy_Function_Base, 
+              dispatch::Proxy_Function_Callable_Impl<Ret (Param...), decltype(call)>>(std::move(call))
+              );
+        } else {
+          return Proxy_Function(
+              chaiscript::make_shared<dispatch::Proxy_Function_Base, 
+              dispatch::Proxy_Function_Callable_Impl<Ret (Param...), std::decay_t<Func>>>(std::forward<Func>(func))
+              );
+        }
+      }
+
+    // this version peels off the function object itself from the function signature, when used
+    // on a callable object
+    template<typename Func, typename Ret, typename Object, typename ... Param, bool Is_Noexcept>
+      auto make_callable(Func &&func, Function_Signature<Ret, Function_Params<Object, Param...>, Is_Noexcept, false, false, true>)
+      {
+        return make_callable_impl(std::forward<Func>(func), Function_Signature<Ret, Function_Params<Param...>, Is_Noexcept, false, false, true>{});
+      } 
+
+    template<typename Func, typename Ret, typename ... Param, bool Is_Noexcept, bool Is_Member, bool Is_MemberObject>
+      auto make_callable(Func &&func, Function_Signature<Ret, Function_Params<Param...>, Is_Noexcept, Is_Member, Is_MemberObject, false> fs)
+      {
+        return make_callable_impl(std::forward<Func>(func), fs);
+      }
+  }
 
   /// \brief Creates a new Proxy_Function object from a free function, member function or data member
   /// \param[in] t Function / member to expose
@@ -40,85 +85,12 @@ namespace chaiscript
   /// 
   /// \sa \ref adding_functions
   template<typename T>
-    Proxy_Function fun(const T &t)
+    Proxy_Function fun(T &&t)
     {
-      typedef typename dispatch::detail::Callable_Traits<T>::Signature Signature;
+      return dispatch::detail::make_callable(std::forward<T>(t), dispatch::detail::Function_Signature{t});
-
-      return Proxy_Function(
-          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Signature, T>>(t));
     }
 
 
-  template<typename Ret, typename ... Param>
-    Proxy_Function fun(Ret (*func)(Param...))
-    {
-      auto fun_call = dispatch::detail::Fun_Caller<Ret, Param...>(func);
-
-      return Proxy_Function(
-          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret (Param...), decltype(fun_call)>>(fun_call));
-
-    }
-
-  template<typename Ret, typename Class, typename ... Param>
-    Proxy_Function fun(Ret (Class::*t_func)(Param...) const)
-    {
-      auto call = dispatch::detail::Const_Caller<Ret, Class, Param...>(t_func);
-
-      return Proxy_Function(
-          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret (const Class &, Param...), decltype(call)>>(call));
-    }
-
-  template<typename Ret, typename Class, typename ... Param>
-    Proxy_Function fun(Ret (Class::*t_func)(Param...))
-    {
-      auto call = dispatch::detail::Caller<Ret, Class, Param...>(t_func);
-
-      return Proxy_Function(
-          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret (Class &, Param...), decltype(call)>>(call));
-
-    }
-
-  template<typename T, typename Class /*, typename = typename std::enable_if<std::is_member_object_pointer<T>::value>::type*/>
-    Proxy_Function fun(T Class::* m /*, typename std::enable_if<std::is_member_object_pointer<T>::value>::type* = 0*/ )
-    {
-      return Proxy_Function(chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Attribute_Access<T, Class>>(m));
-    }
-
-// only compile this bit if noexcept is part of the type system
-//
-#if __cpp_noexcept_function_type >= 201510
-  template<typename Ret, typename ... Param>
-    Proxy_Function fun(Ret (*func)(Param...) noexcept)
-    {
-      auto fun_call = dispatch::detail::Fun_Caller<Ret, Param...>(func);
-
-      return Proxy_Function(
-          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret (Param...), decltype(fun_call)>>(fun_call));
-
-    }
-
-  template<typename Ret, typename Class, typename ... Param>
-    Proxy_Function fun(Ret (Class::*t_func)(Param...) const noexcept)
-    {
-      auto call = dispatch::detail::Const_Caller<Ret, Class, Param...>(t_func);
-
-      return Proxy_Function(
-          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret (const Class &, Param...), decltype(call)>>(call));
-    }
-
-  template<typename Ret, typename Class, typename ... Param>
-    Proxy_Function fun(Ret (Class::*t_func)(Param...) noexcept)
-    {
-      auto call = dispatch::detail::Caller<Ret, Class, Param...>(t_func);
-
-      return Proxy_Function(
-          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret (Class &, Param...), decltype(call)>>(call));
-
-    }
-#endif
-
-
-
   
   /// \brief Creates a new Proxy_Function object from a free function, member function or data member and binds the first parameter of it
   /// \param[in] t Function / member to expose
@@ -145,6 +117,7 @@ namespace chaiscript
     }
 
 
+
 }