ffead.server.doc
JSONSerialize.cpp
1 /*
2  Copyright 2010, Sumeet Chhetri
3 
4  Licensed under the Apache License, Version 2.0 (the "License");
5  you may not use this file except in compliance with the License.
6  You may obtain a copy of the License at
7 
8  http://www.apache.org/licenses/LICENSE-2.0
9 
10  Unless required by applicable law or agreed to in writing, software
11  distributed under the License is distributed on an "AS IS" BASIS,
12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  See the License for the specific language governing permissions and
14  limitations under the License.
15 */
16 /*
17  * JSONSerialize.cpp
18  *
19  * Created on: Jan 27, 2013
20  * Author: sumeet
21  */
22 
23 #include "JSONSerialize.h"
24 
25 string JSONSerialize::demangle(const char *mangled)
26 {
27  int status; char *demangled;
28  using namespace abi;
29  demangled = __cxa_demangle(mangled, NULL, 0, &status);
30  string s(demangled);
31  delete demangled;
32  return s;
33 }
34 string JSONSerialize::getClassName(void* instance)
35 {
36  const char *mangled = typeid(instance).name();
37  return demangle(mangled);
38 }
39 
40 string JSONSerialize::_handleAllSerialization(string className,void *t)
41 {
42  string objXml;
43  if(className=="std::string" || className=="string")
44  {
45  string tem = *(string*)t;
46  objXml = "\""+CastUtil::lexical_cast<string>(tem)+"\"";
47  }
48  else if(className=="int")
49  {
50  int tem = *(int*)t;
51  objXml = CastUtil::lexical_cast<string>(tem);
52  }
53  else if(className=="short")
54  {
55  short tem = *(short*)t;
56  objXml = CastUtil::lexical_cast<string>(tem);
57  }
58  else if(className=="long")
59  {
60  long tem = *(long*)t;
61  objXml = CastUtil::lexical_cast<string>(tem);
62  }
63  else if(className=="float")
64  {
65  float tem = *(float*)t;
66  objXml = CastUtil::lexical_cast<string>(tem);
67  }
68  else if(className=="double")
69  {
70  double tem = *(double*)t;
71  objXml = CastUtil::lexical_cast<string>(tem);
72  }
73  else if(className=="bool")
74  {
75  bool tem = *(bool*)t;
76  objXml = CastUtil::lexical_cast<string>(tem);
77  }
78  else if(className=="Date")
79  {
80  DateFormat formt("yyyy-mm-dd hh:mi:ss");
81  objXml = "\""+formt.format(*(Date*)t)+"\"";
82  }
83  else if(className=="BinaryData")
84  {
85  objXml = "\""+BinaryData::serilaize(*(BinaryData*)t)+"\"";
86  }
87  else if(className.find("std::vector<std::string,")!=string::npos || className.find("std::vector<string,")!=string::npos)
88  {
89  vector<string> *tt = (vector<string>*)t;
90  objXml = serializevec<string>(*tt);
91  }
92  else if(className.find("std::vector<int,")!=string::npos)
93  {
94  vector<int> *tt = (vector<int>*)t;
95  objXml = serializevec<int>(*tt);
96  }
97  else if(className.find("std::vector<short,")!=string::npos)
98  {
99  vector<short> *tt = (vector<short>*)t;
100  objXml = serializevec<short>(*tt);
101  }
102  else if(className.find("std::vector<long,")!=string::npos)
103  {
104  vector<long> *tt = (vector<long>*)t;
105  objXml = serializevec<long>(*tt);
106  }
107  else if(className.find("std::vector<double,")!=string::npos)
108  {
109  vector<double> *tt = (vector<double>*)t;
110  objXml = serializevec<double>(*tt);
111  }
112  else if(className.find("std::vector<float,")!=string::npos)
113  {
114  vector<float> *tt = (vector<float>*)t;
115  objXml = serializevec<float>(*tt);
116  }
117  else if(className.find("std::vector<bool,")!=string::npos)
118  {
119  vector<bool> *tt = (vector<bool>*)t;
120  objXml = serializevec<bool>(*tt);
121  }
122  else if(className.find("std::vector<")!=string::npos)
123  {
124  StringUtil::replaceFirst(className,"std::vector<","");
125  string vtyp = className.substr(0,className.find(","));
126  return _serContainers(t,vtyp,"Vec");
127  }
128  else if(className.find("std::list<std::string,")!=string::npos || className.find("std::list<string,")!=string::npos)
129  {
130  list<string> *tt = (list<string>*)t;
131  objXml = serializelist<string>(*tt);
132  }
133  else if(className.find("std::list<int,")!=string::npos)
134  {
135  list<int> *tt = (list<int>*)t;
136  objXml = serializelist<int>(*tt);
137  }
138  else if(className.find("std::list<long,")!=string::npos)
139  {
140  list<long> *tt = (list<long>*)t;
141  objXml = serializelist<long>(*tt);
142  }
143  else if(className.find("std::list<short,")!=string::npos)
144  {
145  list<short> *tt = (list<short>*)t;
146  objXml = serializelist<short>(*tt);
147  }
148  else if(className.find("std::list<double,")!=string::npos)
149  {
150  list<double> *tt = (list<double>*)t;
151  objXml = serializelist<double>(*tt);
152  }
153  else if(className.find("std::list<float,")!=string::npos)
154  {
155  list<float> *tt = (list<float>*)t;
156  objXml = serializelist<float>(*tt);
157  }
158  else if(className.find("std::list<bool,")!=string::npos)
159  {
160  list<bool> *tt = (list<bool>*)t;
161  objXml = serializelist<bool>(*tt);
162  }
163  else if(className.find("std::list<")!=string::npos)
164  {
165  StringUtil::replaceFirst(className,"std::list<","");
166  string vtyp = className.substr(0,className.find(","));
167  return _serContainers(t,vtyp,"Lis");
168  }
169  else if(className.find("std::set<std::string,")!=string::npos || className.find("std::set<string,")!=string::npos)
170  {
171  set<string> *tt = (set<string>*)t;
172  objXml = serializeset<string>(*tt);
173  }
174  else if(className.find("std::set<int,")!=string::npos)
175  {
176  set<int> *tt = (set<int>*)t;
177  objXml = serializeset<int>(*tt);
178  }
179  else if(className.find("std::set<short,")!=string::npos)
180  {
181  set<short> *tt = (set<short>*)t;
182  objXml = serializeset<short>(*tt);
183  }
184  else if(className.find("std::set<long,")!=string::npos)
185  {
186  set<long> *tt = (set<long>*)t;
187  objXml = serializeset<long>(*tt);
188  }
189  else if(className.find("std::set<double,")!=string::npos)
190  {
191  set<double> *tt = (set<double>*)t;
192  objXml = serializeset<double>(*tt);
193  }
194  else if(className.find("std::set<float,")!=string::npos)
195  {
196  set<float> *tt = (set<float>*)&t;
197  objXml = serializeset<float>(*tt);
198  }
199  else if(className.find("std::set<bool,")!=string::npos)
200  {
201  set<bool> *tt = (set<bool>*)&t;
202  objXml = serializeset<bool>(*tt);
203  }
204  else if(className.find("std::set<")!=string::npos)
205  {
206  StringUtil::replaceFirst(className,"std::set<","");
207  string vtyp = className.substr(0,className.find(","));
208  return _serContainers(t,vtyp,"Set");
209  }
210  else if(className.find("std::multiset<std::string,")!=string::npos || className.find("std::multiset<string,")!=string::npos)
211  {
212  multiset<string> *tt = (multiset<string>*)t;
213  objXml = serializemultiset<string>(*tt);
214  }
215  else if(className.find("std::multiset<int,")!=string::npos)
216  {
217  multiset<int> *tt = (multiset<int>*)t;
218  objXml = serializemultiset<int>(*tt);
219  }
220  else if(className.find("std::multiset<long,")!=string::npos)
221  {
222  multiset<long> *tt = (multiset<long>*)t;
223  objXml = serializemultiset<long>(*tt);
224  }
225  else if(className.find("std::multiset<short,")!=string::npos)
226  {
227  multiset<short> *tt = (multiset<short>*)t;
228  objXml = serializemultiset<short>(*tt);
229  }
230  else if(className.find("std::multiset<double,")!=string::npos)
231  {
232  multiset<double> *tt = (multiset<double>*)t;
233  objXml = serializemultiset<double>(*tt);
234  }
235  else if(className.find("std::multiset<float,")!=string::npos)
236  {
237  multiset<float> *tt = (multiset<float>*)t;
238  objXml = serializemultiset<float>(*tt);
239  }
240  else if(className.find("std::multiset<bool,")!=string::npos)
241  {
242  multiset<bool> *tt = (multiset<bool>*)t;
243  objXml = serializemultiset<bool>(*tt);
244  }
245  else if(className.find("std::multiset<")!=string::npos)
246  {
247  StringUtil::replaceFirst(className,"std::multiset<","");
248  string vtyp = className.substr(0,className.find(","));
249  return _serContainers(t,vtyp,"MulSet");
250  }
251  else if(className.find("std::queue<std::string,")!=string::npos || className.find("std::queue<string,")!=string::npos)
252  {
253  std::queue<string> *tt = (std::queue<string>*)t;
254  objXml = serializeq<string>(*tt);
255  }
256  else if(className.find("std::queue<int,")!=string::npos)
257  {
258  std::queue<int> *tt = (std::queue<int>*)t;
259  objXml = serializeq<int>(*tt);
260  }
261  else if(className.find("std::queue<short,")!=string::npos)
262  {
263  std::queue<short> *tt = (std::queue<short>*)t;
264  objXml = serializeq<short>(*tt);
265  }
266  else if(className.find("std::queue<long,")!=string::npos)
267  {
268  std::queue<long> *tt = (std::queue<long>*)t;
269  objXml = serializeq<long>(*tt);
270  }
271  else if(className.find("std::queue<double,")!=string::npos)
272  {
273  std::queue<double> *tt = (std::queue<double>*)t;
274  objXml = serializeq<double>(*tt);
275  }
276  else if(className.find("std::queue<float,")!=string::npos)
277  {
278  std::queue<float> *tt = (std::queue<float>*)t;
279  objXml = serializeq<float>(*tt);
280  }
281  else if(className.find("std::queue<bool,")!=string::npos)
282  {
283  std::queue<bool> *tt = (std::queue<bool>*)t;
284  objXml = serializeq<bool>(*tt);
285  }
286  else if(className.find("std::queue<")!=string::npos)
287  {
288  StringUtil::replaceFirst(className,"std::queue<","");
289  string vtyp = className.substr(0,className.find(","));
290  return _serContainers(t,vtyp,"Q");
291  }
292  else if(className.find("std::deque<std::string,")!=string::npos || className.find("std::deque<string,")!=string::npos)
293  {
294  deque<string> *tt = (deque<string>*)t;
295  objXml = serializedq<string>(*tt);
296  }
297  else if(className.find("std::deque<int,")!=string::npos)
298  {
299  deque<int> *tt = (deque<int>*)t;
300  objXml = serializedq<int>(*tt);
301  }
302  else if(className.find("std::deque<long,")!=string::npos)
303  {
304  deque<long> *tt = (deque<long>*)t;
305  objXml = serializedq<long>(*tt);
306  }
307  else if(className.find("std::deque<short,")!=string::npos)
308  {
309  deque<short> *tt = (deque<short>*)t;
310  objXml = serializedq<short>(*tt);
311  }
312  else if(className.find("std::deque<double,")!=string::npos)
313  {
314  deque<double> *tt = (deque<double>*)t;
315  objXml = serializedq<double>(*tt);
316  }
317  else if(className.find("std::deque<float,")!=string::npos)
318  {
319  deque<float> *tt = (deque<float>*)t;
320  objXml = serializedq<float>(*tt);
321  }
322  else if(className.find("std::deque<bool,")!=string::npos)
323  {
324  deque<bool> *tt = (deque<bool>*)t;
325  objXml = serializedq<bool>(*tt);
326  }
327  else if(className.find("std::deque<")!=string::npos)
328  {
329  StringUtil::replaceFirst(className,"std::deque<","");
330  string vtyp = className.substr(0,className.find(","));
331  return _serContainers(t,vtyp,"Dq");
332  }
333  else
334  {
335  return _ser(t,className);
336  }
337  return objXml;
338 }
339 
340 
341 string JSONSerialize::_serContainers(void* t,string className, string type)
342 {
343  string json;
344  string libName = Constants::INTER_LIB_FILE;
345  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
346  if(dlib == NULL)
347  {
348  cerr << dlerror() << endl;
349  exit(-1);
350  }
351  string methodname = "from"+className+type+"VPToJSON";
352  void *mkr = dlsym(dlib, methodname.c_str());
353  typedef string (*RfPtr) (void*);
354  RfPtr f = (RfPtr)mkr;
355  if(f!=NULL)
356  json = f(t);
357  return json;
358 }
359 
360 string JSONSerialize::_ser(void* t,string className)
361 {
362  string json;
363  string libName = Constants::INTER_LIB_FILE;
364  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
365  if(dlib == NULL)
366  {
367  cerr << dlerror() << endl;
368  exit(-1);
369  }
370  string methodname = "from"+className+"VPToJSON";
371  void *mkr = dlsym(dlib, methodname.c_str());
372  typedef string (*RfPtr) (void*);
373  RfPtr f = (RfPtr)mkr;
374  if(f!=NULL)
375  json = f(t);
376  return json;
377 }
378 
379 string JSONSerialize::_ser(Object t)
380 {
381  return _ser(t.getVoidPointer(),t.getTypeName());
382 }
383 
384 
385 void* JSONSerialize::_handleAllUnSerialization(string json,string className)
386 {
387  if(className=="std::string" || className=="string" || className=="int" || className=="short" || className=="float" || className=="double"
388  || className=="long" || className=="bool")
389  {
390  if(className=="int")
391  {
392  int *vt = new int;
393  *vt = CastUtil::lexical_cast<int>(json);
394  return vt;
395  }
396  else if(className=="long")
397  {
398  long *vt = new long;
399  *vt = CastUtil::lexical_cast<long>(json);
400  return vt;
401  }
402  else if(className=="short")
403  {
404  short *vt = new short;
405  *vt = CastUtil::lexical_cast<short>(json);
406  return vt;
407  }
408  else if(className=="Date")
409  {
410  DateFormat formt("yyyy-mm-dd hh:mi:ss");
411  if(json.length()>2)
412  return formt.parse(json.substr(1, json.length()-1));
413  else
414  {
415  return new Date;
416  }
417  }
418  else if(className=="BinaryData")
419  {
420  if(json.length()>2)
421  return BinaryData::unSerilaize(json.substr(1, json.length()-1));
422  else
423  return new BinaryData;
424  }
425  else if(className=="float")
426  {
427  float *vt = new float;
428  *vt = CastUtil::lexical_cast<float>(json);
429  return vt;
430  }
431  else if(className=="double")
432  {
433  double *vt = new double;
434  *vt = CastUtil::lexical_cast<double>(json);
435  return vt;
436  }
437  else if(className=="bool")
438  {
439  bool *vt = new bool;
440  *vt = CastUtil::lexical_cast<bool>(json);
441  return vt;
442  }
443  else if(className=="std::string" || className=="string")
444  {
445  string *vt = new string;
446  if(json.length()>2)
447  *vt = CastUtil::lexical_cast<string>(json.substr(1, json.length()-1));
448  return vt;
449  }
450  }
451  else if(className.find("std::vector<")==0)
452  {
453  StringUtil::replaceFirst(className,"std::vector<","");
454  StringUtil::replaceFirst(className,">","");
455  return unserializeConatiner(json, className, "Vec");
456  }
457  else if(className.find("std::list<")==0)
458  {
459  StringUtil::replaceFirst(className,"std::vector<","");
460  StringUtil::replaceFirst(className,">","");
461  return unserializeConatiner(json, className,"Lis");
462  }
463  else if(className.find("std::set<")==0)
464  {
465  StringUtil::replaceFirst(className,"std::vector<","");
466  StringUtil::replaceFirst(className,">","");
467  return unserializeConatiner(json, className,"Set");
468  }
469  else if(className.find("std::multiset<")==0)
470  {
471  StringUtil::replaceFirst(className,"std::vector<","");
472  StringUtil::replaceFirst(className,">","");
473  return unserializeConatiner(json, className, "MulSet");
474  }
475  else if(className.find("std::queue<")==0)
476  {
477  StringUtil::replaceFirst(className,"std::vector<","");
478  StringUtil::replaceFirst(className,">","");
479  return unserializeConatiner(json, className,"Q");
480  }
481  else if(className.find("std::deque<")==0)
482  {
483  StringUtil::replaceFirst(className,"std::vector<","");
484  StringUtil::replaceFirst(className,">","");
485  return unserializeConatiner(json, className, "Dq");
486  }
487  return _unser(json,className);
488 }
489 
490 void* JSONSerialize::unserializeConatiner(string json, string className, string type)
491 {
492  if(className=="string" || className=="std::string")
493  {
494  JSONElement root = JSONUtil::getDocument(json);
495  vector<string> *t = JSONUtil::toVectorP<string>(root);
496  return unserContainer<string>(*t, type);
497  }
498  else if(className=="double")
499  {
500  JSONElement root = JSONUtil::getDocument(json);
501  vector<double> *t = JSONUtil::toVectorP<double>(root);
502  return unserContainer<double>(*t, type);
503  }
504  else if(className=="float")
505  {
506  JSONElement root = JSONUtil::getDocument(json);
507  vector<float> *t = JSONUtil::toVectorP<float>(root);
508  return unserContainer<float>(*t, type);
509  }
510  else if(className=="int")
511  {
512  JSONElement root = JSONUtil::getDocument(json);
513  vector<int> *t = JSONUtil::toVectorP<int>(root);
514  return unserContainer<int>(*t, type);
515  }
516  else if(className=="short")
517  {
518  JSONElement root = JSONUtil::getDocument(json);
519  vector<short> *t = JSONUtil::toVectorP<short>(root);
520  return unserContainer<short>(*t, type);
521  }
522  else if(className=="long")
523  {
524  JSONElement root = JSONUtil::getDocument(json);
525  vector<long> *t = JSONUtil::toVectorP<long>(root);
526  return unserContainer<long>(*t, type);
527  }
528  else if(className=="bool")
529  {
530  JSONElement root = JSONUtil::getDocument(json);
531  vector<bool> *t = JSONUtil::toVectorP<bool>(root);
532  return unserContainer<bool>(*t, type);
533  }
534  else
535  return _unserCont(json,className, type);
536 
537 }
538 
539 void* JSONSerialize::_unserCont(string objXml,string className,string type)
540 {
541  void* obj = NULL;
542  string libName = Constants::INTER_LIB_FILE;
543  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
544  if(dlib == NULL)
545  {
546  cerr << dlerror() << endl;
547  exit(-1);
548  }
549  string methodname = "to"+className+type+"VP";
550  void *mkr = dlsym(dlib, methodname.c_str());
551  typedef void* (*RfPtr) (string);
552  RfPtr f = (RfPtr)mkr;
553  if(f!=NULL)
554  {
555  obj = f(objXml);
556  }
557  return obj;
558 }
559 
560 
561 void* JSONSerialize::_unser(string objXml,string className)
562 {
563  void* obj = NULL;
564  string libName = Constants::INTER_LIB_FILE;
565  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
566  if(dlib == NULL)
567  {
568  cerr << dlerror() << endl;
569  exit(-1);
570  }
571  string methodname = "toVoidP"+className;
572  void *mkr = dlsym(dlib, methodname.c_str());
573  typedef void* (*RfPtr) (string);
574  RfPtr f = (RfPtr)mkr;
575  if(f!=NULL)
576  {
577  obj = f(objXml);
578  }
579  return obj;
580 }