Allow to use std::shared_ptr with wrapped class arguments

Fixed a bug to use a reference or shared_ptr to wrapped class as a function argument.
Now have to supply `use_shared_ptr` boolean template argument to `call_from_v8` for
proper `class_<T, use_shared_ptr>` usage on function argument unwrapping.

Added a `convert<T, ref_from_shared_ptr>` specialization to use a reference
as a function argument for wrapped with `std::shared_ptr<T>` classes.

Added test cases.

Author: pmed

test/test_call_from_v8.cpp

@@ -32,6 +32,11 @@ void w(v8::FunctionCallbackInfo<v8::Value> const& args)
 	return args.GetReturnValue().Set(args.Length());
 }
 
+struct X {};
+void class_ref(X&) {}
+void class_ptr(X*) {}
+void class_sptr(std::shared_ptr<X>) {}
+
 using v8pp::detail::select_call_traits;
 using v8pp::detail::call_from_v8_traits;
 using v8pp::detail::isolate_arg_call_traits;
@@ -60,6 +65,14 @@ static_assert(std::is_same<select_call_traits<decltype(&z)>,
 static_assert(std::is_same<select_call_traits<decltype(&w)>,
 	v8_args_call_traits<decltype(&w) >> ::value, "");
 
+static_assert(std::is_same<select_call_traits<decltype(&class_ptr), false>::arg_convert<0>::from_type, X*>::value, "class ptr");
+static_assert(std::is_same<select_call_traits<decltype(&class_ref), false>::arg_convert<0>::from_type, X&>::value, "class ref");
+static_assert(std::is_same<select_call_traits<decltype(&class_sptr), false>::arg_convert<0>::from_type, std::shared_ptr<X>>::value, "class shared_ptr");
+
+static_assert(std::is_same<select_call_traits<decltype(&class_ptr), true>::arg_convert<0>::from_type, std::shared_ptr<X>>::value, "class ptr");
+static_assert(std::is_same<select_call_traits<decltype(&class_ref), true>::arg_convert<0>::from_type, X&>::value, "class ref");
+static_assert(std::is_same<select_call_traits<decltype(&class_sptr), true>::arg_convert<0>::from_type, std::shared_ptr<X>>::value, "class shared_ptr");
+
 } // unnamed namespace
 
 void test_call_from_v8()

test/test_class.cpp

@@ -44,6 +44,11 @@ struct Y : X
 
 	explicit Y(int x) { var = x; ++instance_count; }
 	~Y() { --instance_count; }
+
+	int useX(X& x) { return var + x.var; }
+
+	template<bool use_shared_ptr, typename X_ptr = typename v8pp::class_<X, use_shared_ptr>::object_pointer_type>
+	int useX_ptr(X_ptr x) { return var + x->var; }
 };
 
 int Y::instance_count = 0;
@@ -112,6 +117,8 @@ void test_class_()
 	Y_class
 		.template inherit<X>()
 		.template ctor<int>()
