c++ 统一插件源码分析二

c++ 统一插件源码分析二

背景：

请参考https://blog.csdn.net/c553110519/article/details/127215315?spm=1001.2014.3001.5501

本文重点分析反序列化后的调用顺序问题

Call

C++ template<typename R>     R call(const msgpack::sbuffer& buf){       auto str = call(buf);       //TODO handle error code and exception       purecpp::msg_codec codec;       return codec.result<R>(str.data(), str.size()); //transforma failed will throw exception     }

服务端当接收到需要函数调用的请求后，会调用

C++ std::string call(const msgpack::sbuffer& buf){       return call(buf.data(), buf.size());     } std::string call(const char* buf, size_t size){   using namespace purecpp;   std::string result;     result = call_in_so_(buf, size);   return result; }

最终会调用到

call_in_so_

C++ namespace purecpp{     std::string call_in_so(const char *data, std::size_t size) {       return purecpp::router::get().route(data, size);     } }

紧接着到了

C++ std::string route(const char* data, std::size_t size) {   std::string result;   do{       //plus1, 1, 2--> 3()result       msg_codec codec;       auto p = codec.unpack<std::tuple<std::string>>(data, size);//       auto& func_name = std::get<0>(p);//       auto it = map_invokers_.find(func_name);//             //       it->second(data, size, result);          ......   }while(0);   return result; }

为了方便分析，删除不是重点的代码，最终调用了

C++ apply(const Function& func, const char* data, size_t size,                                      std::string& result)

我们接着分析它

apply

C++ static inline void apply(const Function& func, const char* data, size_t size,                                      std::string& result) {   using args_tuple = typename function_traits<Function>::args_tuple;   msg_codec codec;   auto tp = codec.unpack<args_tuple>(data, size);   router::call(func, result, std::move(tp)); }

可以看的出来它把

我们重点看下

router::call

C++ template<typename F, typename Arg, typename... Args>         static         typename std::enable_if<std::is_void<typename std::result_of<F(Args...)>::type>::value>::type         call(const F & f, std::string & result, std::tuple<Arg, Args...> tp) {           call_helper(f, std::make_index_sequence<sizeof...(Args)>{}, std::move(tp));         }

这里可以明显的看到在传递函数参数的时候把后边的放，比较巧妙过滤上了

call_helper

C++ template<typename F, size_t... I, typename Arg, typename... Args>         static typename std::result_of<F(Args...)>::type call_helper(                 const F & f, const std::index_sequence<I...>&, std::tuple<Arg, Args...> tup) {           return f(std::move(std::get<I + 1>(tup))...);         }

代码看到这里就很简单了，