acl  3.5.3.0
gson_helper.ipp
浏览该文件的文档.
1 /**
2  * Copyright (C) 2015-2018
3  * All rights reserved.
4  *
5  * AUTHOR(S)
6  * E-mail: "fuwangqini" niukey@qq.com
7  * 2017.5.13 fixed one bug by "lindawei" <672496008@qq.com>
8  *
9  * VERSION
10  * Sat 08 Oct 2016 09:07:14 PM CST
11  */
12 
13 #pragma once
14 #include "../acl_cpp_define.hpp"
15 #include "../stdlib/string.hpp"
16 #include "../stdlib/json.hpp"
17 #include "../stdlib/string.hpp"
18 #include <set>
19 namespace acl
20 {
21 
22 ///////////////////////////////////type_traits////////////////////////////////
23 
24 struct true_type
25 {
26  static const bool value = true;
27 };
28 
29 struct false_type
30 {
31  static const bool value = false;
32 };
33 
34 template<class T>
35 struct remove_const
36 {
37  typedef T type;
38 };
39 
40 template<class T>
41 struct remove_const<const T>
42 {
43  typedef T type;
44 };
45 
46 template<class T>
47 struct remove_volatile
48 {
49  typedef T type;
50 };
51 
52 template<class T>
53 struct remove_volatile<volatile T>
54 {
55  typedef T type;
56 };
57 
58 template<class T>
59 struct remove_cv
60 {
61  typedef typename remove_const
62  <typename remove_volatile<T>::type>::type type;
63 };
64 
65 //remove_pointer
66 template<class T>
67 struct remove_pointer
68 {
69  typedef T type;
70 };
71 
72 template<class T>
73 struct remove_pointer<T *>
74 {
75  typedef T type;
76 };
77 
78 template<class T>
79 struct remove_pointer<T *const>
80 {
81  typedef T type;
82 };
83 
84 template<class T>
85 struct remove_pointer<T *volatile>
86 {
87  typedef T type;
88 };
89 
90 template<class T>
91 struct remove_pointer<T *const volatile>
92 {
93  typedef T type;
94 };
95 
96 template<bool ,
97  class T = void>
98  struct enable_if
99 {
100 };
101 
102 template<class T>
103 struct enable_if<true, T>
104 {
105  typedef T type;
106 };
107 
108 //_Is_number
109 template<class T>
110 struct _Is_number : false_type
111 {
112 };
113 
114 template<>
115 struct _Is_number<unsigned short> : true_type
116 {
117 };
118 
119 template<>
120 struct _Is_number<signed short> : true_type
121 {
122 };
123 
124 template<>
125 struct _Is_number<unsigned int> : true_type
126 {
127 };
128 
129 template<>
130 struct _Is_number<signed int> : true_type
131 {
132 };
133 
134 template<>
135 struct _Is_number<unsigned long> : true_type
136 {
137 };
138 
139 template<>
140 struct _Is_number<signed long> : true_type
141 {
142 };
143 
144 template<>
145 struct _Is_number<long long> : true_type
146 {
147 };
148 
149 template<>
150 struct _Is_number<unsigned long long> : true_type
151 {
152 };
153 
154 #if 0
155 template<>
156 struct _Is_number<size_t> : true_type
157 {
158 };
159 
160 template<>
161 struct _Is_number<ssize_t> : true_type
162 {
163 };
164 #endif
165 
166 template<class T>
167 struct is_number : _Is_number<typename remove_cv<T>::type>
168 {
169 };
170 
171 //string
172 template<class T>
173 struct _Is_string : false_type
174 {
175 };
176 
177 template<>
178 struct _Is_string<std::string> : true_type
179 {
180 };
181 
182 template<>
183 struct _Is_string<acl::string> : true_type
184 {
185 };
186 
187 template<class T>
188 struct is_string : _Is_string<typename remove_cv<T>::type>
189 {
190 };
191 
192 //double
193 template<class T>
194 struct _Is_double : false_type
195 {
196 };
197 
198 template<>
199 struct _Is_double<float> : true_type
200 {
201 };
202 
203 template<>
204 struct _Is_double<double> : true_type
205 {
206 };
207 
208 template<>
209 struct _Is_double<long double> : true_type
210 {
211 };
212 
213 template <class T>
214 struct is_double : _Is_double<typename remove_const<T>::type>
215 {
216 };
217 
218 //char ptr. c string in cpp
219 template<class T>
220 struct _Is_char_ptr : false_type
221 {
222 };
223 
224 template<>
225 struct _Is_char_ptr<char*> : true_type
226 {
227 };
228 
229 template<class T>
230 struct is_char_ptr :_Is_char_ptr<typename remove_cv<T>::type>
231 {
232 };
233 
234 template<class T>
235 struct _Is_bool : false_type
236 {
237 };
238 
239 template<>
240 struct _Is_bool<bool> : true_type
241 {
242 };
243 
244 template<class T>
245 struct is_bool : _Is_bool<typename remove_cv<T>::type>
246 {
247 };
248 
249 template<bool T>
250 struct _Is_object :false_type
251 {
252 };
253 
254 template<>
255 struct _Is_object<true> : true_type
256 {
257 };
258 
259 template<class T>
260 struct is_object : _Is_object<
261  !is_string<T>::value &&
262  !is_double<T>::value &&
263  !is_number<T>::value &&
264  !is_bool<T>::value &&
265  !is_char_ptr<T>::value>
266 {
267 };
268 
269 template <class T>
270 static inline bool check_nullptr(T&)
271 {
272  return false;
273 }
274 
275 template<class T>
276 static inline bool check_nullptr(T *t)
277 {
278  if (t == NULL)
279  return true;
280  return false;
281 }
282 
283 //acl::string ,std::string
284 template<class T>
285 typename enable_if<is_string<T>::value, const char *>::type
286 static inline get_value(const T &value)
287 {
288  return value.c_str();
289 }
290 
291 template<class T>
292 typename enable_if<is_string<T>::value, const char *>::type
293 static inline get_value(const T *value)
294 {
295  return value->c_str();
296 }
297 
298 //char *,const char *
299 static inline const char *get_value(const char *value)
300 {
301  return value;
302 }
303 
304 //bool
305 static inline bool get_value(const bool value)
306 {
307  return value;
308 }
309 
310 static inline bool get_value(const bool* value)
311 {
312  return *value;
313 }
314 
315 //number
316 template <class T>
317 typename enable_if<is_number<T>::value, T>::type
318 static inline get_value(const T t)
319 {
320  return t;
321 }
322 
323 // number pointor -> number
324 // eg: int * -> int .
325 template <class T>
326 typename enable_if<is_number<T>::value, T>::type
327 static inline get_value(const T *t)
328 {
329  return *t;
330 }
331 
332 template <class T>
333 typename enable_if<is_double<T>::value, T>::type
334 static inline get_value(const T &t)
335 {
336  return t;
337 }
338 
339 template <class T>
340 typename enable_if<is_double<T>::value, T>::type
341 static inline get_value(const T *t)
342 {
343  return *t;
344 }
345 
346 // obj
347 template<class T>
348 typename enable_if<is_object<T>::value, void>::type
349 static inline add_item(acl::json &json, acl::json_node &node, const T &obj)
350 {
351  if(check_nullptr(obj))
352  node.add_array_null();
353  else
354  node.add_child(gson(json, obj));
355 }
356 
357 // number
358 template<class T>
359 typename enable_if<is_number<T>::value, void>::type
360 static inline add_item(acl::json &, acl::json_node &node, T value)
361 {
362  node.add_array_number(get_value(value));
363 }
364 
365 template<class T>
366 typename enable_if<is_number<T>::value, void>::type
367 static inline add_item(acl::json &, acl::json_node &node, T *value)
368 {
369  if (check_nullptr(value))
370  node.add_array_null();
371  else
372  node.add_array_number(get_value(value));
373 }
374 
375 template<class T>
376 typename enable_if<is_double<T>::value, void>::type
377 static inline add_item(acl::json &, acl::json_node &node, T value)
378 {
379  node.add_array_double(get_value(value));
380 }
381 
382 template<class T>
383 typename enable_if<is_double<T>::value, void>::type
384 static inline add_item(acl::json &, acl::json_node &node, T* value)
385 {
386  if(check_nullptr(value))
387  node.add_array_null();
388  else
389  node.add_array_double(get_value(value));
390 }
391 
392 //bool
393 template<class T>
394 typename enable_if<is_bool<T>::value, void>::type
395 static inline add_item(acl::json &, acl::json_node &node, T *value)
396 {
397  if (check_nullptr(value))
398  node.add_array_null();
399  else
400  node.add_array_bool(get_value(value));
401 }
402 
403 template<class T>
404 typename enable_if<is_bool<T>::value, void>::type
405 static inline add_item(acl::json &, acl::json_node &node, T value)
406 {
407  node.add_array_bool(get_value(value));
408 }
409 
410 template<class T>
411 typename enable_if<is_string<T>::value, void>::type
412 static inline add_item(acl::json &, acl::json_node &node, T value)
413 {
414  node.add_array_text(get_value(value));
415 }
416 
417 template<class T>
418 typename enable_if<is_string<T>::value, void>::type
419 static inline add_item(acl::json &, acl::json_node &node, T *value)
420 {
421  if (check_nullptr(value))
422  node.add_array_null();
423  else
424  node.add_array_text(get_value(value));
425 }
426 
427 static inline void add_item(acl::json &, acl::json_node &node, char *value)
428 {
429  if (check_nullptr(value))
430  node.add_array_null();
431  else
432  node.add_array_text(value);
433 }
434 //list
435 template<class T>
436 static inline acl::json_node &gson(acl::json &json,
437  const std::list<T> &objects)
438 {
439  acl::json_node &node = json.create_array();
440  for (typename std::list<T>::const_iterator
441  itr = objects.begin(); itr != objects.end(); ++itr)
442  {
443  add_item(json, node, *itr);
444  }
445 
446  return node;
447 }
448 template<class T>
449 static inline acl::json_node &gson(acl::json &json,
450  const std::list<T> *objects)
451 {
452  return gson(json, *objects);
453 }
454 
455 //vector
456 template<class T>
457 static inline acl::json_node &gson(acl::json &json,
458  const std::vector<T> &objects)
459 {
460  acl::json_node &node = json.create_array();
461  for (typename std::vector<T>::const_iterator
462  itr = objects.begin(); itr != objects.end(); ++itr)
463  {
464  add_item(json, node, *itr);
465  }
466 
467  return node;
468 }
469 
470 template<class T>
471 static inline acl::json_node &gson(acl::json &json,
472  const std::vector<T> *objects)
473 {
474  return gson(json, *objects);
475 }
476 //set
477 template<class T>
478 static inline acl::json_node &gson(acl::json &json, const std::set<T> *objects)
479 {
480  return gson(json, *objects);
481 }
482 
483 template<class T>
484 static inline acl::json_node &gson(acl::json &json,
485  const std::set<T> &objects)
486 {
487  acl::json_node &node = json.create_array();
488  for (typename std::set<T>::const_iterator
489  itr = objects.begin(); itr != objects.end(); ++itr)
490  {
491  add_item(json, node, *itr);
492  }
493 
494  return node;
495 }
496 
497 //define number map
498 template<class K, class V>
499 typename enable_if<is_number<V>::value, acl::json_node &>::type
500 static inline gson(acl::json &json, const std::map<K, V> &objects)
501 {
502  acl::json_node &node = json.create_array();
503  for (typename std::map<K, V>::const_iterator
504  itr = objects.begin(); itr != objects.end(); ++itr)
505  {
506  const char *tag = get_value(itr->first);
507  if (check_nullptr(itr->second))
508  node.add_child(json.create_node().add_null(tag));
509  else
510  node.add_child(json.create_node()
511  .add_number(tag, get_value(itr->second)));
512  }
513 
514  return node;
515 }
516 
517 //define number map
518 template<class K, class V>
519 typename enable_if< is_number<V>::value, acl::json_node &>::type
520 static inline gson(acl::json &json, const std::map<K, V> *objects)
521 {
522  acl::json_node &node = json.create_array();
523  for (typename std::map<K, V>::const_iterator
524  itr = objects->begin(); itr != objects->end(); ++itr)
525  {
526  const char *tag = get_value(itr->first);
527  if (check_nullptr(itr->second))
528  node.add_child(json.create_node().add_null(tag));
529  else
530  node.add_child(json.create_node()
531  .add_number(tag, get_value(itr->second)));
532  }
533 
534  return node;
535 }
536 
537 //define floating map
538 template<class K, class V>
539 typename enable_if<is_double<V>::value, acl::json_node &>::type
540 static inline gson(acl::json &json, const std::map<K, V> &objects)
541 {
542  acl::json_node &node = json.create_array();
543  for (typename std::map<K, V>::const_iterator
544  itr = objects.begin(); itr != objects.end(); ++itr)
545  {
546  const char *tag = get_value(itr->first);
547  if (check_nullptr(itr->second))
548  node.add_child(json.create_node().add_null(tag));
549  else
550  node.add_child(json.create_node()
551  .add_double(tag, get_value(itr->second)));
552  }
553 
554  return node;
555 }
556 
557 template<class K, class V>
558 typename enable_if<is_double<V>::value, acl::json_node &>::type
559 static inline gson(acl::json &json, const std::map<K, V> *objects)
560 {
561  acl::json_node &node = json.create_array();
562  for (typename std::map<K, V>::const_iterator
563  itr = objects->begin(); itr != objects->end(); ++itr)
564  {
565  const char *tag = get_value(itr->first);
566  if (check_nullptr(itr->second))
567  node.add_child(json.create_node().add_null(tag));
568  else
569  node.add_child(json.create_node()
570  .add_double(tag, get_value(itr->second)));
571  }
572 
573  return node;
574 }
575 
576 //define bool map
577 template<class K, class V>
578 typename enable_if<is_bool<V>::value, acl::json_node &>::type
579 static inline gson(acl::json &json, const std::map<K, V> &objects)
580 {
581  acl::json_node &node = json.create_array();
582  for (typename std::map<K, V>::const_iterator itr = objects.begin();
583  itr != objects.end(); ++itr)
584  {
585  const char *tag = get_value(itr->first);
586  if (check_nullptr(itr->second))
587  node.add_child(json.create_node().add_null(tag));
588  else
589  node.add_child(json.create_node()
590  .add_bool(tag, itr->second));
591  }
592 
593  return node;
594 }
595 
596 template<class K, class V>
597 typename enable_if<is_string<V>::value
598  || is_char_ptr<V>::value, acl::json_node &>::type
599 static inline gson(acl::json &json, const std::map<K, V> & objects)
600 {
601  acl::json_node &node = json.create_array();
602  for (typename std::map<K, V>::const_iterator
603  itr = objects.begin(); itr != objects.end(); ++itr)
604  {
605  const char *tag = get_value(itr->first);
606  if (check_nullptr(itr->second))
607  node.add_child(json.create_node().add_null(tag));
608  else
609  node.add_child(json.create_node()
610  .add_text(tag, get_value(itr->second)));
611  }
612 
613  return node;
614 }
615 
616 template<class K, class V>
617 typename enable_if<is_string<V>::value
618  || is_char_ptr<V>::value, acl::json_node &>::type
619 static inline gson(acl::json &json, const std::map<K, V*> & objects)
620 {
621  acl::json_node &node = json.create_array();
622  for (typename std::map<K, V*>::const_iterator
623  itr = objects.begin(); itr != objects.end(); ++itr)
624  {
625  const char *tag = get_value(itr->first);
626  if (check_nullptr(itr->second))
627  node.add_child(json.create_node().add_null(tag));
628  else
629  node.add_child(json.create_node()
630  .add_text(tag, get_value(itr->second)));
631  }
632 
633  return node;
634 }
635 
636 template<class T, class V>
637 typename enable_if<is_object<V>::value, acl::json_node &>::type
638 static inline gson(acl::json &json, const std::map<T, V> &objects)
639 {
640  acl::json_node &node = json.create_array();
641  for (typename std::map<T, V>::const_iterator
642  itr = objects.begin(); itr != objects.end(); ++itr)
643  {
644  const char *tag = get_value(itr->first);
645  if (check_nullptr(itr->second))
646  node.add_child(json.create_node().add_null(tag));
647  else
648  {
649  acl::json_node &item = gson(json, itr->second);
650  node.add_child(json.create_node()
651  .add_child(tag, item));
652  }
653  }
654 
655  return node;
656 }
657 
658 template<class T, class V>
659 typename enable_if<is_object<V>::value, acl::json_node &>::type
660 static inline gson(acl::json &json, const std::map<T, V> *objects)
661 {
662  return gson(json, *objects);
663 }
664 
665 template<class T, class V>
666 typename enable_if<is_object<V>::value, acl::json_node &>::type
667 static inline gson(acl::json &json, const std::map<T, V*> &objects)
668 {
669  acl::json_node &node = json.create_array();
670  for (typename std::map<T, V*>::const_iterator
671  itr = objects.begin(); itr != objects.end(); ++itr)
672  {
673  const char *tag = get_value(itr->first);
674  if (check_nullptr(itr->second))
675  node.add_child(json.create_node().add_null(tag));
676  else
677  {
678  acl::json_node &item = gson(json, itr->second);
679  node.add_child(json.create_node()
680  .add_child(tag, item));
681  }
682  }
683 
684  return node;
685 }
686 
687 template<class T, class V>
688 typename enable_if<is_object<V>::value, acl::json_node &>::type
689 static inline gson(acl::json &json, const std::map<T, V*> *objects)
690 {
691  return gson(json, *objects);
692 }
693 
694 //////////////////////////////////////////////////////////////////////////////
695 
696 #if 0
697 template <class T>
698 typename enable_if<is_object<T>::value,
699  std::pair<bool, std::string> >::type
700 static inline gson(acl::json_node &node, T **obj);
701 #endif
702 
703 template<class T>
704 static inline void del(T **obj)
705 {
706  delete *obj;
707  *obj = NULL;
708 }
709 
710 template<class T>
711 static inline void del(T *obj)
712 {
713  (void) obj;
714 }
715 
716 //bool
717 static inline std::pair<bool, std::string>
718 gson(acl::json_node &node, bool *obj)
719 {
720  if (node.is_bool() == false)
721  return std::make_pair(false, "get bool failed");
722 
723  *obj = *node.get_bool();
724  return std::make_pair(true, "");
725 }
726 
727 static inline std::pair<bool, std::string>
728 gson(acl::json_node &node, bool **obj)
729 {
730  *obj = NULL;
731  if (node.is_bool() == false)
732  return std::make_pair(false, "get bool failed");
733 
734  *obj = new bool;
735  **obj = *node.get_bool();
736 
737  return std::make_pair(true, "");
738 }
739 
740 //double
741 template <class T>
742 typename enable_if<is_double<T>::value,
743  std::pair<bool, std::string> >::type
744 static inline gson(acl::json_node &node, T *obj)
745 {
746  if (node.is_double() == false)
747  return std::make_pair(false, "get double failed");
748 
749  *obj = static_cast<T>(*node.get_double());
750  return std::make_pair(true, "");
751 }
752 
753 template <class T>
754 typename enable_if<is_double<T>::value,
755  std::pair<bool, std::string> >::type
756 static inline gson(acl::json_node &node, T **obj)
757 {
758  *obj = NULL;
759  if (node.is_double() == false)
760  return std::make_pair(false, "get double failed");;
761 
762  *obj = new T;
763  **obj = static_cast<T>(*node.get_double());
764 
765  return std::make_pair(true, "");
766 }
767 
768 //intergral
769 template <class T>
770 typename enable_if<is_number<T>::value,
771  std::pair<bool, std::string> >::type
772 static inline gson(acl::json_node &node, T *obj)
773 {
774  if (node.is_number() == false)
775  return std::make_pair(false, "get number failed");
776 
777  *obj = static_cast<T>(*node.get_int64());
778  return std::make_pair(true, "");
779 }
780 
781 template <class T>
782 typename enable_if<is_number<T>::value,
783  std::pair<bool, std::string> >::type
784 static inline gson(acl::json_node &node, T **obj)
785 {
786  *obj = NULL;
787  if (node.is_number() == false)
788  return std::make_pair(false, "get number failed");;
789 
790  *obj = new T;
791  **obj = static_cast<T>(*node.get_int64());
792 
793  return std::make_pair(true, "");
794 }
795 
796 //string
797 static inline std::pair<bool, std::string>
798 gson(acl::json_node &node, char **obj)
799 {
800  *obj = NULL;
801  if (node.is_string() == false)
802  return std::make_pair(false, "get char * string failed");
803 
804  int len = (int) strlen(node.get_string());
805  *obj = new char[len + 1];
806  memcpy(*obj, node.get_string(), len);
807  (*obj)[len] = 0;
808 
809  return std::make_pair(true, "");
810 }
811 
812 static inline std::pair<bool, std::string>
813 gson(acl::json_node &node, acl::string &obj)
814 {
815  if (node.is_string() == false)
816  return std::make_pair(false, "get string failed");
817  obj.clear();
818  obj.append(node.get_string());
819 
820  return std::make_pair(true, "");
821 }
822 
823 static inline std::pair<bool, std::string>
824 gson(acl::json_node &node, acl::string *obj)
825 {
826  if (node.is_string() == false)
827  return std::make_pair(false, "get string failed");
828  obj->clear();
829  obj->append(node.get_string());
830  return std::make_pair(true, "");
831 }
832 
833 static inline std::pair<bool, std::string>
834 gson(acl::json_node &node, acl::string **obj)
835 {
836  *obj = NULL;
837  if (node.is_string() == false)
838  return std::make_pair(false, "get string failed");
839 
840  *obj = new acl::string;
841  (*obj)->append(node.get_string());
842 
843  return std::make_pair(true, "");
844 }
845 
846 static inline std::pair<bool, std::string>
847 gson(acl::json_node &node, std::string &obj)
848 {
849  if (node.is_string() == false)
850  return std::make_pair(false, "get string failed");
851  obj.clear();
852  obj.append(node.get_string());
853  return std::make_pair(true, "");
854 }
855 
856 static inline std::pair<bool, std::string>
857 gson(acl::json_node &node, std::string *obj)
858 {
859  if (node.is_string() == false)
860  return std::make_pair(false, "get string failed");
861  obj->clear();
862  obj->append(node.get_string());
863  return std::make_pair(true, "");
864 }
865 
866 static inline std::pair<bool, std::string>
867 gson(acl::json_node &node, std::string **obj)
868 {
869  *obj = NULL;
870  if (node.is_string() == false)
871  return std::make_pair(false, "get string failed");
872 
873  *obj = new std::string;
874  (*obj)->append(node.get_string());
875 
876  return std::make_pair(true, "");
877 }
878 
879 // list
880 template<class T>
881 static inline std::pair<bool, std::string>
882 gson(acl::json_node &node, std::list<T> *objs)
883 {
884  std::pair<bool, std::string> result;
885  acl::json_node *itr = node.first_child();
886 
887  if (itr == NULL)
888  {
889  // maybe the vector is empty ---zsx
890  objs->clear();
891  return std::make_pair(true, "");
892  }
893 
894  while (itr)
895  {
896  // for avoiding object's member pointor copy, the obj can be
897  // put in list first, when error happened just only erase it.
898  // ---lindawei
899 
900  objs->push_back(T());
901  typename std::list<T>::iterator it = objs->end();
902  --it;
903  result = gson(*itr, &*it);
904  if (!result.first)
905  {
906  break;
907  }
908  itr = node.next_child();
909  }
910  if (result.first)
911  return result;
912 
913  objs->clear();
914  return result;
915 }
916 
917 // list
918 template<class T>
919 static inline std::pair<bool, std::string>
920 gson(acl::json_node &node, std::list<T*> *objs)
921 {
922  std::pair<bool, std::string> result;
923  acl::json_node *itr = node.first_child();
924 
925  if (itr == NULL)
926  {
927  // maybe the vector is empty ---zsx
928  objs->clear();
929  return std::make_pair(true, "");
930  }
931 
932  while (itr)
933  {
934  T* obj = new T;
935  objs->push_back(obj);
936  result = gson(*itr, obj);
937  if (!result.first)
938  {
939  break;
940  }
941  itr = node.next_child();
942  }
943  if(objs->size())
944  {
945  delete *objs->begin();
946  objs->pop_front();
947  }
948  return result;
949 }
950 
951 // vector
952 template<class T>
953 std::pair<bool, std::string>
954 static inline gson(acl::json_node &node, std::vector<T> *objs)
955 {
956  std::pair<bool, std::string> result;
957  acl::json_node *itr = node.first_child();
958 
959  if (itr == NULL)
960  {
961  // maybe the vector is empty ---zsx
962  objs->clear();
963  return std::make_pair(true, "");
964  }
965 
966  while (itr)
967  {
968  // for avoiding object's member pointor copy
969  // ---lindawei
970 
971  objs->push_back(T());
972  typename std::vector<T>::iterator it = objs->end();
973  --it;
974  result = gson(*itr, &*it);
975  if (!result.first)
976  break;
977  itr = node.next_child();
978  }
979  if(result.first)
980  return result;
981  objs->clear();
982  return result;
983 }
984 
985 // vector
986 template<class T>
987 std::pair<bool, std::string>
988 static inline gson(acl::json_node &node, std::vector<T*> *objs)
989 {
990  std::pair<bool, std::string> result;
991  acl::json_node *itr = node.first_child();
992 
993  if (itr == NULL)
994  {
995  // maybe the vector is empty ---zsx
996  objs->clear();
997  return std::make_pair(true, "");
998  }
999 
1000  while (itr)
1001  {
1002  T* obj = new T;
1003  objs->push_back(obj);
1004  typename std::vector<T*>::iterator it = objs->end();
1005  --it;
1006  result = gson(*itr, *it);
1007  if (!result.first)
1008  {
1009  break;
1010  }
1011  itr = node.next_child();
1012  }
1013  if(result.first)
1014  return result;
1015 
1016  while(objs->size())
1017  {
1018  T *obj = (*objs)[0];
1019  delete obj;
1020  objs->pop_back();
1021  }
1022  return result;
1023 }
1024 
1025 //set
1026 template<class T>
1027 std::pair<bool, std::string>
1028 static inline gson(acl::json_node &node, std::set<T*> *objs)
1029 {
1030  std::pair<bool, std::string> result;
1031  acl::json_node *itr = node.first_child();
1032 
1033  if (itr == NULL)
1034  {
1035  // maybe the vector is empty ---zsx
1036  objs->clear();
1037  return std::make_pair(true, "");
1038  }
1039 
1040  while (itr)
1041  {
1042  T* obj = new T;
1043  result = gson(*itr, obj);
1044  if (!result.first)
1045  {
1046  delete obj;
1047  break;
1048  }
1049  objs->insert(obj);
1050  itr = node.next_child();
1051  }
1052 
1053  if (result.first)
1054  return result;
1055 
1056  while(objs->size())
1057  {
1058  T* obj = *objs->begin();
1059  objs->erase(objs->begin());
1060  delete obj;
1061  }
1062  return result;
1063 }
1064 
1065 template<class T>
1066 std::pair<bool, std::string>
1067 static inline gson(acl::json_node &node, std::set<T> *objs)
1068 {
1069  std::pair<bool, std::string> result;
1070  acl::json_node *itr = node.first_child();
1071 
1072  if (itr == NULL)
1073  {
1074  // maybe the vector is empty ---zsx
1075  objs->clear();
1076  return std::make_pair(true, "");
1077  }
1078 
1079  while (itr)
1080  {
1081  T obj = T();
1082  result = gson(*itr, &obj);
1083  if (!result.first)
1084  {
1085  break;
1086  }
1087  objs->insert(obj);
1088  itr = node.next_child();
1089  }
1090 
1091  if (result.first)
1092  return result;
1093 
1094  objs->clear();
1095  return result;
1096 }
1097 
1098 template <class T>
1099 typename enable_if<is_object<T>::value,
1100  std::pair<bool, std::string> >::type
1101 static inline gson(acl::json_node &node, T **obj)
1102 {
1103  *obj = new T();
1104  std::pair<bool, std::string> result = gson(node, *obj);
1105  if (result.first == false)
1106  {
1107  delete *obj;
1108  *obj = NULL;
1109  }
1110 
1111  return result;
1112 }
1113 
1114 ///////////////////////////////////////////map////////////////////////////////
1115 
1116 // int map
1117 template<class K, class T>
1118 typename enable_if<
1119  is_string<T>::value||
1120  is_bool<T>::value||
1121  is_number<T>::value||
1122  is_double<T>::value||
1123  is_char_ptr<T>::value,
1124  std::pair<bool, std::string> >::type
1125 static inline expand(acl::json_node &node, std::map<K, T> *objs)
1126 {
1127  std::pair<bool, std::string> result;
1128  acl::json_node *itr = node.first_child();
1129  while (itr)
1130  {
1131  T obj;
1132  result = gson(*itr, &obj);
1133  if (!result.first)
1134  break;
1135 
1136  objs->insert(std::make_pair(K(itr->tag_name()), obj));
1137  itr = node.next_child();
1138  }
1139 
1140  if (result.first)
1141  return std::make_pair(true, "");
1142 
1143  for (typename std::map<K, T>::iterator it = objs->begin();
1144  it != objs->end(); ++it)
1145  {
1146  del(&it->second);
1147  }
1148 
1149  objs->clear();
1150  return result;
1151 }
1152 
1153 template<class K, class T>
1154 typename enable_if <is_object<T>::value ,
1155  std::pair<bool, std::string > > ::type
1156 static inline expand(acl::json_node &node, std::map<K, T> *objs)
1157 {
1158  std::pair<bool, std::string> result;
1159  acl::json_node *itr = node.first_child();
1160 
1161  while (itr && itr->get_obj())
1162  {
1163  T obj;
1164  result = gson(*(itr->get_obj()), &obj);
1165  if (!result.first)
1166  break;
1167 
1168  objs->insert(std::make_pair(K(itr->tag_name()), obj));
1169  itr = node.next_child();
1170  }
1171 
1172  if (result.first)
1173  return std::make_pair(true, "");
1174 
1175  for (typename std::map<K, T>::iterator itr2 = objs->begin();
1176  itr2 != objs->end(); ++itr2)
1177  {
1178  del(&itr2->second);
1179  }
1180 
1181  objs->clear();
1182  return result;
1183 }
1184 
1185 // map
1186 template<class K, class V>
1187 std::pair<bool, std::string>
1188 static inline gson(acl::json_node &node, std::map<K, V> *objs)
1189 {
1190  std::pair<bool, std::string> result;
1191  acl::json_node *itr = node.first_child();
1192  std::string error_string;
1193 
1194  while (itr)
1195  {
1196  result = expand(*itr, objs);
1197  if (result.first == false)
1198  error_string.append(result.second);
1199  itr = node.next_child();
1200  }
1201 
1202  return std::make_pair(!!!objs->empty(), error_string);
1203 }
1204 
1205 template<class K, class T>
1206 typename enable_if<
1207  is_string<T>::value||
1208  is_bool<T>::value||
1209  is_number<T>::value||
1210  is_double<T>::value||
1211  is_char_ptr<T>::value,
1212  std::pair<bool, std::string> >::type
1213 static inline expand(acl::json_node &node, std::map<K, T*> *objs)
1214 {
1215  std::pair<bool, std::string> result;
1216  acl::json_node *itr = node.first_child();
1217  while (itr)
1218  {
1219  T* obj = new T;
1220  result = gson(*itr, obj);
1221  if (!result.first)
1222  break;
1223 
1224  objs->insert(std::make_pair(K(itr->tag_name()), obj));
1225  itr = node.next_child();
1226  }
1227 
1228  if (result.first)
1229  return std::make_pair(true, "");
1230 
1231  for (typename std::map<K, T*>::iterator it = objs->begin();
1232  it != objs->end(); ++it)
1233  {
1234  del(&it->second);
1235  }
1236 
1237  objs->clear();
1238  return result;
1239 }
1240 
1241 template<class K, class T>
1242 typename enable_if <is_object<T>::value ,
1243  std::pair<bool, std::string > > ::type
1244 static inline expand(acl::json_node &node, std::map<K, T*> *objs)
1245 {
1246  std::pair<bool, std::string> result;
1247  acl::json_node *itr = node.first_child();
1248 
1249  while (itr && itr->get_obj())
1250  {
1251  T* obj = new T;
1252  result = gson(*(itr->get_obj()), obj);
1253  if (!result.first)
1254  break;
1255 
1256  objs->insert(std::make_pair(K(itr->tag_name()), obj));
1257  itr = node.next_child();
1258  }
1259 
1260  if (result.first)
1261  return std::make_pair(true, "");
1262 
1263  for (typename std::map<K, T*>::iterator itr2 = objs->begin();
1264  itr2 != objs->end(); ++itr2)
1265  {
1266  del(&itr2->second);
1267  }
1268 
1269  objs->clear();
1270  return result;
1271 }
1272 
1273 // map
1274 template<class K, class V>
1275 std::pair<bool, std::string>
1276 static inline gson(acl::json_node &node, std::map<K, V*> *objs)
1277 {
1278  std::pair<bool, std::string> result;
1279  acl::json_node *itr = node.first_child();
1280  std::string error_string;
1281 
1282  while (itr)
1283  {
1284  result = expand(*itr, objs);
1285  if (result.first == false)
1286  error_string.append(result.second);
1287  itr = node.next_child();
1288  }
1289 
1290  return std::make_pair(!!!objs->empty(), error_string);
1291 }
1292 
1293 } // namespace acl
acl::string::append
string & append(const string &s)
acl::json_node::get_string
const char * get_string(void) const
acl::json_node::add_double
json_node & add_double(const char *tag, double value, bool return_child=false)
acl::json_node::add_number
json_node & add_number(const char *tag, long long int value, bool return_child=false)
acl::string::clear
string & clear()
acl::json_node::first_child
json_node * first_child(void)
acl::json_node::get_double
const double * get_double(void) const
acl::json_node::add_text
json_node & add_text(const char *tag, const char *value, bool return_child=false)
acl::json_node::get_obj
json_node * get_obj(void) const
acl::json_node::get_int64
const long long int * get_int64(void) const
acl::json_node::is_bool
bool is_bool(void) const
acl::json_node::add_array_number
json_node & add_array_number(long long int value, bool return_child=false)
acl::json_node::add_child
json_node & add_child(json_node *child, bool return_child=false)
acl::remove_cv::type
remove_const< typename remove_volatile< T >::type >::type type
Definition: gson_helper.ipp:62
acl::json_node::add_null
json_node & add_null(const char *tag, bool return_child=false)
acl::json::create_node
json_node & create_node(const char *tag, const char *value)
acl::json_node::is_double
bool is_double(void) const
acl::json_node::add_array_double
json_node & add_array_double(double value, bool return_child=false)
acl::json::create_array
json_node & create_array(void)
acl::json_node::add_array_null
json_node & add_array_null(bool return_child=false)
acl::json_node::is_number
bool is_number(void) const
acl::json_node::next_child
json_node * next_child(void)
acl::json_node::clear
void clear(void)
acl::json_node::add_array_bool
json_node & add_array_bool(bool value, bool return_child=false)
acl::json_node::get_bool
const bool * get_bool(void) const
acl::json_node::add_array_text
json_node & add_array_text(const char *text, bool return_child=false)
acl::true_type::value
static const bool value
Definition: gson_helper.ipp:26
acl::json_node::is_string
bool is_string(void) const
acl::json_node::add_bool
json_node & add_bool(const char *tag, bool value, bool return_child=false)
acl::json_node::tag_name
const char * tag_name(void) const
acl::false_type::value
static const bool value
Definition: gson_helper.ipp:31