mock_mem_fn can accept a real member pointer

Author: peacalm

include/peacalm/luaw.h

@@ -246,12 +246,12 @@ class luaw {
   template <typename T, typename = void>
   struct registrar;
 
-  // A callable object adapter, which bahaves like the result of std::mem_fn.
-  // The origin first argument should be reference or raw pointer,
-  // then this object can accept reference, raw pointer, and also smart pointers
-  // (std::shared_ptr and std::unique_ptr) as the first argument to call the
-  // origin callable object.
-  template <typename T>
+  // Mock std::mem_fn by a function or callable object whose first argument
+  // must be raw pointer of a class.
+  // Then can call this class by reference, raw pointer or smart pointers
+  // (std::shared_ptr and std::unique_ptr) of the class.
+  // Also can accept a real member pointer, then it is just like std::mem_fn.
+  template <typename T, typename = void>
   class mock_mem_fn;
 
   // Mock non-member to be a class's member.
@@ -4290,9 +4290,12 @@ auto retrieve_underlying_ptr(T&& t) {
 
 }  // namespace luaw_detail
 
-// The first argument of CallableObject must be pointer, and could be `auto*`.
+// The first argument of CallableObject must be raw pointer, and could be
+// `auto*` (in lambda).
 template <typename CallableObject>
-class luaw::mock_mem_fn {
+class luaw::mock_mem_fn<
+    CallableObject,
+    std::enable_if_t<!std::is_member_pointer<CallableObject>::value>> {
   CallableObject o;
 
 public:
@@ -4305,6 +4308,22 @@ class luaw::mock_mem_fn {
   }
 };
 
+template <typename MemberPointer>
+class luaw::mock_mem_fn<
+    MemberPointer,
+    std::enable_if_t<std::is_member_pointer<MemberPointer>::value>> {
+  decltype(std::mem_fn(static_cast<MemberPointer>(nullptr))) o;
+
+public:
+  mock_mem_fn(MemberPointer p) : o(std::mem_fn(p)) {}
+
+  template <typename FirstArg, typename... Args>
+  decltype(auto) operator()(FirstArg&& f, Args&&... args) const {
+    return o(luaw_detail::retrieve_underlying_ptr(std::forward<FirstArg>(f)),
+             std::forward<Args>(args)...);
+  };
+};
+
 //////////////////// static_mem_fn impl ////////////////////////////////////////
 
 // specialize for C function pointer

test/unit_test/register_member.cpp

@@ -1861,4 +1861,30 @@ TEST(register_member, get_object_created_by_lua) {
   EXPECT_EQ(a.ci, 1);
 }
 
+TEST(register_member, nonconst_as_const_member) {
+  luaw l;
+  l.register_member<const int Obj::*>("i", &Obj::i);
+  l.register_member("i2", &Obj::i);
+
+  l.set("o", Obj{});
+  EXPECT_EQ(l.eval<int>("return o.i"), 1);
+  EXPECT_EQ(l.eval<int>("return o.i2"), 1);
+
+  EXPECT_EQ(l.dostring("o.i2 = 2"), LUA_OK);
+  EXPECT_NE(l.dostring("o.i = 2"), LUA_OK);
+  l.log_error_out();
+}
+
+TEST(register_member, change_member_function_type) {
+  luaw l;
+  l.register_member("i", &Obj::i);
+  l.register_member("geti", &Obj::geti);
+  l.register_member<bool (Obj::*)() const>("getb", &Obj::geti);
+
+  l.set("o", Obj(123));
+  EXPECT_EQ(l.eval<int>("return o.i"), 123);
+  EXPECT_EQ(l.eval<int>("return o:geti()"), 123);
+  EXPECT_EQ(l.eval<int>("return o:getb()"), 1);
+}
+
 }  // namespace