Mongodb C++ 的简易封装

Mongodb.h

#ifndef MONGODB_H
#define MONGODB_H

#include <bsoncxx/builder/stream/document.hpp>
#include <bsoncxx/types.hpp>
#include <mongocxx/client.hpp>
#include <mongocxx/instance.hpp>
#include <mongocxx/uri.hpp>
#include <bsoncxx/json.hpp>
#include <QString>

using bsoncxx::builder::stream::document;
using bsoncxx::builder::stream::open_document;
using bsoncxx::builder::stream::close_document;
using bsoncxx::builder::stream::open_array;
using bsoncxx::builder::stream::close_array;
using bsoncxx::builder::stream::finalize;
using namespace mongocxx;
using namespace mongocxx::options;
using bsoncxx::builder::basic::kvp;
using bsoncxx::builder::basic::make_document;
using bsoncxx::to_json;

class Mongodb
{
protected:
    mongocxx::instance* m_dbInstance = nullptr;
    mongocxx::client* m_client = nullptr;

    QString m_hostName;
    QString m_port;

public:
    stdx::optional<bsoncxx::document::value> find_One(QString db,QString coll,document& filter,const mongocxx::v_noabi::options::find& options = mongocxx::v_noabi::options::find());
    cursor* find(QString db,QString coll,document& filter,const mongocxx::v_noabi::options::find& options = mongocxx::v_noabi::options::find());
    stdx::optional<result::insert_one> insert_One(QString db,QString coll,document& doc,const mongocxx::v_noabi::options::insert& options = {});
    stdx::optional<result::update> update_One(QString db,QString coll,document& filter,document& value,const mongocxx::v_noabi::options::update& options = mongocxx::v_noabi::options::update());
    stdx::optional<result::update> update_Many(QString db,QString coll,document& filter,document& value,const mongocxx::v_noabi::options::update& options = mongocxx::v_noabi::options::update());
    stdx::optional<result::delete_result> delete_One(QString db,QString coll,document& filter,const mongocxx::v_noabi::options::delete_options& options = mongocxx::v_noabi::options::delete_options());
    stdx::optional<result::delete_result> delete_Many(QString db,QString coll,document& filter,const mongocxx::v_noabi::options::delete_options& options = mongocxx::v_noabi::options::delete_options());
    std::int64_t countDocument(QString db,QString coll,document& filter,const options::count& option = options::count());

public:
    Mongodb();
    Mongodb(QString hostName,QString port);
    void setHostName(QString hostName);
    void setPort(QString port);
    void connectToHost();
    mongocxx::client* client();
    ~Mongodb();

    static QString getIDInView(const bsoncxx::v_noabi::document::view& view);
};

#endif // MONGODB_H

 

Mongodb.cpp

#include "Mongodb.h"
#include "tinyjson.hpp"

using namespace tiny;

Mongodb::Mongodb()
{

}

Mongodb::Mongodb(QString hostName,QString port)
{
    m_hostName = hostName;
    m_port = port;
}

void Mongodb::setHostName(QString hostName)
{
    m_hostName = hostName;
}

void Mongodb::setPort(QString port)
{
    m_port = port;
}

void Mongodb::connectToHost()
{
    if((m_hostName != "") && (m_port != ""))
    {
        if(m_dbInstance)
        {
            delete m_dbInstance;
            m_dbInstance = nullptr;
        }

        if(m_client)
        {
            delete m_client;
            m_client = nullptr;
        }

        m_dbInstance = new(std::nothrow) mongocxx::instance();
        m_client = new(std::nothrow) mongocxx::client(mongocxx::uri{("mongodb://" + m_hostName + ":" + m_port).toStdString().c_str()});
    }
}

mongocxx::client* Mongodb::client()
{
    return m_client;
}

stdx::optional<bsoncxx::document::value> Mongodb::find_One(QString db,QString coll,document& filter,const mongocxx::v_noabi::options::find& options)
{
    stdx::optional<bsoncxx::document::value> ret;

    if(m_dbInstance && m_client)
    {
        return (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].find_one(filter.view(),options);
    }

    return ret;
}

cursor* Mongodb::find(QString db,QString coll,document& filter,const mongocxx::v_noabi::options::find& options)
{
    if(m_dbInstance && m_client)
    {
        auto c = (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].find(filter.view(),options);
        return new(std::nothrow) cursor(std::move(c));
    }

    return nullptr;
}

