接着上一篇继续，这次我们尝试实现rpc函数的注册以及数据解析

实现handle_data函数

void handle_data(char*, std::size_t);

handle_data的用于处理网络上发过来的原生数据。处理数据的方法各个各样，这里我们还是用例rpc_stream来处理。先说一下基本算法：

1. 解析数据的头部，获取数据的总大小(total_sz)
2. 解析函数名的大小，然后读取函数名
3. 剩下的字符串为参数数据，后续用于反序列化为tuple格式

std::size_t rpc_request::parse(const char* data, std::size_t sz) {
    std::size_t orig = sz;
    while (sz) {
        if (status_ == ST_HEAD) {
            // 解析头部数据
            if (sz >= cosume_size_) {
                stream_ptr_->write_stream().write(data, cosume_size_);
                sz -= cosume_size_;
                status_ = ST_BODY;
                data += cosume_size_;
                cosume_size_ = total_size();
            }
            else {
                stream_ptr_->write_stream().write(data, sz);
                cosume_size_ -= sz;
                sz = 0;
                break;
            }
        }
        else if (status_ == ST_BODY) {
            // 解析method&args
            if (sz >= cosume_size_) {
                stream_ptr_->write_stream().write(data, cosume_size_);
                sz -= cosume_size_;
                status_ = ST_END;
                break;
            }
            else {
                stream_ptr_->write_stream().write(data, sz);
                cosume_size_ -= sz;
                sz = 0;
                break;
            }
        }
        else {
            break;
        }
    }
    return orig - sz;
}

这里不想详细去讲解rpc_request的实现，因为解析数据的逻辑还是比较简单易懂的，具体的代码可以看这里。数据解析后，rpc_service会通过call_method函数对方法进行调用。

virtual void call_method(const std::string&, const std::string&) = 0;

在rpc_service类中call_method中的两个参数分别是函数名称和反序列化之前的字符串。

怎样确定反序列的格式

我们将一个字符串通过msgpack的接口反序列化为tuple类型，但怎样确定tuple内部的类型呢？
这里我实现一个function_traits类解决这个问题。

template<typename T>
struct function_traits_impl;

template<typename T>
struct function_traits :
    function_traits_impl<std::remove_cv_t<std::remove_reference_t<T>>> 
{};

template<typename Ret, typename ... Args>
struct function_traits_impl<Ret(Args...)> {
    typedef Ret return_type;

    template<std::size_t I>
    struct args {
        using type = typename std::tuple_element<I, std::tuple<Args...>>::type;
    };

    typedef std::tuple<std::remove_cv_t<std::remove_reference_t<Args>>...> tuple_type;
};

template<typename Ret, typename ... Args>
struct function_traits_impl<Ret(*)(Args...)>: 
    function_traits_impl<Ret(Args...)> {};

template<typename Ret, typename Cls, typename ... Args>
struct function_traits_impl<Ret(Cls::*)(Args...)>: 
    function_traits_impl<Ret(Args...)> {};

有了function_traits后，通过function_traits<Handler>::tuple_type我们就可以知道对应的类型了。基于function_traits，我们就可以实现register_handler函数了。

template<typename Handler>
void register_func(const std::string& method, Handler&& handler) {
    // pseodu codes
    register_[method] = handler;
}

register_handler很简答，就是找到一个容器，将method与handler对应存储就可以了。那么接下来call_method需要做什么呢？

void call_method(const std::string& method, const std::string& args) {
    // pesodu codes
    using args_tuple = typename function_traits<Handler>::tuple_type;
    args_tuple t;
    msgpack::unpack(args_str.c_str(), args_str.size()).get().convert(t);
    using index = std::make_index_sequence<std::tuple_size<std::remove_reference_t<args_tuple>>::value>;
    call_impl(self, t, index{});
}

template<typename TupleArgs, std::size_t ... Is>
void call_impl(Cls* self, TupleArgs&& tuple_args, std::index_sequence<Is...>) {
    (self->*handler_)(std::forward<typename std::tuple_element<Is, std::remove_reference_t<TupleArgs>>::type>(std::get<Is>(tuple_args))...);
}

这里有些是伪代码和真实代码进行混合写的，最后的实现可以看这里。

相关代码地址：https://github.com/Whosemario/ThinkIdeaEx/tree/master/rpc

接下来

怎样使用RPC框架来实现一些功能