xyz347 / xpack Goto Github PK

* limitations under the License.
*/

#include <iostream>
#include "xpack/json.h"
#include <string>

using namespace std;

struct Example {
    string type;
    xpack::JsonData data;
    XPACK(O(type, data));
};

struct Range {
    int min;
    int max;
    XPACK(O(min, max));
};

struct User {
    int id;
    string name;
    XPACK(O(id, name));
};

static void test(const std::string &data) {
    Example e;
    xpack::json::decode(data, e);
    if (e.type == "range") {
        Range r;
        e.data.Get(r);
    } else if (e.type == "user") {
	User u;
	e.data.Get(u);
	cout << u.id << endl;
    } else {

    }

}

int main(int argc, char *argv[]) {
    (void)argc;
    (void)argv;

    string s1 = "{\"type\":\"range\", \"data\":{\"min\":12, \"max\":33}}";
    string s2 = "{\"type\":\"user\", \"data\":{\"id\":123344343434343435, \"name\":\"xpack\"}}";
    test(s1);
    test(s2);
    
    return 0;
}

    template <class T>
    static void decode(const rapidjson::Value* value_data, T &val) {
        JsonDecoder doc(value_data);
        doc.decode(NULL, val, NULL);
    }

// std::map<enum, T>
template <typename TK, typename TV>
struct is_xpack_xtype<std::map<TK, TV>> {
    static bool const value = true;
};

template <class OBJ, typename TK, typename TV>
bool xpack_xtype_decode(OBJ& obj, const char* key, std::map<TK, TV>& val, const Extend* ext) {
    if constexpr (std::is_enum_v<TK>) {
        std::map<int64_t, TV> tmp;
        if (!obj.decode(key, tmp, ext)) {
            return false;
        }
        val.clear();
        for (auto&& item : tmp) {
            val[item.first] = item.second;
        }
        return true;
    } else {
        static_assert(false, "std::map with this key type is not supported to decode");
        return false;
    }
}

template <class OBJ, typename TK, typename TV>
bool xpack_xtype_encode(OBJ& obj, const char* key, const std::map<TK, TV>& val, const Extend* ext) {
    if constexpr (std::is_enum_v<TK>) {
        std::map<TK, TV> tmp;
        for (auto&& item : val) {
            tmp[item.first] = item.second;
        }
        return obj.encode(key, tmp, ext);
    } else {
        static_assert(false, "std::map with this key type is not supported to encode");
        return false;
    }
}

 JsonDecoder(const std::string& str, bool isfile=false):xdoc_type(NULL, ""),_doc(new rapidjson::Document),_val(_doc) {
    std::string err;
    std::string data;

    do {
        if (isfile) {
            std::ifstream fs(str.c_str(), std::ifstream::binary);
            if (!fs) {
                err = "Open file["+str+"] fail.";
                break;
            }
            std::string _tmp((std::istreambuf_iterator<char>(fs)), std::istreambuf_iterator<char>());


            if (_tmp[0] == '\xEF' && _tmp[1] == '\xBB' && _tmp[2] == '\xBF')//if this formate is utf8-bom
            {
                data = _tmp.substr(3, _tmp.length() - 3);
            }
            else
            {
                data.swap(_tmp);
            }


            _doc->Parse(data);
        } else  {
            _doc->Parse(str);
        }

struct value {
  int a;
  XPACK(O(a));
};
std::map<std::string, value>  map;
xpack::json::decode("{\"123\":{\"a\":1011}, \"234\":{}}", map);
cout << map.size() << ',' << map["123"].a << ',' << map["234"].a << endl;

struct JanusResponse {
	std::string janus;
	std::string transaction;		
	int64_t session_id = -1;
	int64_t sender = -1;
	XPACK(O(janus, transaction, session_id, sender));
};

struct CreateSessionData {
	int64_t id;
	XPACK(O(id));
};

struct CreateSessionResponse : public JanusResponse {
	CreateSessionData data;
	XPACK(I(JanusResponse), O(data));
};

std::string js = "{\"janus\":\"success\",\"transaction\":\"RftQMdXKkq6q\",\"data\":{\"id\":6053426257610390}}";
vi::CreateSessionResponse model;
xpack::json::decode(js, model);

std::string result = xpack::json::encode(model);

你好，我发现decode结果是对的，encode的结果是错的，id的值不对。是我的用法不对？
（在x2struct上能正确encode）