Merge pull request #27 from ThePhD/master

Adding std::function functionality for easier interop, interop with regular C++ classes at C++/lua boundary
2024-03-22 13:10:44 +08:00 · 2014-05-30 21:02:33 -04:00 · 2014-05-30 21:02:33 -04:00 · 56c6d41134
commit 56c6d41134
parent 089b075317 0315a43b1b
10 changed files with 199 additions and 64 deletions
--- a/sol/demangle.hpp
+++ b/sol/demangle.hpp
@ -33,9 +33,26 @@ namespace sol {
 namespace detail {
 #ifdef _MSC_VER
 std::string demangle(const std::type_info& id) {
+    return id.name();
+}
+
+#elif defined(__GNUC__) || defined(__clang__)
+std::string demangle(const std::type_info& id) {
+    int status;
+    char* unmangled = abi::__cxa_demangle(id.name(), 0, 0, &status);
+    std::string realname = unmangled;
+    free(unmangled);
+    return realname;
+}
+
+#else
+#error Compiler not supported for demangling
+#endif // compilers
+
+std::string lua_demangle(const std::type_info& id) {
+    std::string realname = demangle(id);
    const static std::array<std::string, 2> removals = { "struct ", "class " };
    const static std::array<std::string, 2> replacements = { "::", "_" };
-    std::string realname = id.name();
    for(std::size_t r = 0; r < removals.size(); ++r) {
        auto found = realname.find(removals[r]);
        while (found != std::string::npos) {
@ -52,19 +69,6 @@ std::string demangle(const std::type_info& id) {
    }
    return realname;
 }
-
-#elif defined(__GNUC__) || defined(__clang__)
-std::string demangle(const std::type_info& id) {
-    int status;
-    char* unmangled = abi::__cxa_demangle(id.name(), 0, 0, &status);
-    std::string realname = unmangled;
-    free(unmangled);
-    return realname;
-}
-
-#else
-#error Compiler not supported for demangling
-#endif // compilers
 } // detail
 } // sol

--- a/sol/function.hpp
+++ b/sol/function.hpp
@ -26,31 +26,32 @@
 #include "tuple.hpp"
 #include "stack.hpp"
 #include <cstdint>
+#include <functional>

 namespace sol {
 class function : public reference {
 private:
-    void luacall (std::size_t argcount, std::size_t resultcount) {
+    void luacall (std::size_t argcount, std::size_t resultcount) const {
        lua_call(state(), static_cast<uint32_t>(argcount), static_cast<uint32_t>(resultcount));
    }

    template<typename... Ret>
-    std::tuple<Ret...> invoke(types<Ret...>, std::size_t n) {
+    std::tuple<Ret...> invoke(types<Ret...>, std::size_t n) const {
        luacall(n, sizeof...(Ret));
        return stack::pop_reverse_call(state(), std::make_tuple<Ret...>, types<Ret...>());
    }

    template<typename Ret>
-    Ret invoke(types<Ret>, std::size_t n) {
+    Ret invoke(types<Ret>, std::size_t n) const {
        luacall(n, 1);
        return stack::pop<Ret>(state());
    }

-    void invoke(types<void>, std::size_t n) {
+    void invoke(types<void>, std::size_t n) const {
        luacall(n, 0);
    }

-    void invoke(types<>, std::size_t n) {
+    void invoke(types<>, std::size_t n) const {
        luacall(n, 0);
    }

@ -63,22 +64,58 @@ public:
    function& operator=(const function&) = default;

    template<typename... Args>
-    void operator()(Args&&... args) {
+    void operator()(Args&&... args) const {
        call<>(std::forward<Args>(args)...);
    }

    template<typename... Ret, typename... Args>
-    typename return_type<Ret...>::type operator()(types<Ret...>, Args&&... args) {
+    typename return_type<Ret...>::type operator()(types<Ret...>, Args&&... args) const {
        return call<Ret...>(std::forward<Args>(args)...);
    }

    template<typename... Ret, typename... Args>
-    typename return_type<Ret...>::type call(Args&&... args) {
+    typename return_type<Ret...>::type call(Args&&... args) const {
        push();
        stack::push_args(state(), std::forward<Args>(args)...);
        return invoke(types<Ret...>(), sizeof...(Args));
    }
 };
+
+namespace stack {
+namespace detail {
+template <typename Signature, typename... FxArgs, typename... Ret>
+inline std::function<Signature> get_std_func(types<FxArgs...>, types<Ret...>, lua_State* L, int index = -1) {
+    typedef typename function_traits<Signature>::return_type return_t;
+    sol::function f(L, index);
+    auto fx = [ f, L, index ] (FxArgs&&... args) -> return_t {
+        return f(types<Ret...>(), std::forward<FxArgs>(args)...);
+    };
+    return std::move(fx);
+}
+
+template <typename Signature, typename... FxArgs>
+inline std::function<Signature> get_std_func(types<FxArgs...>, types<void>, lua_State* L, int index = -1) {
+    sol::function f(L, index);
+    auto fx = [ f, L, index ] (FxArgs&&... args) -> void {
+        f(std::forward<FxArgs>(args)...);
+    };
+    return std::move(fx);
+}
+
+template <typename Signature, typename... FxArgs>
+inline std::function<Signature> get_std_func(types<FxArgs...> t, types<>, lua_State* L, int index = -1) {
+    return get_std_func<Signature>(std::move(t), types<void>(), L, index);
+}
+
+template <typename Signature>
+inline std::function<Signature> get(types<std::function<Signature>>, lua_State* L, int index = -1) {
+    typedef typename function_traits<Signature> fx_t;
+    typedef typename fx_t::args_type args_t;
+    typedef typename tuple_types<typename fx_t::return_type>::type ret_t;
+    return get_std_func<Signature>(args_t(), ret_t(), L, index);
+}
+} // detail
+} // stack
 } // sol

 #endif // SOL_FUNCTION_HPP
--- a/sol/function_types.hpp
+++ b/sol/function_types.hpp
@ -34,7 +34,9 @@ struct static_function {

    template<typename... Args>
    static int typed_call(types<void>, types<Args...> t, function_type* fx, lua_State* L) {
-        stack::pop_call(L, fx, t);
+        stack::get_call(L, fx, t);
+        std::ptrdiff_t nargs = sizeof...(Args);
+        lua_pop(L, nargs);
        return 0;
    }

@ -46,7 +48,9 @@ struct static_function {
    template<typename... Ret, typename... Args>
    static int typed_call(types<Ret...>, types<Args...> t, function_type* fx, lua_State* L) {
        typedef typename return_type<Ret...>::type return_type;
-        return_type r = stack::pop_call(L, fx, t);
+        return_type r = stack::get_call(L, fx, t);
+        std::ptrdiff_t nargs = sizeof...(Args);
+        lua_pop(L, nargs);
        stack::push(L, std::move(r));
        return sizeof...(Ret);
    }
@ -71,7 +75,9 @@ struct static_member_function {
    template<typename... Args>
    static int typed_call(types<void>, types<Args...>, T& item, function_type& ifx, lua_State* L) {
        auto fx = [&item, &ifx](Args&&... args) -> void { (item.*ifx)(std::forward<Args>(args)...); };
-        stack::pop_call(L, fx, types<Args...>());
+        stack::get_call(L, fx, types<Args...>());
+        std::ptrdiff_t nargs = sizeof...(Args);
+        lua_pop(L, nargs);
        return 0;
    }

@ -84,7 +90,9 @@ struct static_member_function {
    static int typed_call(types<Ret...>, types<Args...>, T& item, function_type& ifx, lua_State* L) {
        typedef typename return_type<Ret...>::type return_type;
        auto fx = [&item, &ifx](Args&&... args) -> return_type { return (item.*ifx)(std::forward<Args>(args)...); };
-        return_type r = stack::pop_call(L, fx, types<Args...>());
+        return_type r = stack::get_call(L, fx, types<Args...>());
+        std::ptrdiff_t nargs = sizeof...(Args);
+        lua_pop(L, nargs);
        stack::push(L, std::move(r));
        return sizeof...(Ret);
    }
@ -162,7 +170,9 @@ struct functor_function : public base_function {

    template<typename... Args>
    int operator()(types<void>, types<Args...> t, lua_State* L) {
-        stack::pop_call(L, fx, t);
+        stack::get_call(L, fx, t);
+        std::ptrdiff_t nargs = sizeof...(Args);
+        lua_pop(L, nargs);
        return 0;
    }

@ -174,7 +184,9 @@ struct functor_function : public base_function {
    template<typename... Ret, typename... Args>
    int operator()(types<Ret...>, types<Args...> t, lua_State* L) {
        typedef typename return_type<Ret...>::type return_type;
-        return_type r = stack::pop_call(L, fx, t);
+        return_type r = stack::get_call(L, fx, t);
+        std::ptrdiff_t nargs = sizeof...(Args);
+        lua_pop(L, nargs);
        stack::push(L, r);
        return sizeof...(Ret);
    }
@ -206,7 +218,7 @@ struct member_function : public base_function {

    template<typename... Args>
    int operator()(types<void>, types<Args...> t, lua_State* L) {
-        stack::pop_call(L, fx, t);
+        stack::get_call(L, fx, t);
        return 0;
    }

@ -218,7 +230,9 @@ struct member_function : public base_function {
    template<typename... Ret, typename... Args>
    int operator()(types<Ret...>, types<Args...> t, lua_State* L) {
        typedef typename return_type<Ret...>::type return_type;
-        return_type r = stack::pop_call(L, fx, t);
+        return_type r = stack::get_call(L, fx, t);
+        std::ptrdiff_t nargs = sizeof...(Args);
+        lua_pop(L, nargs);
        stack::push(L, std::move(r));
        return sizeof...(Ret);
    }
@ -256,18 +270,6 @@ struct userdata_function : public base_function {
    template<typename... FxArgs>
    userdata_function(FxArgs&&... fxargs): fx(std::forward<FxArgs>(fxargs)...) {}

-    template<typename... Args>
-    int operator()(types<void>, types<Args...> t, lua_State* L) {
-        stack::pop_call(L, fx, t);
-        return 0;
-    }
-
-    template<typename... Args>
-    int operator()(types<>, types<Args...> t, lua_State* L) {
-        return (*this)(types<void>(), t, L);
-    }
-
-
    template<typename Return, typename Raw = Unqualified<Return>>
    typename std::enable_if<std::is_same<T, Raw>::value, void>::type special_push(lua_State*, Return&&) {
        // push nothing
@ -278,15 +280,30 @@ struct userdata_function : public base_function {
        stack::push(L, std::forward<Return>(r));
    }

+    template<typename... Args>
+    int operator()(types<void>, types<Args...> t, lua_State* L) {
+        stack::get_call(L, 2, fx, t);
+        std::ptrdiff_t nargs = sizeof...(Args);
+        lua_pop(L, nargs);
+        return 0;
+    }
+
    template<typename... Ret, typename... Args>
    int operator()(types<Ret...>, types<Args...> t, lua_State* L) {
        typedef typename return_type<Ret...>::type return_type;
-        return_type r = stack::pop_call(L, fx, t);
+        return_type r = stack::get_call(L, 2, fx, t);
+        std::ptrdiff_t nargs = sizeof...(Args);
+        lua_pop(L, nargs);
        // stack::push(L, std::move(r));
        special_push(L, r);
        return sizeof...(Ret);
    }

+    template<typename... Args>
+    int operator()(types<>, types<Args...> t, lua_State* L) {
+        return (*this)(types<void>(), t, L);
+    }
+
    virtual int operator()(lua_State* L) override {
        fx.prepare(L);
        return (*this)(tuple_types<typename traits_type::return_type>(), typename traits_type::args_type(), L);
--- a/sol/stack.hpp
+++ b/sol/stack.hpp
@ -61,16 +61,21 @@ inline type get(types<type>, lua_State* L, int index = -1) {
    return static_cast<type>(lua_type(L, index));
 }

+template <typename T, typename U = typename std::remove_reference<T>::type>
+inline U get_sol_type(std::true_type, types<T>, lua_State* L, int index = -1) {
+    return U(L, index);
+}
+
 template <typename T>
-inline T& get(types<userdata<T>>, lua_State* L, int index = -1) {
+inline T& get_sol_type(std::false_type, types<T>, lua_State* L, int index = -1) {
    userdata_t udata = get(types<userdata_t>{}, L, index);
    T* obj = static_cast<T*>(udata.value);
    return *obj;
 }

-template <typename T, typename U = typename std::remove_reference<T>::type>
-inline U get(types<T>, lua_State* L, int index = -1) {
-    return U(L, index);
+template <typename T, typename U = Unqualified<T>>
+inline auto get(types<T> t, lua_State* L, int index = -1) -> decltype(get_sol_type(std::is_base_of<sol::reference, U>(), t, L, index)) {
+    return get_sol_type(std::is_base_of<sol::reference, U>(), t, L, index);
 }

 template<typename T>
@ -298,6 +303,11 @@ inline auto get_call(lua_State* L, int index, TFx&& fx, types<Args...> t) -> dec
    return detail::ltr_get(L, index, std::forward<TFx>(fx), t, t);
 }

+template<typename... Args, typename TFx>
+inline auto get_call(lua_State* L, TFx&& fx, types<Args...> t) -> decltype(detail::ltr_get(L, 1, std::forward<TFx>(fx), t, t)) {
+    return detail::ltr_get(L, 1, std::forward<TFx>(fx), t, t);
+}
+
 template<typename... Args, typename TFx>
 inline auto pop_call(lua_State* L, TFx&& fx, types<Args...> t) -> decltype(detail::ltr_pop(L, std::forward<TFx>(fx), t, t)) {
    return detail::ltr_pop(L, std::forward<TFx>(fx), t, t);
--- a/sol/state.hpp
+++ b/sol/state.hpp
@ -28,12 +28,6 @@

 namespace sol {
 namespace detail {
-template<class T, class...>
-struct are_same : std::true_type {};
-
-template<class T, class U, class... Args>
-struct are_same<T, U, Args...> : std::integral_constant<bool, std::is_same<T, U>::value && are_same<T, Args...>::value> {};
-
 inline int atpanic(lua_State* L) {
    std::string err = lua_tostring(L, -1);
    throw error(err);
@ -70,7 +64,7 @@ public:

    template<typename... Args>
    void open_libraries(Args&&... args) {
-        static_assert(detail::are_same<lib, Args...>::value, "all types must be libraries");
+        static_assert(are_same<lib, Args...>::value, "all types must be libraries");
        if(sizeof...(args) == 0) {
            luaL_openlibs(L.get());
            return;
--- a/sol/traits.hpp
+++ b/sol/traits.hpp
@ -26,6 +26,12 @@
 #include <type_traits>

 namespace sol {
+template<class T, class...>
+struct are_same : std::true_type { };
+
+template<class T, class U, class... Args>
+struct are_same<T, U, Args...> : std::integral_constant <bool, std::is_same<T, U>::value && are_same<T, Args...>::value> { };
+
 template<typename T, typename R = void>
 using EnableIf = typename std::enable_if<T::value, R>::type;

@ -53,6 +59,12 @@ struct return_type<> : types<>{
    typedef void type;
 };

+template<typename... Args>
+struct is_tuple : std::false_type{ };
+
+template<typename... Args>
+struct is_tuple<std::tuple<Args...>> : std::true_type{ };
+
 template <typename T, template <typename...> class Templ>
 struct is_specialization_of : std::false_type { };
 template <typename... T, template <typename...> class Templ>
--- a/sol/tuple.hpp
+++ b/sol/tuple.hpp
@ -69,10 +69,10 @@ template<typename... Args>
 struct reversed : reversed_<types<>, Args...>{};

 template<typename... Args>
-struct tuple_types : types<Args...>, std::false_type {};
+struct tuple_types : types<Args...> {};

 template<typename... Args>
-struct tuple_types<std::tuple<Args...>> : types<Args...>, std::true_type {};
+struct tuple_types<std::tuple<Args...>> : types<Args...> {};

 template<typename... Tn>
 struct constructors {};
--- a/sol/userdata.hpp
+++ b/sol/userdata.hpp
@ -42,7 +42,7 @@ struct userdata_traits {
 };

 template<typename T>
-const std::string userdata_traits<T>::name = detail::demangle(typeid(T));
+const std::string userdata_traits<T>::name = detail::lua_demangle(typeid(T));

 template<typename T>
 const std::string userdata_traits<T>::metatable = std::string("sol.stateful.").append(name);
--- a/tests.cpp
+++ b/tests.cpp
@ -2,11 +2,39 @@
 #include <catch.hpp>
 #include <sol.hpp>

+void test_free_func(std::function<void()> f) {
+    f();
+}
+
+void test_free_func2(std::function<int(int)> f, int arg1) {
+    int val = f(arg1);
+    assert(arg1 == val);
+}
+
 std::string free_function() {
    std::cout << "free_function()" << std::endl;
    return "test";
 }

+struct self_test {
+    int bark;
+
+    self_test() : bark(100) {
+
+    }
+
+    void g(const std::string& str) {
+        std::cout << str << '\n';
+        bark += 1;
+    }
+
+    void f(const self_test& t) {
+        std::cout << "got test" << '\n';
+        assert(t.bark == bark);
+        assert(&t == this);
+    }
+};
+
 struct object {
    std::string operator() () {
        std::cout << "member_test()" << std::endl;
@ -324,6 +352,25 @@ TEST_CASE("functions/return_order_and_multi_get", "Check if return order is in t
    REQUIRE(tluaget == triple);
 }

+TEST_CASE("functions/sol::function to std::function", "check if conversion to std::function works properly and calls with correct arguments") {
+    sol::state lua;
+    lua.open_libraries(sol::lib::base);
+
+    lua.set_function("testFunc", test_free_func);
+    lua.set_function("testFunc2", test_free_func2);
+    lua.script(
+        "testFunc(function() print(\"hello std::function\") end)"
+       );
+    lua.script(
+        "function m(a)\n"
+        "     print(\"hello std::function with arg \", a)\n"
+        "     return a\n"
+        "end\n"
+        "\n"
+        "testFunc2(m, 1)"
+       );
+}
+
 TEST_CASE("tables/operator[]", "Check if operator[] retrieval and setting works properly") {
    sol::state lua;
    lua.open_libraries(sol::lib::base);
@ -493,3 +540,17 @@ TEST_CASE("tables/userdata utility derived", "userdata classes must play nice wh
    REQUIRE((lua.get<int>("dgn10") == 70));
    REQUIRE((lua.get<int>("dgn") == 7));
 }
+
+
+TEST_CASE("tables/self-referential userdata", "userdata classes must play nice when C++ object types are requested for C++ code") {
+    sol::state lua;
+    lua.open_libraries(sol::lib::base);
+
+    lua.new_userdata<self_test>("test", "g", &self_test::g, "f", &self_test::f);
+
+    lua.script(
+        "local a = test.new()\n"
+        "a:g(\"woof\")\n"
+        "a:f(a)\n"
+       );
+}