stdx::optional<result::insert_one> Mongodb::insert_One(QString db,QString coll,document& doc,const mongocxx::v_noabi::options::insert& options)
{
    stdx::optional<result::insert_one> ret;

    if(m_dbInstance && m_client)
    {
        ret = (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].insert_one(doc.view(),options);
    }

    return ret;
}

stdx::optional<result::update> Mongodb::update_One(QString db,QString coll,document& filter,document& value,const mongocxx::v_noabi::options::update& options)
{
    stdx::optional<result::update> ret;
    if(m_dbInstance && m_client)
    {
        ret = (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].update_one(
                    filter.view(),
                    make_document(kvp("$set",value)),
                    options
                    );
    }

    return ret;
}

stdx::optional<result::update> Mongodb::update_Many(QString db,QString coll,document& filter,document& value,const mongocxx::v_noabi::options::update& options)
{
    stdx::optional<result::update> ret;
    if(m_dbInstance && m_client)
    {
        ret = (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].update_many(
                    filter.view(),
                    make_document(kvp("$set",value)),
                    options
                    );
    }

    return ret;
}

stdx::optional<result::delete_result> Mongodb::delete_One(QString db,QString coll,document& filter,const mongocxx::v_noabi::options::delete_options&  options)
{
    stdx::optional<result::delete_result> ret;

    if(m_dbInstance && m_client)
    {
        ret = (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].delete_one(filter.view(),options);
    }

    return ret;
}

stdx::optional<result::delete_result> Mongodb::delete_Many(QString db,QString coll,document& filter,const mongocxx::v_noabi::options::delete_options& options)
{
    stdx::optional<result::delete_result> ret;

    if(m_dbInstance && m_client)
    {
        ret = (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].delete_many(filter.view(),options);
    }

    return ret;
}

std::int64_t Mongodb::countDocument(QString db,QString coll,document& filter,const options::count& option)
{
    return (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].count_documents(filter.view(),option);
}

Mongodb::~Mongodb()
{
    delete m_dbInstance;
    delete m_client;
}

QString Mongodb::getIDInView(const bsoncxx::v_noabi::document::view& view)
{
    QString ret = "";

    auto str = bsoncxx::to_json(view);
    TinyJson json;
    json.ReadJson(str);

    auto id = json.Get<std::string>("_id");
    TinyJson id_json;
    id_json.ReadJson(id);
    ret = id_json.Get<std::string>("$oid").c_str();

    return ret;
}

tinyjson.hpp(来自github)

https://github.com/button-chen/tinyjson

/**
*
*    tiny::TinyJson library
*    Copyright 2017 Button
*
*/

#ifndef TINY_JSON_H_
#define TINY_JSON_H_

#include <string>
#include <sstream>
#include <map>
#include <vector>
#include <algorithm>
#include <iostream>

namespace tiny {

    /**
    * 无类型，解析时确认
    *
    */
    class Value
    {
    public:
        Value() {
            value_.clear();
            nokey_ = false;
        }
        Value(std::string val) : value_(val) {
            if (value_ == "") {
                value_.clear();
                nokey_ = true;
            }
            else {
                nokey_ = false;
            }
        }
        ~Value() {}

    public:
        std::string value() { return value_; }
        template<typename R> 
        R GetAs() {
            std::istringstream iss(value_);
            R v;
            iss >> v;
            return v;
        }


        template<typename V> 
        void Set(V v) {
            std::ostringstream oss;
            if (nokey_) {
                oss << v;
            }
            else {
                oss << """ << value_ << """ << ":" << v;
            }
            value_ = oss.str();
        }

        template<typename T>
        void Push(T& v) {
            std::ostringstream oss;
            if (v.get_nokey()) {
                oss << v.WriteJson(0);
            }
            else {
                oss << v.WriteJson(1);
            }
            value_ = oss.str();
        }

    private:
        std::string value_;
        bool nokey_;
    };

        template<> inline bool Value::GetAs() { return value_ == "true" ? true : false; }
        template<> inline std::string Value::GetAs() { return value_; }
        template<>
        inline void Value::Set(std::string v) {
                std::ostringstream oss;
                if (nokey_) {
                        oss << """ << v << """;
                }
                else {
                        oss << """ << value_ << """ << ":" << """ << v << """;
                }
                value_ = oss.str();
        }