+		.set("useX", &Y::useX)
+		.set("useX_ptr", &Y::useX_ptr<use_shared_ptr>)
 		;
 
 	check_ex<std::runtime_error>("already wrapped class X", [isolate]()
@@ -167,7 +174,7 @@ void test_class_()
 	check("y3_obj", v8pp::to_v8(isolate, y3) == y3_obj);
 	check_eq("y3.var", y3->var, -3);
 
-	run_script<int>(context, "for (i = 0; i < 10; ++i) new Y(i); i");
+	run_script<int>(context, "x = new X; for (i = 0; i < 10; ++i) { y = new Y(i); y.useX(x); y.useX_ptr(x); }");
 	check_eq("Y count", Y::instance_count, 10 + 4); // 10 + y + y1 + y2 + y3
 	run_script<int>(context, "y = null; 0");
 

v8pp/call_from_v8.hpp

@@ -18,7 +18,7 @@
 
 namespace v8pp { namespace detail {
 
-template<typename F, size_t Offset = 0>
+template<typename F, bool use_shared_ptr = false, size_t Offset = 0>
 struct call_from_v8_traits
 {
 	static bool const is_mem_fun = std::is_member_function_pointer<F>::value;
@@ -43,15 +43,24 @@ struct call_from_v8_traits
 	using arg_type = typename tuple_element<Index + is_mem_fun,
 		Index < (arg_count + Offset)>::type;
 
-	template<size_t Index>
-	using convert_type = decltype(convert<arg_type<Index>>::from_v8(
-		std::declval<v8::Isolate*>(), std::declval<v8::Handle<v8::Value>>()));
+	template<size_t Index, typename Arg = arg_type<Index>,
+		typename T = typename std::remove_reference<Arg>::type,
+		typename U = typename std::remove_pointer<T>::type
+	>
+	using arg_convert = typename std::conditional<
+		is_wrapped_class<U>::value && use_shared_ptr,
+		typename std::conditional<std::is_pointer<T>::value,
+			convert<std::shared_ptr<U>>,
+			convert<U, ref_from_shared_ptr>
+		>::type,
+		convert<Arg>
+	>::type;
 
 	template<size_t Index>
-	static convert_type<Index>
+	static decltype(arg_convert<Index>::from_v8(std::declval<v8::Isolate*>(), std::declval<v8::Handle<v8::Value>>()))
 	arg_from_v8(v8::FunctionCallbackInfo<v8::Value> const& args)
 	{
-		return convert<arg_type<Index>>::from_v8(args.GetIsolate(), args[Index - Offset]);
+		return arg_convert<Index>::from_v8(args.GetIsolate(), args[Index - Offset]);
 	}
 
 	static void check(v8::FunctionCallbackInfo<v8::Value> const& args)
@@ -63,11 +72,11 @@ struct call_from_v8_traits
 	}
 };
 
-template<typename F>
-using isolate_arg_call_traits = call_from_v8_traits<F, 1>;
+template<typename F, bool use_shared_ptr = false>
+using isolate_arg_call_traits = call_from_v8_traits<F, use_shared_ptr, 1>;
 
 template<typename F, size_t Offset = 0>
-struct v8_args_call_traits : call_from_v8_traits<F, Offset>
+struct v8_args_call_traits : call_from_v8_traits<F, false, Offset>
 {
 	template<size_t Index>
 	using arg_type = v8::FunctionCallbackInfo<v8::Value> const&;
@@ -102,12 +111,14 @@ using is_first_arg_isolate = std::integral_constant<bool,
 	std::is_same<typename call_from_v8_traits<F>::template arg_type<0>,
 		v8::Isolate*>::value>;
 
-template<typename F>
+template<typename F, bool use_shared_ptr = false>
 using select_call_traits = typename std::conditional<is_first_arg_isolate<F>::value,
 	typename std::conditional<is_direct_args<F, 1>::value,
-		isolate_v8_args_call_traits<F>, isolate_arg_call_traits<F>>::type,
+		isolate_v8_args_call_traits<F>,
+		isolate_arg_call_traits<F, use_shared_ptr>>::type,
 	typename std::conditional<is_direct_args<F, 0>::value,
-		v8_args_call_traits<F>, call_from_v8_traits<F>>::type
+		v8_args_call_traits<F>,
+		call_from_v8_traits<F, use_shared_ptr>>::type
 >::type;
 
 template<typename F, typename CallTraits, size_t ...Indices>
@@ -126,22 +137,22 @@ call_from_v8_impl(T& obj, F&& func, v8::FunctionCallbackInfo<v8::Value> const& a
 	return (obj.*func)(CallTraits::template arg_from_v8<Indices>(args)...);
 }
 
-template<typename F, size_t ...Indices>
+template<typename F, bool use_shared_ptr, size_t ...Indices>
 typename function_traits<F>::return_type
 call_from_v8_impl(F&& func, v8::FunctionCallbackInfo<v8::Value> const& args,
-	isolate_arg_call_traits<F>, index_sequence<Indices...>)
+	isolate_arg_call_traits<F, use_shared_ptr>, index_sequence<Indices...>)
 {
 	return func(args.GetIsolate(),
-		isolate_arg_call_traits<F>::template arg_from_v8<Indices + 1>(args)...);
+		isolate_arg_call_traits<F, use_shared_ptr>::template arg_from_v8<Indices + 1>(args)...);
 }
 
-template<typename T, typename F, size_t ...Indices>
+template<typename T, bool use_shared_ptr, typename F, size_t ...Indices>
 typename function_traits<F>::return_type
 call_from_v8_impl(T& obj, F&& func, v8::FunctionCallbackInfo<v8::Value> const& args,
-	isolate_arg_call_traits<F>, index_sequence<Indices...>)
+	isolate_arg_call_traits<F, use_shared_ptr>, index_sequence<Indices...>)
 {
 	return (obj.*func)(args.GetIsolate(),
-		isolate_arg_call_traits<F>::template arg_from_v8<Indices + 1>(args)...);
+		isolate_arg_call_traits<F, use_shared_ptr>::template arg_from_v8<Indices + 1>(args)...);
 }
 
 template<typename F, size_t ...Indices>
@@ -160,21 +171,21 @@ call_from_v8_impl(T& obj, F&& func, v8::FunctionCallbackInfo<v8::Value> const& a
 	return (obj.*func)(args.GetIsolate(), args);
 }
 
