本文主要是介绍远程过程调用-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);
}
这篇关于远程过程调用-buttonrpc源码解析6-函数调用的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!