远程过程调用-buttonrpc源码解析6-函数调用

前一篇文章讲述了服务端如何利用std::bind绑定函数，统一函数调用形式。本片文章继续分析服务端如何调用绑定后的函数。
解惑：前一篇里buttonrpc源码采用了buttonrpc::callproxy<F>或buttonrpc::callproxy<F, S>函数作为绑定的调用对象，而将func作为绑定的参数。那为什么不直接使用型如std::bind(func, args...)或std::bind(func, struct, args...)的方式呢？因为我们无法将func的参数统一成最后几个参数类型相同，也不应该统一，func应该表达其本身函数的意思。因此，需要借助委托函数buttonrpc::callproxy<F>或buttonrpc::callproxy<F, S>来统一函数的最后几个参数，本节将进行重点分析。

1、服务端调用的第一层函数
服务端会通过反序列化得到函数名称，之后得到参数数据指针data和数据长度len。接着调用call_函数，并将返回值序列化到ds对象中返回。其中，auto fun = m_handlers[name]得到的就是当初绑定时的委托函数callproxy。

inline Serializer* buttonrpc::call_(std::string name, const char* data, int len)
{
	Serializer* ds = new Serializer();
	if (m_handlers.find(name) == m_handlers.end()) {
		(*ds) << value_t<int>::code_type(RPC_ERR_FUNCTIION_NOT_BIND);
		(*ds) << value_t<int>::msg_type("function not bind: " + name);
		return ds;
	}
	auto fun = m_handlers[name];
	fun(ds, data, len);
	ds->reset();
	return ds;
}

2、重点：委托函数callproxy，统一函数最后三个参数

template<typename F>
inline void buttonrpc::callproxy( F fun, Serializer* pr, const char* data, int len )
{
	callproxy_(fun, pr, data, len);
}

template<typename F, typename S>
inline void buttonrpc::callproxy(F fun, S * s, Serializer * pr, const char * data, int len)
{
	callproxy_(fun, s, pr, data, len);
}

3、重点：函数callproxy_负责拆分callproxy中的模板F的具体类型

// 函数指针
template<typename R, typename... Params>
void callproxy_(R(*func)(Params...), Serializer* pr, const char* data, int len)
{
	callproxy_(std::function<R(Params...)>(func), pr, data, len);
}

// 类成员函数指针
template<typename R, typename C, typename S, typename... Params>
void callproxy_(R(C::* func)(Params...), S* s, Serializer* pr, const char* data, int len)
{
	using args_type = std::tuple<typename std::decay<Params>::type...>;

	Serializer ds(StreamBuffer(data, len));
	constexpr auto N = std::tuple_size<typename std::decay<args_type>::type>::value;
	args_type args = ds.get_tuple < args_type >(std::make_index_sequence<N>{});

	// 以下代码作用：函数调用+处理返回值
	auto ff = [=](Params... ps)->R {
		return (s->*func)(ps...);
	};
	typename type_xx<R>::type r = call_helper<R>(ff, args);

	value_t<R> val;
	val.set_code(RPC_ERR_SUCCESS);
	val.set_val(r);
	(*pr) << val;
}

// functional
template<typename R, typename... Params>
void callproxy_(std::function<R(Params... ps)> func, Serializer* pr, const char* data, int len)
{	
	using args_type = std::tuple<typename std::decay<Params>::type...>;

	Serializer ds(StreamBuffer(data, len));
	constexpr auto N = std::tuple_size<typename std::decay<args_type>::type>::value;
	args_type args = ds.get_tuple < args_type > (std::make_index_sequence<N>{});

	// 以下代码作用：函数调用+处理返回值
	typename type_xx<R>::type r = call_helper<R>(func, args);

	value_t<R> val;
	val.set_code(RPC_ERR_SUCCESS);
	val.set_val(r);
	(*pr) << val;
}

由于callproxy_里的func函数在std::bind的时候已经绑定过了，因此可以明确知道func参数的类型和个数，便可以得到std::tuple的类型args_type和元素数量N，最终反序列化到元组args：

using args_type = std::tuple<typename std::decay<Params>::type...>;
constexpr auto N = std::tuple_size<typename std::decay<args_type>::type>::value;
args_type args = ds.get_tuple < args_type > (std::make_index_sequence<N>{});

而在拆分类成员函数内，出现了lambda表达式，而没采用std::bind：

auto ff = [=](Params... ps)->R {
	return (s->*func)(ps...);
};

这是因为如果采用std::bind的方式，需要添加参数占位符std::placeholders::_1，而面对可变参的时候无法确定应该填写几个，所以采用lambda表达式。
4、若不考虑函数返回值，则可以直接调用invoke函数

// 具体实现函数模板：用tuple做参数调用函数模板类
template<typename Function, typename Tuple, std::size_t... Index>
decltype(auto) invoke_impl(Function&& func, Tuple&& t, std::index_sequence<Index...>)
{
	return func(std::get<Index>(std::forward<Tuple>(t))...);
}

// 函数模板：作为一个接口，负责调用相关函数并传递参数 
template<typename Function, typename Tuple>
decltype(auto) invoke(Function&& func, Tuple&& t)
{
	constexpr auto size = std::tuple_size<typename std::decay<Tuple>::type>::value;
	return invoke_impl(std::forward<Function>(func), std::forward<Tuple>(t), std::make_index_sequence<size>{});
}

修改后，调用invoke方式如下：

// 类成员函数
template<typename R, typename C, typename S, typename... Params>
void callproxy_(R(C::* func)(Params...), S* s, Serializer* pr, const char* data, int len)
{
	using args_type = std::tuple<typename std::decay<Params>::type...>;

	Serializer ds(StreamBuffer(data, len));
	constexpr auto N = std::tuple_size<typename std::decay<args_type>::type>::value;
	args_type args = ds.get_tuple < args_type >(std::make_index_sequence<N>{});

	// 不考虑返回值，修改如下
	auto ff = [=](Params... ps)->R {
		return (s->*func)(ps...);
	};
	invoke(ff, args);
}

// 普通函数
template<typename R, typename... Params>
void callproxy_(std::function<R(Params... ps)> func, Serializer* pr, const char* data, int len)
{
	using args_type = std::tuple<typename std::decay<Params>::type...>;

	Serializer ds(StreamBuffer(data, len));
	constexpr auto N = std::tuple_size<typename std::decay<args_type>::type>::value;
	args_type args = ds.get_tuple < args_type > (std::make_index_sequence<N>{});

	// 不考虑返回值，修改如下
	invoke(func, args);
}