rapidjson包装与lua包装以及两者的交互

rapidjson包装

rapidjson是有名的开源c++ json库，其类java的API使得其易于使用，然而对于rapidjson中的setInt，setString等等setXXX的函数，以及getInt, getString等等getXXX的函数，作者觉得太过于繁琐，想到如果能将这些set和get封装起来，仅仅使用一个函数接口来调用，那么代码将会显得很简洁，维护起来也容易多了。

下面的代码给出了一个简单的尝试。

// for int
template 
typename std::enable_if::value, void>::type
_set_value(rapidjson::Value* node, T value, rapidjson::Document& d)
{
    node->SetInt(value);
}

template 
typename std::enable_if::value, void>::type
_get_value(rapidjson::Value* node, T& value)
{
    value = node->GetInt();
}  

// for string
template 
typename std::enable_if::value, void>::type
    _set_value(rapidjson::Value* node, T value, rapidjson::Document& d)
{
    node->SetString(value.c_str(), value.length(), d.GetAllocator());
}

template 
typename std::enable_if::value, void>::type
    _get_value(rapidjson::Value* node, T& value)
{
    value = std::string(node->GetString());
}

// for char *
template 
typename std::enable_if::value, void>::type
    _set_value(rapidjson::Value* node, T value, rapidjson::Document& d)
{
    node->SetString(value, d.GetAllocator());
}

template 
typename std::enable_if::value, void>::type
_get_value(rapidjson::Value* node, T& value)
{
    value = node->GetString();
}

上面的代码分别对数据的类型进行了模板的特例化用来与rapidjson中setXXX, getXXX的数值类型保持一致。这样在使用时，可以统一使用一个函数来替换setXXX, getXXX函数簇。比如：

rapidjson::Value* node;
int value = 10;
_set_value(node, 10, d);
_get_value(node, value);

根据上面模板函数，可以扩展跟多的函数，比如：

 template 
 int get_value(rapidjson::Document& d, const std::string& key, T& value)
 {
 using namespace std;
 using namespace rapidjson;
 
 
vector node_vec;
Value \*node = static_cast(&d);

node_vec = split(key, '.');
for (int i = 0; i < node_vec.size(); i++) {
    auto itr = node->FindMember(node_vec[i].c_str());
    if (i == node_vec.size() - 1) {
        if (itr != 0) {
            Value* temp = &(itr->value);
            if (temp->IsObject())
                return -1;
            _get_value(temp, value);
            return 0;
        } else {
            return -1;
        }
    } else {
        if (itr != 0) {
            node = &(itr->value);
            if (!node->IsObject()) {
                return -1;
            }
        }
        else {
            return -1;
        }
    }
}
return -1;
 
 
}
 

这个模板函数通过一个使用"."(不包括引号)作为分隔符的字符串往一个rapidjson结构中获取数据，如果这个字符串按"."分割并且顺序与原字符串相同，那么每个子字符串表示一个json树中的节点，最后一个子串为叶子节点，value为其值。

相应地下面是set_value模板函数

 template 
 int set_value(rapidjson::Document& d, const std::string& key, T value)
 {
 using namespace rapidjson;
 using namespace std;
 
 
Value\* node = &d;
vector node_vec;

node_vec = split(key, '.');
for (int i = 0; i < node_vec.size(); i++) {
    auto itr = node->FindMember(node_vec[i].c_str());
    if (i == node_vec.size() - 1) {
        if (itr != 0) {
            _set_value(&(itr->value), value, d);
        } else {
            if (!node->IsObject()) {
                node->SetObject();
            }
            Value a;
            node->AddMember(node_vec[i].c_str(), d.GetAllocator(), a, d.GetAllocator());
            _set_value(&((*node)[node_vec[i].c_str()]), value, d);
        }

    } else {
        if (itr != 0) {
            if (itr->value.IsObject()) {
                node = &(itr->value);
            } else {
                return -1;
            }
        } else {
            Value key_wrapper(node_vec[i].c_str(), d.GetAllocator());
            Value null_value;
            node->AddMember(key_wrapper, null_value, d.GetAllocator());
            node = &((*node)[node_vec[i].c_str()]);
            node->SetObject();
        }
    }
}
return 0;
 
 
}
 

该函数会往json树中根据指定的节点路径去插入叶子节点的元素。

lua包装

和rapidjson类似，在lua的c扩展中有lua_getXXX, lua_pushXXX的函数簇，使用类似的方法将这些函数封装起来：

 // for int
 template 
 typename std::enable_if::value, void>::type
 lua_push(lua_State *L, T value)
 {
 lua_pushinteger(L, value);
 }
 template 
 typename std::enable_if::value, int>::type
 lua_get(lua_State *L, T& value)
 {
 int isnum = 0;
 value = lua_tointegerx(L, -1, &isnum);
 return isnum != 1 ? -1 : 0;
 }
 
 
// for double
template 
    typename std::enable_if::value, void>::type
    lua_push(lua_State \*L, T value)
{
    lua_pushnumber(L, value);
}
template 
    typename std::enable_if::value, int>::type
    lua_get(lua_State \*L, T& value)
{
    int isnum = 0;
    value = lua_tonumberx(L, -1, &isnum);
    return isnum != 1 ? -1 : 0;
}