        template<>
        inline void Value::Set(const char* v) {
                Set(std::string(v));
        }

        template<>
        inline void Value::Set(bool v) {
                std::ostringstream oss;
                std::string val = v == true ? "true" : "false";
                if (nokey_) {
                        oss << val;
                }
                else {
                        oss << """ << value_ << """ << ":" << val;
                }
                value_ = oss.str();
        }

    /**
    * 此模板类处理json键对应的值是一个嵌套对象或者数组的情况
    * 
    */
    template<typename T>
    class ValueArray : public T
    {
    public:
        ValueArray() {}
        ValueArray(std::vector<std::string> vo) { vo_ = vo; }

        bool Enter(int i) {
            std::string obj = vo_[i];
                        return this->ReadJson(obj);
        }

        int Count() { return vo_.size(); }

    private:
        std::vector<std::string> vo_;
    };

    /**
    * 解析json字符串保存为键值的顺序存储，解析是按一层一层的进行
    * 解析时把json看做是对象'{}' 与 数组'[]' 的组合
    *
    */
    class ParseJson
    {
    public:
        ParseJson() {}
        ~ParseJson() {}

    public:
        bool ParseArray(std::string json, std::vector<std::string>& vo);
        bool ParseObj(std::string json);
        std::vector<std::string> GetKeyVal() {
            return keyval_;
        }

    protected:
        std::string Trims(std::string s, char lc, char rc);
        int GetFirstNotSpaceChar(std::string& s, int cur);
        std::string FetchArrayStr(std::string inputstr, int inpos, int& offset);
        std::string FetchObjStr(std::string inputstr, int inpos, int& offset);
        std::string FetchStrStr(std::string inputstr, int inpos, int& offset);
        std::string FetchNumStr(std::string inputstr, int inpos, int& offset);

    private:
        std::vector<char> token_;
        std::vector<std::string> keyval_;
    };

    inline bool ParseJson::ParseArray(std::string json, std::vector<std::string>& vo) {
        json = Trims(json, '[', ']');
        std::string tokens;
        size_t i = 0;
        for (; i < json.size(); ++i) {
            char c = json[i];
            if (isspace(c) || c == '"') continue;
            if (c == ':' || c == ',' || c == '{') {
                if (!tokens.empty()) {
                    vo.push_back(tokens);
                    tokens.clear();
                }
                if (c == ',') continue;
                int offset = 0;
                char nextc = c;
                for (; c != '{';) {
                    nextc = json[++i];
                    if (isspace(nextc)) continue;
                    break;
                }
                if (nextc == '{') {
                    tokens = FetchObjStr(json, i, offset);
                }
                else if (nextc == '[') {
                    tokens = FetchArrayStr(json, i, offset);
                }
                i += offset;
                continue;
            }
            tokens.push_back(c);
        }
        if (!tokens.empty()) {
            vo.push_back(tokens);
        }
        return true;
    }

    // 解析为 key-value 调用一次解析一个层次
    inline bool ParseJson::ParseObj(std::string json) {
        auto LastValidChar = [&](int index)->char{
            for (int i = index-1; i >= 0; --i){
                if (isspace(json[i])) continue;
                char tmp = json[i];
                return tmp;
            }
            return '';
        };

        json = Trims(json, '{', '}');
        size_t i = 0;
        for (; i < json.size(); ++i) {
            char nextc = json[i];
            if (isspace(nextc)) continue;

            std::string tokens;
            int offset = 0;
            if (nextc == '{') {
                tokens = FetchObjStr(json, i, offset);
            }
            else if (nextc == '[') {
                tokens = FetchArrayStr(json, i, offset);
            }
            else if (nextc == '"') {
                tokens = FetchStrStr(json, i, offset);
            }
            else if (isdigit(nextc) && LastValidChar(i) == ':')
            {
                tokens = FetchNumStr(json, i, offset);
            }
            else {
                continue;
            }
            keyval_.push_back(tokens);
            i += offset;
        }
        if (keyval_.size() == 0)
        {
            keyval_.push_back(json);
        }
        return true;
    }

