1 #ifndef MONGODB_H
 2 #define MONGODB_H
 3 
 4 #include <bsoncxx/builder/stream/document.hpp>
 5 #include <bsoncxx/types.hpp>
 6 #include <mongocxx/client.hpp>
 7 #include <mongocxx/instance.hpp>
 8 #include <mongocxx/uri.hpp>
 9 #include <bsoncxx/json.hpp>
10 #include <QString>
11 
12 using bsoncxx::builder::stream::document;
13 using bsoncxx::builder::stream::open_document;
14 using bsoncxx::builder::stream::close_document;
15 using bsoncxx::builder::stream::open_array;
16 using bsoncxx::builder::stream::close_array;
17 using bsoncxx::builder::stream::finalize;
18 using namespace mongocxx;
19 using namespace mongocxx::options;
20 using bsoncxx::builder::basic::kvp;
21 using bsoncxx::builder::basic::make_document;
22 using bsoncxx::to_json;
23 
24 class Mongodb
25 {
26 protected:
27     mongocxx::instance* m_dbInstance = nullptr;
28     mongocxx::client* m_client = nullptr;
29 
30     QString m_hostName;
31     QString m_port;
32 
33 public:
34     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());
35     cursor* find(QString db,QString coll,document& filter,const mongocxx::v_noabi::options::find& options = mongocxx::v_noabi::options::find());
36     stdx::optional<result::insert_one> insert_One(QString db,QString coll,document& doc,const mongocxx::v_noabi::options::insert& options = {});
37     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());
38     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());
39     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());
40     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());
41     std::int64_t countDocument(QString db,QString coll,document& filter,const options::count& option = options::count());
42 
43 public:
44     Mongodb();
45     Mongodb(QString hostName,QString port);
46     void setHostName(QString hostName);
47     void setPort(QString port);
48     void connectToHost();
49     mongocxx::client* client();
50     ~Mongodb();
51 
52     static QString getIDInView(const bsoncxx::v_noabi::document::view& view);
53 };
54 
55 #endif // MONGODB_H

  1 #include "Mongodb.h"
  2 #include "tinyjson.hpp"
  3 
  4 using namespace tiny;
  5 
  6 Mongodb::Mongodb()
  7 {
  8 
  9 }
 10 
 11 Mongodb::Mongodb(QString hostName,QString port)
 12 {
 13     m_hostName = hostName;
 14     m_port = port;
 15 }
 16 
 17 void Mongodb::setHostName(QString hostName)
 18 {
 19     m_hostName = hostName;
 20 }
 21 
 22 void Mongodb::setPort(QString port)
 23 {
 24     m_port = port;
 25 }
 26 
 27 void Mongodb::connectToHost()
 28 {
 29     if((m_hostName != "") && (m_port != ""))
 30     {
 31         if(m_dbInstance)
 32         {
 33             delete m_dbInstance;
 34             m_dbInstance = nullptr;
 35         }
 36 
 37         if(m_client)
 38         {
 39             delete m_client;
 40             m_client = nullptr;
 41         }
 42 
 43         m_dbInstance = new(std::nothrow) mongocxx::instance();
 44         m_client = new(std::nothrow) mongocxx::client(mongocxx::uri{("mongodb://" + m_hostName + ":" + m_port).toStdString().c_str()});
 45     }
 46 }
 47 
 48 mongocxx::client* Mongodb::client()
 49 {
 50     return m_client;
 51 }
 52 
 53 stdx::optional<bsoncxx::document::value> Mongodb::find_One(QString db,QString coll,document& filter,const mongocxx::v_noabi::options::find& options)
 54 {
 55     stdx::optional<bsoncxx::document::value> ret;
 56 
 57     if(m_dbInstance && m_client)
 58     {
 59         return (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].find_one(filter.view(),options);
 60     }
 61 
 62     return ret;
 63 }
 64 
 65 cursor* Mongodb::find(QString db,QString coll,document& filter,const mongocxx::v_noabi::options::find& options)
 66 {
 67     if(m_dbInstance && m_client)
 68     {
 69         auto c = (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].find(filter.view(),options);
 70         return new(std::nothrow) cursor(std::move(c));
 71     }
 72 
 73     return nullptr;
 74 }
 75 
 76 stdx::optional<result::insert_one> Mongodb::insert_One(QString db,QString coll,document& doc,const mongocxx::v_noabi::options::insert& options)
 77 {
 78     stdx::optional<result::insert_one> ret;
 79 
 80     if(m_dbInstance && m_client)
 81     {
 82         ret = (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].insert_one(doc.view(),options);
 83     }
 84 
 85     return ret;
 86 }
 87 
 88 stdx::optional<result::update> Mongodb::update_One(QString db,QString coll,document& filter,document& value,const mongocxx::v_noabi::options::update& options)
 89 {
 90     stdx::optional<result::update> ret;
 91     if(m_dbInstance && m_client)
 92     {
 93         ret = (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].update_one(
 94                     filter.view(),
 95                     make_document(kvp("$set",value)),
 96                     options
 97                     );
 98     }
 99 
100     return ret;
101 }
102 
103 stdx::optional<result::update> Mongodb::update_Many(QString db,QString coll,document& filter,document& value,const mongocxx::v_noabi::options::update& options)
104 {
105     stdx::optional<result::update> ret;
106     if(m_dbInstance && m_client)
107     {
108         ret = (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].update_many(
109                     filter.view(),
110                     make_document(kvp("$set",value)),
111                     options
112                     );
113     }
114 
115     return ret;
116 }
117 
118 stdx::optional<result::delete_result> Mongodb::delete_One(QString db,QString coll,document& filter,const mongocxx::v_noabi::options::delete_options&  options)
119 {
120     stdx::optional<result::delete_result> ret;
121 
122     if(m_dbInstance && m_client)
123     {
124         ret = (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].delete_one(filter.view(),options);
125     }
126 
127     return ret;
128 }
129 
130 stdx::optional<result::delete_result> Mongodb::delete_Many(QString db,QString coll,document& filter,const mongocxx::v_noabi::options::delete_options& options)
131 {
132     stdx::optional<result::delete_result> ret;
133 
134     if(m_dbInstance && m_client)
135     {
136         ret = (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].delete_many(filter.view(),options);
137     }
138 
139     return ret;
140 }
141 
142 std::int64_t Mongodb::countDocument(QString db,QString coll,document& filter,const options::count& option)
143 {
144     return (*m_client)[db.toStdString().c_str()][coll.toStdString().c_str()].count_documents(filter.view(),option);
145 }
146 
147 Mongodb::~Mongodb()
148 {
149     delete m_dbInstance;
150     delete m_client;
151 }
152 
153 QString Mongodb::getIDInView(const bsoncxx::v_noabi::document::view& view)
154 {
155     QString ret = "";
156 
157     auto str = bsoncxx::to_json(view);
158     TinyJson json;
159     json.ReadJson(str);
160 
161     auto id = json.Get<std::string>("_id");
162     TinyJson id_json;
163     id_json.ReadJson(id);
164     ret = id_json.Get<std::string>("$oid").c_str();
165 
166     return ret;
167 }

  1 /**
  2 *
  3 *    tiny::TinyJson library
  4 *    Copyright 2017 Button
  5 *
  6 */
  7 
  8 #ifndef TINY_JSON_H_
  9 #define TINY_JSON_H_
 10 
 11 #include <string>
 12 #include <sstream>
 13 #include <map>
 14 #include <vector>
 15 #include <algorithm>
 16 #include <iostream>
 17 
 18 namespace tiny {
 19 
 20     /**
 21     * 无类型，解析时确认
 22     *
 23     */
 24     class Value
 25     {
 26     public:
 27         Value() {
 28             value_.clear();
 29             nokey_ = false;
 30         }
 31         Value(std::string val) : value_(val) {
 32             if (value_ == "") {
 33                 value_.clear();
 34                 nokey_ = true;
 35             }
 36             else {
 37                 nokey_ = false;
 38             }
 39         }
 40         ~Value() {}
 41 
 42     public:
 43         std::string value() { return value_; }
 44         template<typename R> 
 45         R GetAs() {
 46             std::istringstream iss(value_);
 47             R v;
 48             iss >> v;
 49             return v;
 50         }
 51 
 52 
 53         template<typename V> 
 54         void Set(V v) {
 55             std::ostringstream oss;
 56             if (nokey_) {
 57                 oss << v;
 58             }
 59             else {
 60                 oss << "\"" << value_ << "\"" << ":" << v;
 61             }
 62             value_ = oss.str();
 63         }
 64 
 65         template<typename T>
 66         void Push(T& v) {
 67             std::ostringstream oss;
 68             if (v.get_nokey()) {
 69                 oss << v.WriteJson(0);
 70             }
 71             else {
 72                 oss << v.WriteJson(1);
 73             }
 74             value_ = oss.str();
 75         }
 76 
 77     private:
 78         std::string value_;
 79         bool nokey_;
 80     };
 81 
 82         template<> inline bool Value::GetAs() { return value_ == "true" ? true : false; }
 83         template<> inline std::string Value::GetAs() { return value_; }
 84         template<>
 85         inline void Value::Set(std::string v) {
 86                 std::ostringstream oss;
 87                 if (nokey_) {
 88                         oss << "\"" << v << "\"";
 89                 }
 90                 else {
 91                         oss << "\"" << value_ << "\"" << ":" << "\"" << v << "\"";
 92                 }
 93                 value_ = oss.str();
 94         }
 95 
 96         template<>
 97         inline void Value::Set(const char* v) {
 98                 Set(std::string(v));
 99         }
100 
101         template<>
102         inline void Value::Set(bool v) {
103                 std::ostringstream oss;
104                 std::string val = v == true ? "true" : "false";
105                 if (nokey_) {
106                         oss << val;
107                 }
108                 else {
109                         oss << "\"" << value_ << "\"" << ":" << val;
110                 }
111                 value_ = oss.str();
112         }
113 
114     /**
115     * 此模板类处理json键对应的值是一个嵌套对象或者数组的情况
116     * 
117     */
118     template<typename T>
119     class ValueArray : public T
120     {
121     public:
122         ValueArray() {}
123         ValueArray(std::vector<std::string> vo) { vo_ = vo; }
124 
125         bool Enter(int i) {
126             std::string obj = vo_[i];
127                         return this->ReadJson(obj);
128         }
129 
130         int Count() { return vo_.size(); }
131 
132     private:
133         std::vector<std::string> vo_;
134     };
135 
136     /**
137     * 解析json字符串保存为键值的顺序存储，解析是按一层一层的进行
138     * 解析时把json看做是对象‘{}‘ 与 数组‘[]‘ 的组合
139     *
140     */
141     class ParseJson
142     {
143     public:
144         ParseJson() {}
145         ~ParseJson() {}
146 
147     public:
148         bool ParseArray(std::string json, std::vector<std::string>& vo);
149         bool ParseObj(std::string json);
150         std::vector<std::string> GetKeyVal() {
151             return keyval_;
152         }
153 
154     protected:
155         std::string Trims(std::string s, char lc, char rc);
156         int GetFirstNotSpaceChar(std::string& s, int cur);
157         std::string FetchArrayStr(std::string inputstr, int inpos, int& offset);
158         std::string FetchObjStr(std::string inputstr, int inpos, int& offset);
159         std::string FetchStrStr(std::string inputstr, int inpos, int& offset);
160         std::string FetchNumStr(std::string inputstr, int inpos, int& offset);
161 
162     private:
163         std::vector<char> token_;
164         std::vector<std::string> keyval_;
165     };
166 
167     inline bool ParseJson::ParseArray(std::string json, std::vector<std::string>& vo) {
168         json = Trims(json, ‘[‘, ‘]‘);
169         std::string tokens;
170         size_t i = 0;
171         for (; i < json.size(); ++i) {
172             char c = json[i];
173             if (isspace(c) || c == ‘\"‘) continue;
174             if (c == ‘:‘ || c == ‘,‘ || c == ‘{‘) {
175                 if (!tokens.empty()) {
176                     vo.push_back(tokens);
177                     tokens.clear();
178                 }
179                 if (c == ‘,‘) continue;
180                 int offset = 0;
181                 char nextc = c;
182                 for (; c != ‘{‘;) {
183                     nextc = json[++i];
184                     if (isspace(nextc)) continue;
185                     break;
186                 }
187                 if (nextc == ‘{‘) {
188                     tokens = FetchObjStr(json, i, offset);
189                 }
190                 else if (nextc == ‘[‘) {
191                     tokens = FetchArrayStr(json, i, offset);
192                 }
193                 i += offset;
194                 continue;
195             }
196             tokens.push_back(c);
197         }
198         if (!tokens.empty()) {
199             vo.push_back(tokens);
200         }
201         return true;
202     }
203 
204     // 解析为 key-value 调用一次解析一个层次
205     inline bool ParseJson::ParseObj(std::string json) {
206         auto LastValidChar = [&](int index)->char{
207             for (int i = index-1; i >= 0; --i){
208                 if (isspace(json[i])) continue;
209                 char tmp = json[i];
210                 return tmp;
211             }
212             return ‘\0‘;
213         };
214 
215         json = Trims(json, ‘{‘, ‘}‘);
216         size_t i = 0;
217         for (; i < json.size(); ++i) {
218             char nextc = json[i];
219             if (isspace(nextc)) continue;
220 
221             std::string tokens;
222             int offset = 0;
223             if (nextc == ‘{‘) {
224                 tokens = FetchObjStr(json, i, offset);
225             }
226             else if (nextc == ‘[‘) {
227                 tokens = FetchArrayStr(json, i, offset);
228             }
229             else if (nextc == ‘\"‘) {
230                 tokens = FetchStrStr(json, i, offset);
231             }
232             else if (isdigit(nextc) && LastValidChar(i) == ‘:‘)
233             {
234                 tokens = FetchNumStr(json, i, offset);
235             }
236             else {
237                 continue;
238             }
239             keyval_.push_back(tokens);
240             i += offset;
241         }
242         if (keyval_.size() == 0)
243         {
244             keyval_.push_back(json);
245         }
246         return true;
247     }
248 
249     inline std::string ParseJson::Trims(std::string s, char lc, char rc)
250     {
251         std::string ss = s;
252         if (s.find(lc) != std::string::npos && s.find(rc) != std::string::npos) {
253             size_t b = s.find_first_of(lc);
254             size_t e = s.find_last_of(rc);
255             ss = s.substr(b + 1, e - b - 1);
256         }
257         return ss;
258     }
259 
260     inline int ParseJson::GetFirstNotSpaceChar( std::string& s, int cur )
261     {
262         for (size_t i = cur; i < s.size(); i++){
263             if (isspace(s[i])) continue;
264             return i - cur;
265         }
266         return 0;
267     }
268 
269     inline std::string ParseJson::FetchArrayStr(std::string inputstr, int inpos, int& offset)
270     {
271         int tokencount = 0;
272         std::string objstr;
273         size_t i = inpos + GetFirstNotSpaceChar(inputstr, inpos);
274         for (; i < inputstr.size(); i++) {
275             char c = inputstr[i];
276             if (c == ‘[‘) {
277                 ++tokencount;
278             }
279             if (c == ‘]‘) {
280                 --tokencount;
281             }
282             objstr.push_back(c);
283             if (tokencount == 0) {
284                 break;
285             }
286         }
287         offset = i - inpos;
288         return objstr;
289     }
290 
291     inline std::string ParseJson::FetchObjStr(std::string inputstr, int inpos, int& offset)
292     {
293         int tokencount = 0;
294         std::string objstr;
295         size_t i = inpos + GetFirstNotSpaceChar(inputstr, inpos);
296         for (; i < inputstr.size(); i++) {
297             char c = inputstr[i];
298             if (c == ‘{‘) {
299                 ++tokencount;
300             }
301             if (c == ‘}‘) {
302                 --tokencount;
303             }
304             objstr.push_back(c);
305             if (tokencount == 0) {
306                 break;
307             }
308         }
309         offset = i - inpos;
310         return objstr;
311     }
312 
313     inline std::string ParseJson::FetchStrStr( std::string inputstr, int inpos, int& offset )
314     {
315         int tokencount = 0;
316         std::string objstr;
317         size_t i = inpos + GetFirstNotSpaceChar(inputstr, inpos);
318         for (; i < inputstr.size(); i++) {
319             char c = inputstr[i];
320             if (c == ‘\"‘) {
321                 ++tokencount;
322             }
323             objstr.push_back(c);
324             if (tokencount % 2 == 0 && (c == ‘,‘ || c == ‘:‘)) {
325                 break;
326             }
327         }
328         offset = i - inpos;
329 
330         return Trims(objstr, ‘\"‘, ‘\"‘);
331     }
332 
333     inline std::string ParseJson::FetchNumStr( std::string inputstr, int inpos, int& offset )
334     {
335         std::string objstr;
336         size_t i = inpos + GetFirstNotSpaceChar(inputstr, inpos);
337         for (; i < inputstr.size(); i++) {
338             char c = inputstr[i];
339             if (c == ‘,‘) {
340                 break;
341             }
342             objstr.push_back(c);
343         }
344         offset = i - inpos;
345 
346         return objstr;
347     }
348 
349     /**
350     * 对外接口类
351     *
352     */
353     class TinyJson;
354     typedef ValueArray<TinyJson> xarray;
355     typedef ValueArray<TinyJson> xobject;
356 
357     class TinyJson
358     {
359         friend class ValueArray<TinyJson>;
360     public:
361         TinyJson() {
362             nokey_ = false;
363         }
364         ~TinyJson() {}
365 
366     public:
367         // read
368         bool ReadJson(std::string json) {
369             ParseJson p;
370             p.ParseObj(json);
371             KeyVal_ = p.GetKeyVal();
372             return true;
373         }
374 
375         template<typename R>
376         R Get(std::string key, R defVal) {
377             auto itr = std::find(KeyVal_.begin(), KeyVal_.end(), key);
378             if (itr == KeyVal_.end()) {
379                 return defVal;
380             }
381             return Value(*(++itr)).GetAs<R>();
382         }
383 
384         template<typename R>
385         R Get(std::string key) {
386             return Get(key, R());
387         }
388 
389         template<typename R>
390         R Get() {
391             return Value(KeyVal_[0]).GetAs<R>();
392         }
393 
394         // write
395         Value& operator[](std::string k) {
396             Items_.push_back(Value(k));
397             Value& v = Items_[Items_.size() - 1];
398             if (k == "") {
399                 nokey_ = true;
400             }
401             return v;
402         }
403 
404         void Push(TinyJson item) {
405             Items_.push_back(Value(""));
406             Value& v = Items_[Items_.size() - 1];
407             nokey_ = true;
408             v.Push(item);
409             sub_type_ = 1;
410         }
411 
412         bool get_nokey() {
413             return nokey_;
414         }
415 
416         std::string WriteJson(){
417             return WriteJson(1);
418         }
419 
420         // 0: none  1: object  2: array
421         std::string WriteJson(int type);
422 
423     public:
424         int sub_type_;
425 
426     private:
427         std::vector<std::string> KeyVal_;
428         std::vector<Value> Items_;
429         bool nokey_;
430     };
431 
432     template<>
433     inline xarray TinyJson::Get(std::string key) {
434         std::string val = Get<std::string>(key);
435         ParseJson p;
436         std::vector<std::string> vo;
437         p.ParseArray(val, vo);
438         xarray vals(vo);
439         return vals;
440     }
441 
442     inline std::ostream & operator << (std::ostream& os, TinyJson& ob)
443     {
444         os << ob.WriteJson();
445         return os;
446     }
447 
448     inline std::string TinyJson::WriteJson(int type)
449     {
450         std::string prefix = type == 1 ? "{" : "[";
451         std::string suffix = type == 1 ? "}" : "]";
452         if (type == 0) {
453             prefix = "";
454             suffix = "";
455         }
456         std::ostringstream oss;
457         oss << prefix;
458         int i = 0;
459         int size = Items_.size();
460         std::string seq = ",";
461         for (; i < size; ++i) {
462             Value& v = Items_[i];
463             oss << v.value() << seq;
464         }
465         std::string jsonstring = oss.str();
466         if (jsonstring.back() == ‘,‘) {
467             jsonstring = jsonstring.substr(0, jsonstring.find_last_of(‘,‘));
468         }
469 
470         jsonstring += suffix;
471         return jsonstring;
472     }
473 
474     template<>
475     inline void Value::Set(TinyJson v) {
476         std::ostringstream oss;
477         if (v.sub_type_ == 1) {
478             oss << "\"" << value_ << "\"" << ":" << v.WriteJson(2);
479         }
480         else {
481             if (nokey_) {
482                 oss << v;
483             }
484             else {
485                 oss << "\"" << value_ << "\"" << ":" << v;
486             }
487         }
488         value_ = oss.str();
489     }
490 
491 }  // end namesapce
492 
493 #endif  // TINY_JSON_H_

  1 #pragma once
  2 
  3 #include "tinyjson.hpp"
  4 #include <string>
  5 #include <iostream>
  6 #include <cassert>
  7 using namespace std;
  8 using namespace tiny;
  9 
 10 string jsonstring = "\
 11 { 12     \"name\":\"lier  gou\",\
 13     \"age\" : 26.9,\
 14     \"data\" : [\
 15     { 16         \"one\":\"chenone\",\
 17         \"two\" : {\
 18             \"love1\":\"2233\",\
 19             \"love2\":44444\
 20         } 21     }, 22     { 23         \"one\":\"chen22\",\
 24         \"two\" : {\
 25             \"love1\":\"8899\",\
 26             \"love2\":10000\
 27         } 28     } 29     ], 30     \"lang\":\"2cpp\"\
 31 } 32 ";
 33 
 34 string jsonstring2 = "\
 35 { 36     \"name\":\"liergou\",\
 37     \"age\" : 26.9,\
 38     \"data\" : [\
 39     { 40         \"one\":\"chenone\",\
 41         \"two\" : [\
 42             \"love_chen\",\
 43             \"love_hui\"\
 44         ] 45     }, 46     { 47         \"one\":\"chen22\",\
 48         \"two\" : [\
 49             \"love_chen2\",\
 50             \"love_hui2\"\
 51         ] 52     } 53     ], 54     \"lang\":\"cpp\"\
 55 } 56 ";
 57 
 58 string jsonstring3 = "\
 59 { 60     \"xx\": {\
 61         \"a\": 1,\
 62         \"b\" : 2\
 63     } 64 }";
 65 
 66 // read demo
 67 void TEST99() {
 68     cout << "\nTEST 99 READ JSON" << endl;
 69     // read
 70     TinyJson json;
 71     json.ReadJson(jsonstring3);
 72 
 73     xobject data = json.Get<xobject>("xx");
 74     for (int i = 0; i < data.Count(); i++) {
 75         data.Enter(i);
 76         int one = data.Get<int>("a");
 77         int two = data.Get<int>("b");
 78         int three = data.Get<int>("c", 99);
 79         assert(one == 1);
 80         assert(two == 2);
 81         assert(three == 99);
 82     }
 83     cout << "TEST 99 PASS" << endl;
 84 }
 85 
 86 
 87 // read demo
 88 void TEST1() {
 89     cout << "\nTEST 1 READ JSON" << endl;
 90     // read
 91     TinyJson json;
 92     json.ReadJson(jsonstring);
 93 
 94     string name = json.Get<string>("name");
 95     float age = json.Get<float>("age");
 96     string lang = json.Get<string>("lang");
 97 
 98     assert(name == "lier  gou");
 99     assert(age > 26 && age < 27);
100     assert(lang == "2cpp");
101 
102     xarray data = json.Get<xarray>("data");
103     for (int i = 0; i < data.Count(); i++) {
104         data.Enter(i);
105         string one = data.Get<string>("one");
106         if (i == 0)
107         {
108             assert(one == "chenone");
109         }
110         if (i == 1)
111         {
112             assert(one == "chen22");
113         }
114         xobject two = data.Get<xobject>("two");
115         for (int ii = 0; ii < two.Count(); ii++) {
116             two.Enter(ii);
117             string love1 = two.Get<string>("love1");
118             int love2 = two.Get<int>("love2");
119             if (i == 0)
120             {
121                 assert(love1 == "2233");
122                 assert(love2 == 44444);
123             }
124             if (i == 1)
125             {
126                 assert(love1 == "8899");
127                 assert(love2 == 10000);
128             }
129 
130         }
131     }
132     cout << "TEST 1 PASS" << endl;
133 }
134 
135 // read demo
136 void TEST2() {
137     cout << "\nTEST 2 READ JSON" << endl;
138     // read
139     TinyJson json;
140     json.ReadJson(jsonstring2);
141 
142     string name = json.Get<string>("name");
143     float age = json.Get<float>("age");
144     string lang = json.Get<string>("lang");
145 
146     assert(name == "liergou");
147     assert(age > 26 && age < 27);
148     assert(lang == "cpp");
149 
150     xarray data = json.Get<xarray>("data");
151     for (int i = 0; i < data.Count(); i++) {
152         data.Enter(i);
153         string one = data.Get<string>("one");
154         if (i == 0)
155         {
156             assert(one == "chenone");
157         }
158         if (i == 1)
159         {
160             assert(one == "chen22");
161         }
162         xarray two = data.Get<xarray>("two");
163         for (int ii = 0; ii < two.Count(); ii++) {
164             two.Enter(ii);
165             string val = two.Get<string>();
166             if (i == 0 && ii == 0)
167             {
168                 assert(val == "love_chen");
169             }
170             if (i == 0 && ii == 1)
171             {
172                 assert(val == "love_hui");
173             }
174             if (i == 1 && ii == 0)
175             {
176                 assert(val == "love_chen2");
177             }
178             if (i == 1 && ii == 1)
179             {
180                 assert(val == "love_hui2");
181             }
182         }
183     }
184     cout << "TEST 2 PASS" << endl;
185 }
186 
187 // write demo TEST3()
188 
189 /*   write result
190 
191 {
192     "name": "liergou",
193     "age": 26,
194     "handsome": true,
195     "data": {
196         "love1": "book",
197         "love2": 666
198     },
199     "data2": {
200         "love1": "book2",
201         "love2": 6662
202     }
203 }
204 
205 */
206 
207 void TEST3() {
208     cout << "\nTEST 3 WRITE JSON" << endl;
209     // write
210     TinyJson wjson;
211     wjson["name"].Set("liergou");
212     wjson["age"].Set(26);
213     wjson["handsome"].Set(true);
214 
215     TinyJson subjson;
216     subjson["love1"].Set("book");
217     subjson["love2"].Set(666);
218 
219     TinyJson subjson2;
220     subjson2["love1"].Set("book2");
221     subjson2["love2"].Set(6662);
222 
223     wjson["data"].Set(subjson);
224     wjson["data2"].Set(subjson2);
225 
226     string str = wjson.WriteJson();
227     cout << "json string: \r\n" << endl;
228     cout << str << endl;
229 }
230 
231 // write demo TEST4()
232 
233 /*   write result
234 
235 {
236     "name": "liergou",
237     "age" : 26,
238     "handsome" : true,
239     "data" : [
240       {
241         "love1": "book",
242         "love2" : 666
243       },
244       {
245         "love1": "book2",
246         "love2" : 6662
247       }
248     ]
249 }
250 
251 */
252 
253 void TEST4() {
254     cout << "\nTEST 4 WRITE JSON" << endl;
255     // write
256     TinyJson wjson;
257     wjson["name"].Set("liergou");
258     wjson["age"].Set(26);
259     wjson["handsome"].Set(true);
260 
261     TinyJson subjson;
262     subjson["love1"].Set("book");
263     subjson["love2"].Set(666);
264 
265     TinyJson subjson2;
266     subjson2["love1"].Set("book2");
267     subjson2["love2"].Set(6662);
268 
269     TinyJson jsonarray;
270     jsonarray.Push(subjson);
271     jsonarray.Push(subjson2);
272 
273     wjson["data"].Set(jsonarray);
274 
275     string str = wjson.WriteJson();
276     cout << "json string: \r\n" << endl;
277     cout << str << endl;
278 }
279 
280 // write demo TEST5()
281 
282 /*   write result
283 
284 {
285     "name": "liergou",
286     "age" : 26,
287     "handsome" : true,
288     "data" : [
289          "book",
290          666
291     ]
292 }
293 
294 */
295 
296 void TEST5() {
297     cout << "\nTEST 5 WRITE JSON" << endl;
298     // write
299     TinyJson wjson;
300     wjson["name"].Set("liergou");
301     wjson["age"].Set(26);
302     wjson["handsome"].Set(true);
303 
304     TinyJson subjson;
305     subjson[""].Set("book");
306     subjson[""].Set(666);
307 
308     TinyJson jsonarray;
309     jsonarray.Push(subjson);
310 
311     wjson["data"].Set(jsonarray);
312 
313     string str = wjson.WriteJson();
314     cout << "json string: \r\n" << endl;
315     cout << str << endl;
316 }