// for char \* and string
template 
    typename std::enable_if::value, void>::type
    lua_push(lua_State \*L, T value)
{
    lua_pushstring(L, value);
}
template 
    typename std::enable_if::value, void>::type
    lua_push(lua_State \*L, T value)
{
    lua_pushstring(L, value.c_str());
}
template 
    typename std::enable_if::value, int>::type
    lua_get(lua_State \*L, T& value)
{
    size_t len = 0;
    const char \*res = lua_tolstring(L, -1, &len);
    if (res == NULL) {
        return -1;
    } else {
        if (len == 0)
            value = std::string();
        else
            value = std::string(res, len);
        return 0;
    }
}
 
 

对于char*类型的lua_getXXX函数建议不要包装，这样做是为了避免这种方式的使用，为了确保取出的字符串是独立内存地址的，上面的实现实际上是建议使用string的接口来处理字符串。

使用上面的模板函数可以构建更加灵活的模板函数，比如递归地往lua的栈中插入数据：

 // recursively push value
 // base function
 
 
void lua_push_recursive(lua_State \*L) {;}

template 
    void lua_push_recursive(lua_State \*L, T value)
{
    lua_push(L, value);
}

template 
    void lua_push_recursive(lua_State *L, T value, Args... args)
{
    lua_push(L, value);
    lua_push_recursive(L, args...);
}
 
 

跟进一步，利用上面的递归函数，可以实现一个通用的调用lua函数的C的接口：

 template 
 int CallLuaFunc(lua_State *L, T& res, const char* func, Args... args)
 {
 lua_getglobal(L, func); /* push function */
 const int args_num = sizeof...(args);
 if (args_num > 0) {
 lua_push_recursive(L, std::forward(args)...);
 }
 if (lua_pcall(L, args_num, 1, 0) != 0) {
 fprintf(stderr, "%s with args_num: %d\n", lua_tostring(L, -1), args_num);
 lua_pop(L, 1); /* pop error message from the stack */
 return -1;
 }
 if (lua_get(L, res) != 0) {
 lua_pop(L, 1);
 return -1;
 }
 lua_pop(L, 1);
 return 0;
 }
 

如果lua中的函数返回一个返回值，那么可以通过上面的函数来调用该lua函数，比如

 #test.lua
 function add(x, y)
 return x+y
 end
 #test.cpp
 int value = 0;
 lua_State *L;
 CallLuaFunc(L, value, "add", 1, 2);
 # value = 3
 

使用lua操作rapidjson数据

一些业务需要灵活地操作json数据，为了满足这一要求，使用lua通过c的API来操作rapidjson数据，然后c++程序再通过调用lua函数获取结果可以大大增加已经部署的程序的灵活度。下面给出一个简单的封装的类的定义：

 class LuaWrapper;
 typedef int (LuaWrapper::*mem_func)(lua_State * L);
 template 
 int adapter(lua_State * L) {
 LuaWrapper * ptr = *static_cast(lua_getextraspace(L));
 return ((*ptr).*func)(L);
 }
 
 
class LuaWrapper {
public:
    LuaWrapper(): doc(nullptr) {
        L_ = luaL_newstate();
        luaL_openlibs(L_);
        \*static_cast(lua_getextraspace(L_)) = this;
    }

    ~LuaWrapper() {
        lua_close(L_);
    }

    // a rapidjson document point is passed in, and this class is not
    // responsible for deleting this point
    int init(const char\* lua_file, rapidjson::Document *d) {
        doc = d;
        int error = luaL_dofile(L_, lua_file);
        if (error) {
            fprintf(stderr, "%s\n", lua_tostring(L_, -1));
            lua_pop(L_, 1);  /* pop error message from the stack */
            exit(-1);
        }

        const luaL_Reg regs[] = {
            { "get_value_str", &adapter<&LuaWrapper::_lua_get_value_str> },
            { "get_value_int", &adapter<&LuaWrapper::_lua_get_value_int> },
            { NULL, NULL }
        };
        //lua_newtable(L_); since the lua is quite simple, so remove table definition
        lua_pushglobaltable(L_);
        luaL_setfuncs(L_, regs, 0);
        return 0;
    }
    template 
    int GetProvider(T& res, const char\* func, Args... args) {
        assert(doc != nullptr);
        // the lua file must have a dispatcher function
        return lua_util::CallLuaFunc(L_,
                                     res,
                                     func,
                                     std::forward(args)...);
    }
private:
    int \_lua_get_value_str(lua_State \* L) {
        const char \*key = luaL_checkstring(L, 1);
        std::string str;
        int err = get_value(\*doc, key, str);
        if (err != 0) {
            lua_pushnil(L);
        } else {
            lua_push(L, str.c_str());
        }
        return 1;
    }
    int \_lua_get_value_int(lua_State \* L) {
        const char \*key = luaL_checkstring(L, 1);
        int val;
        int err = get_value(\*doc, key, val);
        if (err != 0) {
            lua_pushnil(L);
        } else {
            lua_push(L, val);
        }
        return 1;
    }
    rapidjson::Document \*doc;
    lua_State \*L_;
};
 
 

在lua中注册c的API需要满足function这样的函数标识，而类的成员函数无法满足这样的标识，为了兼容lua的API，这里使用了一个适配器int adapter(lua_State * L)，适配器满足lua的函数标识的要求，因此可以用来注册成lua的c的API。

这样，与lua的交互完全可以快速封装在一个类里，从而为调用者提供简单易懂的接口。