    inline std::string ParseJson::Trims(std::string s, char lc, char rc)
    {
        std::string ss = s;
        if (s.find(lc) != std::string::npos && s.find(rc) != std::string::npos) {
            size_t b = s.find_first_of(lc);
            size_t e = s.find_last_of(rc);
            ss = s.substr(b + 1, e - b - 1);
        }
        return ss;
    }

    inline int ParseJson::GetFirstNotSpaceChar( std::string& s, int cur )
    {
        for (size_t i = cur; i < s.size(); i++){
            if (isspace(s[i])) continue;
            return i - cur;
        }
        return 0;
    }

    inline std::string ParseJson::FetchArrayStr(std::string inputstr, int inpos, int& offset)
    {
        int tokencount = 0;
        std::string objstr;
        size_t i = inpos + GetFirstNotSpaceChar(inputstr, inpos);
        for (; i < inputstr.size(); i++) {
            char c = inputstr[i];
            if (c == '[') {
                ++tokencount;
            }
            if (c == ']') {
                --tokencount;
            }
            objstr.push_back(c);
            if (tokencount == 0) {
                break;
            }
        }
        offset = i - inpos;
        return objstr;
    }

    inline std::string ParseJson::FetchObjStr(std::string inputstr, int inpos, int& offset)
    {
        int tokencount = 0;
        std::string objstr;
        size_t i = inpos + GetFirstNotSpaceChar(inputstr, inpos);
        for (; i < inputstr.size(); i++) {
            char c = inputstr[i];
            if (c == '{') {
                ++tokencount;
            }
            if (c == '}') {
                --tokencount;
            }
            objstr.push_back(c);
            if (tokencount == 0) {
                break;
            }
        }
        offset = i - inpos;
        return objstr;
    }

    inline std::string ParseJson::FetchStrStr( std::string inputstr, int inpos, int& offset )
    {
        int tokencount = 0;
        std::string objstr;
        size_t i = inpos + GetFirstNotSpaceChar(inputstr, inpos);
        for (; i < inputstr.size(); i++) {
            char c = inputstr[i];
            if (c == '"') {
                ++tokencount;
            }
            objstr.push_back(c);
            if (tokencount % 2 == 0 && (c == ',' || c == ':')) {
                break;
            }
        }
        offset = i - inpos;

        return Trims(objstr, '"', '"');
    }

    inline std::string ParseJson::FetchNumStr( std::string inputstr, int inpos, int& offset )
    {
        std::string objstr;
        size_t i = inpos + GetFirstNotSpaceChar(inputstr, inpos);
        for (; i < inputstr.size(); i++) {
            char c = inputstr[i];
            if (c == ',') {
                break;
            }
            objstr.push_back(c);
        }
        offset = i - inpos;

        return objstr;
    }

    /**
    * 对外接口类
    *
    */
    class TinyJson;
    typedef ValueArray<TinyJson> xarray;
    typedef ValueArray<TinyJson> xobject;

    class TinyJson
    {
        friend class ValueArray<TinyJson>;
    public:
        TinyJson() {
            nokey_ = false;
        }
        ~TinyJson() {}

    public:
        // read
        bool ReadJson(std::string json) {
            ParseJson p;
            p.ParseObj(json);
            KeyVal_ = p.GetKeyVal();
            return true;
        }

        template<typename R>
        R Get(std::string key, R defVal) {
            auto itr = std::find(KeyVal_.begin(), KeyVal_.end(), key);
            if (itr == KeyVal_.end()) {
                return defVal;
            }
            return Value(*(++itr)).GetAs<R>();
        }

        template<typename R>
        R Get(std::string key) {
            return Get(key, R());
        }

        template<typename R>
        R Get() {
            return Value(KeyVal_[0]).GetAs<R>();
        }

        // write
        Value& operator[](std::string k) {
            Items_.push_back(Value(k));
            Value& v = Items_[Items_.size() - 1];
            if (k == "") {
                nokey_ = true;
            }
            return v;
        }

        void Push(TinyJson item) {
            Items_.push_back(Value(""));
            Value& v = Items_[Items_.size() - 1];
            nokey_ = true;
            v.Push(item);
            sub_type_ = 1;
        }

        bool get_nokey() {
            return nokey_;
        }

        std::string WriteJson(){
            return WriteJson(1);
        }