-template<typename F>
+template<typename F, bool use_shared_ptr>
 typename function_traits<F>::return_type
 call_from_v8(F&& func, v8::FunctionCallbackInfo<v8::Value> const& args)
 {
-	using call_traits = select_call_traits<F>;
+	using call_traits = select_call_traits<F, use_shared_ptr>;
 	call_traits::check(args);
 	return call_from_v8_impl(std::forward<F>(func), args,
 		call_traits(), make_index_sequence<call_traits::arg_count>());
 }
 
-template<typename T, typename F>
+template<typename T, typename F, bool use_shared_ptr>
 typename function_traits<F>::return_type
 call_from_v8(T& obj, F&& func, v8::FunctionCallbackInfo<v8::Value> const& args)
 {
-	using call_traits = select_call_traits<F>;
+	using call_traits = select_call_traits<F, use_shared_ptr>;
 	call_traits::check(args);
 	return call_from_v8_impl(obj, std::forward<F>(func), args,
 		call_traits(), make_index_sequence<call_traits::arg_count>());

v8pp/class.hpp

@@ -553,8 +553,8 @@ class class_
 		static object_pointer_type call(v8::FunctionCallbackInfo<v8::Value> const& args)
 		{
 			using ctor_function = object_pointer_type(*)(v8::Isolate* isolate, Args...);
-			return detail::call_from_v8(static_cast<ctor_function>(
-				&factory<T, use_shared_ptr>::create), args);
+			return detail::call_from_v8<ctor_function, use_shared_ptr>(
+				&factory<T, use_shared_ptr>::create, args);
 		}
 	};
 

v8pp/convert.hpp

@@ -594,8 +594,7 @@ struct convert<T, typename std::enable_if<is_wrapped_class<T>::value>::type>
 };
 
 template<typename T>
-struct convert<std::shared_ptr<T>,
-	typename std::enable_if<is_wrapped_class<T>::value>::type>
+struct convert<std::shared_ptr<T>, typename std::enable_if<is_wrapped_class<T>::value>::type>
 {
 	using from_type = std::shared_ptr<T>;
 	using to_type = v8::Handle<v8::Object>;
@@ -621,6 +620,41 @@ struct convert<std::shared_ptr<T>,
 	}
 };
 
+struct ref_from_shared_ptr {};
+
+template<typename T>
+struct convert<T, ref_from_shared_ptr>
+{
+	using from_type = T&;
+	using to_type = v8::Handle<v8::Object>;
+
+	static bool is_valid(v8::Isolate* isolate, v8::Handle<v8::Value> value)
+	{
+		return convert<std::shared_ptr<T>>::is_valid(isolate, value);
+	}
+
+	static from_type from_v8(v8::Isolate* isolate, v8::Handle<v8::Value> value)
+	{
+		if (!is_valid(isolate, value))
+		{
+			throw std::invalid_argument("expected Object");
+		}
+		if (std::shared_ptr<T> object = convert<std::shared_ptr<T>>::from_v8(isolate, value))
+		{
+//			assert(object.use_count() > 1);
+			return *object;
+		}
+		throw std::runtime_error("failed to unwrap C++ object");
+	}
+
+	static to_type to_v8(v8::Isolate* isolate, T const& value)
+	{
+		v8::Handle<v8::Object> result = convert<std::shared_ptr<T>>::to_v8(isolate, &value);
+		if (!result.IsEmpty()) return result;
+		throw std::runtime_error("failed to wrap C++ object");
+	}
+};
+
 template<typename T>
 struct convert<T&> : convert<T> {};
 

v8pp/function.hpp

@@ -122,7 +122,7 @@ typename std::enable_if<is_callable<F>::value,
 	typename function_traits<F>::return_type>::type
 invoke(v8::FunctionCallbackInfo<v8::Value> const& args)
 {
-	return call_from_v8(std::forward<F>(get_external_data<F>(args.Data())), args);
+	return call_from_v8<F, use_shared_ptr>(std::forward<F>(get_external_data<F>(args.Data())), args);
 }
 
 template<typename F, bool use_shared_ptr>
@@ -137,8 +137,9 @@ invoke(v8::FunctionCallbackInfo<v8::Value> const& args)
 
 	v8::Isolate* isolate = args.GetIsolate();
 	v8::Local<v8::Object> obj = args.This();
-	return call_from_v8(*class_<class_type, use_shared_ptr>::unwrap_object(isolate, obj),
-			std::forward<F>(get_external_data<F>(args.Data())), args);
+	return call_from_v8<class_type, F, use_shared_ptr>(
+		*class_<class_type, use_shared_ptr>::unwrap_object(isolate, obj),
+		std::forward<F>(get_external_data<F>(args.Data())), args);
 }
 
 template<typename F, bool use_shared_ptr>