        // 0: none  1: object  2: array
        std::string WriteJson(int type);

    public:
        int sub_type_;

    private:
        std::vector<std::string> KeyVal_;
        std::vector<Value> Items_;
        bool nokey_;
    };

    template<>
    inline xarray TinyJson::Get(std::string key) {
        std::string val = Get<std::string>(key);
        ParseJson p;
        std::vector<std::string> vo;
        p.ParseArray(val, vo);
        xarray vals(vo);
        return vals;
    }

    inline std::ostream & operator << (std::ostream& os, TinyJson& ob)
    {
        os << ob.WriteJson();
        return os;
    }

    inline std::string TinyJson::WriteJson(int type)
    {
        std::string prefix = type == 1 ? "{" : "[";
        std::string suffix = type == 1 ? "}" : "]";
        if (type == 0) {
            prefix = "";
            suffix = "";
        }
        std::ostringstream oss;
        oss << prefix;
        int i = 0;
        int size = Items_.size();
        std::string seq = ",";
        for (; i < size; ++i) {
            Value& v = Items_[i];
            oss << v.value() << seq;
        }
        std::string jsonstring = oss.str();
        if (jsonstring.back() == ',') {
            jsonstring = jsonstring.substr(0, jsonstring.find_last_of(','));
        }

        jsonstring += suffix;
        return jsonstring;
    }

    template<>
    inline void Value::Set(TinyJson v) {
        std::ostringstream oss;
        if (v.sub_type_ == 1) {
            oss << """ << value_ << """ << ":" << v.WriteJson(2);
        }
        else {
            if (nokey_) {
                oss << v;
            }
            else {
                oss << """ << value_ << """ << ":" << v;
            }
        }
        value_ = oss.str();
    }

}  // end namesapce

#endif  // TINY_JSON_H_

tinyjson使用案例

#pragma once

#include "tinyjson.hpp"
#include <string>
#include <iostream>
#include <cassert>
using namespace std;
using namespace tiny;

string jsonstring = "
{
    "name":"lier  gou",
    "age" : 26.9,
    "data" : [
    {
        "one":"chenone",
        "two" : {
            "love1":"2233",
            "love2":44444
        }
    },
    {
        "one":"chen22",
        "two" : {
            "love1":"8899",
            "love2":10000
        }
    }
    ],
    "lang":"2cpp"
}
";

string jsonstring2 = "
{
    "name":"liergou",
    "age" : 26.9,
    "data" : [
    {
        "one":"chenone",
        "two" : [
            "love_chen",
            "love_hui"
        ]
    },
    {
        "one":"chen22",
        "two" : [
            "love_chen2",
            "love_hui2"
        ]
    }
    ],
    "lang":"cpp"
}
";

string jsonstring3 = "
{
    "xx": {
        "a": 1,
        "b" : 2
    }
}";

// read demo
void TEST99() {
    cout << "
TEST 99 READ JSON" << endl;
    // read
    TinyJson json;
    json.ReadJson(jsonstring3);

    xobject data = json.Get<xobject>("xx");
    for (int i = 0; i < data.Count(); i++) {
        data.Enter(i);
        int one = data.Get<int>("a");
        int two = data.Get<int>("b");
        int three = data.Get<int>("c", 99);
        assert(one == 1);
        assert(two == 2);
        assert(three == 99);
    }
    cout << "TEST 99 PASS" << endl;
}


// read demo
void TEST1() {
    cout << "
TEST 1 READ JSON" << endl;
    // read
    TinyJson json;
    json.ReadJson(jsonstring);

    string name = json.Get<string>("name");
    float age = json.Get<float>("age");
    string lang = json.Get<string>("lang");

    assert(name == "lier  gou");
    assert(age > 26 && age < 27);
    assert(lang == "2cpp");

    xarray data = json.Get<xarray>("data");
    for (int i = 0; i < data.Count(); i++) {
        data.Enter(i);
        string one = data.Get<string>("one");
        if (i == 0)
        {
            assert(one == "chenone");
        }
        if (i == 1)
        {
            assert(one == "chen22");
        }
        xobject two = data.Get<xobject>("two");
        for (int ii = 0; ii < two.Count(); ii++) {
            two.Enter(ii);
            string love1 = two.Get<string>("love1");
            int love2 = two.Get<int>("love2");
            if (i == 0)
            {
                assert(love1 == "2233");
                assert(love2 == 44444);
            }
            if (i == 1)
            {
                assert(love1 == "8899");
                assert(love2 == 10000);
            }

        }
    }
    cout << "TEST 1 PASS" << endl;
}

// read demo
void TEST2() {
    cout << "
TEST 2 READ JSON" << endl;
    // read
    TinyJson json;
    json.ReadJson(jsonstring2);

    string name = json.Get<string>("name");
    float age = json.Get<float>("age");
    string lang = json.Get<string>("lang");

    assert(name == "liergou");
    assert(age > 26 && age < 27);
    assert(lang == "cpp");

    xarray data = json.Get<xarray>("data");
    for (int i = 0; i < data.Count(); i++) {
        data.Enter(i);
        string one = data.Get<string>("one");
        if (i == 0)
        {
            assert(one == "chenone");
        }
        if (i == 1)
        {
            assert(one == "chen22");
        }
        xarray two = data.Get<xarray>("two");
        for (int ii = 0; ii < two.Count(); ii++) {
            two.Enter(ii);
            string val = two.Get<string>();
            if (i == 0 && ii == 0)
            {
                assert(val == "love_chen");
            }
            if (i == 0 && ii == 1)
            {
                assert(val == "love_hui");
            }
            if (i == 1 && ii == 0)
            {
                assert(val == "love_chen2");
            }
            if (i == 1 && ii == 1)
            {
                assert(val == "love_hui2");
            }
        }
    }
    cout << "TEST 2 PASS" << endl;
}

// write demo TEST3()

/*   write result

{
    "name": "liergou",
    "age": 26,
    "handsome": true,
    "data": {
        "love1": "book",
        "love2": 666
    },
    "data2": {
        "love1": "book2",
        "love2": 6662
    }
}

*/

void TEST3() {
    cout << "
TEST 3 WRITE JSON" << endl;
    // write
    TinyJson wjson;
    wjson["name"].Set("liergou");
    wjson["age"].Set(26);
    wjson["handsome"].Set(true);

    TinyJson subjson;
    subjson["love1"].Set("book");
    subjson["love2"].Set(666);

    TinyJson subjson2;
    subjson2["love1"].Set("book2");
    subjson2["love2"].Set(6662);

    wjson["data"].Set(subjson);
    wjson["data2"].Set(subjson2);

    string str = wjson.WriteJson();
    cout << "json string: 
" << endl;
    cout << str << endl;
}

// write demo TEST4()

/*   write result

{
    "name": "liergou",
    "age" : 26,
    "handsome" : true,
    "data" : [
      {
        "love1": "book",
        "love2" : 666
      },
      {
        "love1": "book2",
        "love2" : 6662
      }
    ]
}

*/

void TEST4() {
    cout << "
TEST 4 WRITE JSON" << endl;
    // write
    TinyJson wjson;
    wjson["name"].Set("liergou");
    wjson["age"].Set(26);
    wjson["handsome"].Set(true);

    TinyJson subjson;
    subjson["love1"].Set("book");
    subjson["love2"].Set(666);

    TinyJson subjson2;
    subjson2["love1"].Set("book2");
    subjson2["love2"].Set(6662);

    TinyJson jsonarray;
    jsonarray.Push(subjson);
    jsonarray.Push(subjson2);

    wjson["data"].Set(jsonarray);

    string str = wjson.WriteJson();
    cout << "json string: 
" << endl;
    cout << str << endl;
}

// write demo TEST5()

/*   write result

{
    "name": "liergou",
    "age" : 26,
    "handsome" : true,
    "data" : [
         "book",
         666
    ]
}

*/

void TEST5() {
    cout << "
TEST 5 WRITE JSON" << endl;
    // write
    TinyJson wjson;
    wjson["name"].Set("liergou");
    wjson["age"].Set(26);
    wjson["handsome"].Set(true);

    TinyJson subjson;
    subjson[""].Set("book");
    subjson[""].Set(666);

    TinyJson jsonarray;
    jsonarray.Push(subjson);

    wjson["data"].Set(jsonarray);

    string str = wjson.WriteJson();
    cout << "json string: 
" << endl;
    cout << str << endl;
}