ffead.server.doc
XMLSerialize.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  * Serialize.cpp
18  *
19  * Created on: Apr 2, 2010
20  * Author: sumeet
21  */
22 
23 #include "XMLSerialize.h"
24 
25 string XMLSerialize::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 XMLSerialize::getClassName(void* instance)
35 {
36  const char *mangled = typeid(instance).name();
37  return demangle(mangled);
38 }
39 
40 string XMLSerialize::_handleAllSerialization(string className,void *t)
41 {
42  string objXml;
43  if(className=="std::string" || className=="string")
44  {
45  string tem = *(string*)t;
46  objXml = "<string>"+CastUtil::lexical_cast<string>(tem)+"</string>";
47  }
48  else if(className=="int")
49  {
50  int tem = *(int*)t;
51  objXml = "<int>"+CastUtil::lexical_cast<string>(tem)+"</int>";
52  }
53  else if(className=="long")
54  {
55  long tem = *(long*)t;
56  objXml = "<long>"+CastUtil::lexical_cast<string>(tem)+"</long>";
57  }
58  else if(className=="short")
59  {
60  short tem = *(short*)t;
61  objXml = "<short>"+CastUtil::lexical_cast<string>(tem)+"</short>";
62  }
63  else if(className=="float")
64  {
65  float tem = *(float*)t;
66  objXml = "<float>"+CastUtil::lexical_cast<string>(tem)+"</float>";
67  }
68  else if(className=="double")
69  {
70  double tem = *(double*)t;
71  objXml = "<double>"+CastUtil::lexical_cast<string>(tem)+"</double>";
72  }
73  else if(className=="bool")
74  {
75  bool tem = *(bool*)t;
76  objXml = "<bool>"+CastUtil::lexical_cast<string>(tem)+"</bool>";
77  }
78  else if(className=="Date")
79  {
80  DateFormat formt("yyyy-mm-dd hh:mi:ss");
81  objXml = "<Date>"+formt.format(*(Date*)t)+"</Date>";
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 _servec(t,vtyp);
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 _serlis(t,vtyp);
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 _serset(t,vtyp);
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 _sermultiset(t,vtyp);
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 _serq(t,vtyp);
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 _serdq(t,vtyp);
332  }
333  else
334  {
335  return _ser(t,className);
336  }
337  return objXml;
338 }
339 
340 string XMLSerialize::_servec(void* t,string className)
341 {
342  string objXml;
343  string libName = Constants::INTER_LIB_FILE;
344  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
345  if(dlib == NULL)
346  {
347  cerr << dlerror() << endl;
348  exit(-1);
349  }
350  string methodname = "serialize"+className+"Vec";
351  void *mkr = dlsym(dlib, methodname.c_str());
352  typedef string (*RfPtr) (void*);
353  RfPtr f = (RfPtr)mkr;
354  if(f!=NULL)
355  objXml = f(t);
356  return objXml;
357 }
358 
359 string XMLSerialize::_serlis(void* t,string className)
360 {
361  string objXml;
362  string libName = Constants::INTER_LIB_FILE;
363  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
364  if(dlib == NULL)
365  {
366  cerr << dlerror() << endl;
367  exit(-1);
368  }
369  string methodname = "serialize"+className+"Lis";
370  void *mkr = dlsym(dlib, methodname.c_str());
371  typedef string (*RfPtr) (void*);
372  RfPtr f = (RfPtr)mkr;
373  if(f!=NULL)
374  objXml = f(t);
375  return objXml;
376 }
377 string XMLSerialize::_serset(void* t,string className)
378 {
379  string objXml;
380  string libName = Constants::INTER_LIB_FILE;
381  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
382  if(dlib == NULL)
383  {
384  cerr << dlerror() << endl;
385  exit(-1);
386  }
387  string methodname = "serialize"+className+"Set";
388  void *mkr = dlsym(dlib, methodname.c_str());
389  typedef string (*RfPtr) (void*);
390  RfPtr f = (RfPtr)mkr;
391  if(f!=NULL)
392  objXml = f(t);
393  return objXml;
394 }
395 string XMLSerialize::_sermultiset(void* t,string className)
396 {
397  string objXml;
398  string libName = Constants::INTER_LIB_FILE;
399  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
400  if(dlib == NULL)
401  {
402  cerr << dlerror() << endl;
403  exit(-1);
404  }
405  string methodname = "serialize"+className+"MulSet";
406  void *mkr = dlsym(dlib, methodname.c_str());
407  typedef string (*RfPtr) (void*);
408  RfPtr f = (RfPtr)mkr;
409  if(f!=NULL)
410  objXml = f(t);
411  return objXml;
412 }
413 string XMLSerialize::_serq(void* t,string className)
414 {
415  string objXml;
416  string libName = Constants::INTER_LIB_FILE;
417  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
418  if(dlib == NULL)
419  {
420  cerr << dlerror() << endl;
421  exit(-1);
422  }
423  string methodname = "serialize"+className+"Q";
424  void *mkr = dlsym(dlib, methodname.c_str());
425  typedef string (*RfPtr) (void*);
426  RfPtr f = (RfPtr)mkr;
427  if(f!=NULL)
428  objXml = f(t);
429  return objXml;
430 }
431 string XMLSerialize::_serdq(void* t,string className)
432 {
433  string objXml;
434  string libName = Constants::INTER_LIB_FILE;
435  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
436  if(dlib == NULL)
437  {
438  cerr << dlerror() << endl;
439  exit(-1);
440  }
441  string methodname = "serialize"+className+"Dq";
442  void *mkr = dlsym(dlib, methodname.c_str());
443  typedef string (*RfPtr) (void*);
444  RfPtr f = (RfPtr)mkr;
445  if(f!=NULL)
446  objXml = f(t);
447  return objXml;
448 }
449 
450 string XMLSerialize::_ser(void* t,string className)
451 {
452  string objXml;
453  string libName = Constants::INTER_LIB_FILE;
454  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
455  if(dlib == NULL)
456  {
457  cerr << dlerror() << endl;
458  exit(-1);
459  }
460  string methodname = "serialize"+className;
461  void *mkr = dlsym(dlib, methodname.c_str());
462  typedef string (*RfPtr) (void*);
463  RfPtr f = (RfPtr)mkr;
464  if(f!=NULL)
465  objXml = f(t);
466  return objXml;
467 }
468 
469 string XMLSerialize::_ser(Object t)
470 {
471  return _ser(t.getVoidPointer(),t.getTypeName());
472 }
473 
474 
475 void* XMLSerialize::_handleAllUnSerialization(string objXml,string className)
476 {
477  if(className=="std::string" || className=="string" || className=="int" || className=="short" || className=="float" || className=="double"
478  || className=="long" || className=="bool")
479  {
480  XmlParser parser("Parser");
481  Document doc = parser.getDocument(objXml);
482  Element message = doc.getRootElement();
483  if(className=="int")
484  {
485  int *vt = new int;
486  *vt = CastUtil::lexical_cast<int>(message.getText());
487  return vt;
488  }
489  else if(className=="short")
490  {
491  short *vt = new short;
492  *vt = CastUtil::lexical_cast<short>(message.getText());
493  return vt;
494  }
495  else if(className=="long")
496  {
497  long *vt = new long;
498  *vt = CastUtil::lexical_cast<long>(message.getText());
499  return vt;
500  }
501  else if(className=="Date")
502  {
503  DateFormat formt("yyyy-mm-dd hh:mi:ss");
504  return formt.parse(message.getText());
505  }
506  else if(className=="BinaryData")
507  {
508  return BinaryData::unSerilaize(message.getText());
509  }
510  else if(className=="float")
511  {
512  float *vt = new float;
513  *vt = CastUtil::lexical_cast<float>(message.getText());
514  return vt;
515  }
516  else if(className=="double")
517  {
518  double *vt = new double;
519  *vt = CastUtil::lexical_cast<double>(message.getText());
520  return vt;
521  }
522  else if(className=="bool")
523  {
524  bool *vt = new bool;
525  *vt = CastUtil::lexical_cast<bool>(message.getText());
526  return vt;
527  }
528  else if(className=="std::string" || className=="string")
529  {
530  string *vt = new string;
531  *vt = CastUtil::lexical_cast<string>(message.getText());
532  return vt;
533  }
534  }
535  else if(objXml.find("<vector-")==0)
536  {
537  return unserializevec(objXml);
538  }
539  else if(objXml.find("<set-")==0)
540  {
541  return unserializeset(objXml);
542  }
543  else if(objXml.find("<multiset-")==0)
544  {
545  return unserializemultiset(objXml);
546  }
547  else if(objXml.find("<list-")==0)
548  {
549  return unserializelist(objXml);
550  }
551  else if(objXml.find("<queue-")==0)
552  {
553  return unserializeq(objXml);
554  }
555  else if(objXml.find("<deque-")==0)
556  {
557  return unserializedq(objXml);
558  }
559  return _unser(objXml,className);
560 }
561 
562 void* XMLSerialize::unserializevec(string objXml)
563 {
564  string cls = objXml.substr(8,objXml.find(">")-8);
565  if(cls=="string" || cls=="std::string")
566  {
567  vector<string> *t = new vector<string>;
568  XmlParser parser("Parser");
569  Document doc = parser.getDocument(objXml);
570  Element message = doc.getRootElement();
571  for (int var = 0; var < (int)message.getChildElements().size(); var++)
572  {
573  Element ele = message.getChildElements().at(var);
574  if(ele.getTagName()=="string" || ele.getTagName()=="std::string")
575  {
576  t->push_back(ele.getText());
577  }
578  }
579  return t;
580  }
581  else if(cls=="double")
582  {
583  vector<double> *t = new vector<double>;
584  XmlParser parser("Parser");
585  Document doc = parser.getDocument(objXml);
586  Element message = doc.getRootElement();
587  for (int var = 0; var < (int)message.getChildElements().size(); var++)
588  {
589  Element ele = message.getChildElements().at(var);
590  if(ele.getTagName()=="double")
591  {
592  t->push_back(CastUtil::lexical_cast<double>(ele.getText()));
593  }
594  }
595  return t;
596  }
597  else if(cls=="float")
598  {
599  vector<float> *t = new vector<float>;
600  XmlParser parser("Parser");
601  Document doc = parser.getDocument(objXml);
602  Element message = doc.getRootElement();
603  for (int var = 0; var < (int)message.getChildElements().size(); var++)
604  {
605  Element ele = message.getChildElements().at(var);
606  if(ele.getTagName()=="float")
607  {
608  t->push_back(CastUtil::lexical_cast<float>(ele.getText()));
609  }
610  }
611  return t;
612  }
613  else if(cls=="int")
614  {
615  vector<int> *t = new vector<int>;
616  XmlParser parser("Parser");
617  Document doc = parser.getDocument(objXml);
618  Element message = doc.getRootElement();
619  for (int var = 0; var < (int)message.getChildElements().size(); var++)
620  {
621  Element ele = message.getChildElements().at(var);
622  if(ele.getTagName()=="int")
623  {
624  t->push_back(CastUtil::lexical_cast<int>(ele.getText()));
625  }
626  }
627  return t;
628  }
629  else if(cls=="short")
630  {
631  vector<short> *t = new vector<short>;
632  XmlParser parser("Parser");
633  Document doc = parser.getDocument(objXml);
634  Element message = doc.getRootElement();
635  for (int var = 0; var < (int)message.getChildElements().size(); var++)
636  {
637  Element ele = message.getChildElements().at(var);
638  if(ele.getTagName()=="short")
639  {
640  t->push_back(CastUtil::lexical_cast<short>(ele.getText()));
641  }
642  }
643  return t;
644  }
645  else if(cls=="long")
646  {
647  vector<long> *t = new vector<long>;
648  XmlParser parser("Parser");
649  Document doc = parser.getDocument(objXml);
650  Element message = doc.getRootElement();
651  for (int var = 0; var < (int)message.getChildElements().size(); var++)
652  {
653  Element ele = message.getChildElements().at(var);
654  if(ele.getTagName()=="long")
655  {
656  t->push_back(CastUtil::lexical_cast<long>(ele.getText()));
657  }
658  }
659  return t;
660  }
661  else if(cls=="bool")
662  {
663  vector<bool> *t = new vector<bool>;
664  XmlParser parser("Parser");
665  Document doc = parser.getDocument(objXml);
666  Element message = doc.getRootElement();
667  for (int var = 0; var < (int)message.getChildElements().size(); var++)
668  {
669  Element ele = message.getChildElements().at(var);
670  if(ele.getTagName()=="bool")
671  {
672  t->push_back(CastUtil::lexical_cast<bool>(ele.getText()));
673  }
674  }
675  return t;
676  }
677  else
678  return _unserVec(objXml,cls);
679 
680 }
681 
682 void* XMLSerialize::unserializelist(string objXml)
683 {
684  string cls = objXml.substr(6,objXml.find(">")-6);
685  if(cls=="string" || cls=="std::string")
686  {
687  list<string> *t = new list<string>;
688  XmlParser parser("Parser");
689  Document doc = parser.getDocument(objXml);
690  Element message = doc.getRootElement();
691  for (int var = 0; var < (int)message.getChildElements().size(); var++)
692  {
693  Element ele = message.getChildElements().at(var);
694  if(ele.getTagName()=="string" || ele.getTagName()=="std::string")
695  {
696  t->push_back(ele.getText());
697  }
698  }
699  return t;
700  }
701  else if(cls=="double")
702  {
703  list<double> *t = new list<double>;
704  XmlParser parser("Parser");
705  Document doc = parser.getDocument(objXml);
706  Element message = doc.getRootElement();
707  for (int var = 0; var < (int)message.getChildElements().size(); var++)
708  {
709  Element ele = message.getChildElements().at(var);
710  if(ele.getTagName()=="double")
711  {
712  t->push_back(CastUtil::lexical_cast<double>(ele.getText()));
713  }
714  }
715  return t;
716  }
717  else if(cls=="float")
718  {
719  list<float> *t = new list<float>;
720  XmlParser parser("Parser");
721  Document doc = parser.getDocument(objXml);
722  Element message = doc.getRootElement();
723  for (int var = 0; var < (int)message.getChildElements().size(); var++)
724  {
725  Element ele = message.getChildElements().at(var);
726  if(ele.getTagName()=="float")
727  {
728  t->push_back(CastUtil::lexical_cast<float>(ele.getText()));
729  }
730  }
731  return t;
732  }
733  else if(cls=="int")
734  {
735  list<int> *t = new list<int>;
736  XmlParser parser("Parser");
737  Document doc = parser.getDocument(objXml);
738  Element message = doc.getRootElement();
739  for (int var = 0; var < (int)message.getChildElements().size(); var++)
740  {
741  Element ele = message.getChildElements().at(var);
742  if(ele.getTagName()=="int")
743  {
744  t->push_back(CastUtil::lexical_cast<int>(ele.getText()));
745  }
746  }
747  return t;
748  }
749  else if(cls=="short")
750  {
751  list<short> *t = new list<short>;
752  XmlParser parser("Parser");
753  Document doc = parser.getDocument(objXml);
754  Element message = doc.getRootElement();
755  for (int var = 0; var < (int)message.getChildElements().size(); var++)
756  {
757  Element ele = message.getChildElements().at(var);
758  if(ele.getTagName()=="short")
759  {
760  t->push_back(CastUtil::lexical_cast<short>(ele.getText()));
761  }
762  }
763  return t;
764  }
765  else if(cls=="long")
766  {
767  list<long> *t = new list<long>;
768  XmlParser parser("Parser");
769  Document doc = parser.getDocument(objXml);
770  Element message = doc.getRootElement();
771  for (int var = 0; var < (int)message.getChildElements().size(); var++)
772  {
773  Element ele = message.getChildElements().at(var);
774  if(ele.getTagName()=="long")
775  {
776  t->push_back(CastUtil::lexical_cast<long>(ele.getText()));
777  }
778  }
779  return t;
780  }
781  else if(cls=="bool")
782  {
783  list<bool> *t = new list<bool>;
784  XmlParser parser("Parser");
785  Document doc = parser.getDocument(objXml);
786  Element message = doc.getRootElement();
787  for (int var = 0; var < (int)message.getChildElements().size(); var++)
788  {
789  Element ele = message.getChildElements().at(var);
790  if(ele.getTagName()=="bool")
791  {
792  t->push_back(CastUtil::lexical_cast<bool>(ele.getText()));
793  }
794  }
795  return t;
796  }
797  else
798  return _unserLis(objXml,cls);
799 }
800 
801 void* XMLSerialize::unserializeset(string objXml)
802 {
803  string cls = objXml.substr(5,objXml.find(">")-5);
804  if(cls=="string" || cls=="std::string")
805  {
806  set<string> *t = new set<string>;
807  XmlParser parser("Parser");
808  Document doc = parser.getDocument(objXml);
809  Element message = doc.getRootElement();
810  for (int var = 0; var < (int)message.getChildElements().size(); var++)
811  {
812  Element ele = message.getChildElements().at(var);
813  if(ele.getTagName()=="string" || ele.getTagName()=="std::string")
814  {
815  t->insert(ele.getText());
816  }
817  }
818  return t;
819  }
820  else if(cls=="double")
821  {
822  set<double> *t = new set<double>;
823  XmlParser parser("Parser");
824  Document doc = parser.getDocument(objXml);
825  Element message = doc.getRootElement();
826  for (int var = 0; var < (int)message.getChildElements().size(); var++)
827  {
828  Element ele = message.getChildElements().at(var);
829  if(ele.getTagName()=="double")
830  {
831  t->insert(CastUtil::lexical_cast<double>(ele.getText()));
832  }
833  }
834  return t;
835  }
836  else if(cls=="float")
837  {
838  set<float> *t = new set<float>;
839  XmlParser parser("Parser");
840  Document doc = parser.getDocument(objXml);
841  Element message = doc.getRootElement();
842  for (int var = 0; var < (int)message.getChildElements().size(); var++)
843  {
844  Element ele = message.getChildElements().at(var);
845  if(ele.getTagName()=="float")
846  {
847  t->insert(CastUtil::lexical_cast<float>(ele.getText()));
848  }
849  }
850  return t;
851  }
852  else if(cls=="int")
853  {
854  set<int> *t = new set<int>;
855  XmlParser parser("Parser");
856  Document doc = parser.getDocument(objXml);
857  Element message = doc.getRootElement();
858  for (int var = 0; var < (int)message.getChildElements().size(); var++)
859  {
860  Element ele = message.getChildElements().at(var);
861  if(ele.getTagName()=="int")
862  {
863  t->insert(CastUtil::lexical_cast<int>(ele.getText()));
864  }
865  }
866  return t;
867  }
868  else if(cls=="short")
869  {
870  set<short> *t = new set<short>;
871  XmlParser parser("Parser");
872  Document doc = parser.getDocument(objXml);
873  Element message = doc.getRootElement();
874  for (int var = 0; var < (int)message.getChildElements().size(); var++)
875  {
876  Element ele = message.getChildElements().at(var);
877  if(ele.getTagName()=="short")
878  {
879  t->insert(CastUtil::lexical_cast<short>(ele.getText()));
880  }
881  }
882  return t;
883  }
884  else if(cls=="long")
885  {
886  set<long> *t = new set<long>;
887  XmlParser parser("Parser");
888  Document doc = parser.getDocument(objXml);
889  Element message = doc.getRootElement();
890  for (int var = 0; var < (int)message.getChildElements().size(); var++)
891  {
892  Element ele = message.getChildElements().at(var);
893  if(ele.getTagName()=="long")
894  {
895  t->insert(CastUtil::lexical_cast<long>(ele.getText()));
896  }
897  }
898  return t;
899  }
900  else if(cls=="bool")
901  {
902  set<bool> *t = new set<bool>;
903  XmlParser parser("Parser");
904  Document doc = parser.getDocument(objXml);
905  Element message = doc.getRootElement();
906  for (int var = 0; var < (int)message.getChildElements().size(); var++)
907  {
908  Element ele = message.getChildElements().at(var);
909  if(ele.getTagName()=="bool")
910  {
911  t->insert(CastUtil::lexical_cast<bool>(ele.getText()));
912  }
913  }
914  return t;
915  }
916  else
917  return _unserSet(objXml,cls);
918 }
919 
920 void* XMLSerialize::unserializemultiset(string objXml)
921 {
922  string cls = objXml.substr(10,objXml.find(">")-10);
923  if(cls=="string" || cls=="std::string")
924  {
925  multiset<string> *t = new multiset<string>;
926  XmlParser parser("Parser");
927  Document doc = parser.getDocument(objXml);
928  Element message = doc.getRootElement();
929  for (int var = 0; var < (int)message.getChildElements().size(); var++)
930  {
931  Element ele = message.getChildElements().at(var);
932  if(ele.getTagName()=="string" || ele.getTagName()=="std::string")
933  {
934  t->insert(ele.getText());
935  }
936  }
937  return t;
938  }
939  else if(cls=="double")
940  {
941  multiset<double> *t = new multiset<double>;
942  XmlParser parser("Parser");
943  Document doc = parser.getDocument(objXml);
944  Element message = doc.getRootElement();
945  for (int var = 0; var < (int)message.getChildElements().size(); var++)
946  {
947  Element ele = message.getChildElements().at(var);
948  if(ele.getTagName()=="double")
949  {
950  t->insert(CastUtil::lexical_cast<double>(ele.getText()));
951  }
952  }
953  return t;
954  }
955  else if(cls=="float")
956  {
957  multiset<float> *t = new multiset<float>;
958  XmlParser parser("Parser");
959  Document doc = parser.getDocument(objXml);
960  Element message = doc.getRootElement();
961  for (int var = 0; var < (int)message.getChildElements().size(); var++)
962  {
963  Element ele = message.getChildElements().at(var);
964  if(ele.getTagName()=="float")
965  {
966  t->insert(CastUtil::lexical_cast<float>(ele.getText()));
967  }
968  }
969  return t;
970  }
971  else if(cls=="int")
972  {
973  multiset<int> *t = new multiset<int>;
974  XmlParser parser("Parser");
975  Document doc = parser.getDocument(objXml);
976  Element message = doc.getRootElement();
977  for (int var = 0; var < (int)message.getChildElements().size(); var++)
978  {
979  Element ele = message.getChildElements().at(var);
980  if(ele.getTagName()=="int")
981  {
982  t->insert(CastUtil::lexical_cast<int>(ele.getText()));
983  }
984  }
985  return t;
986  }
987  else if(cls=="short")
988  {
989  multiset<short> *t = new multiset<short>;
990  XmlParser parser("Parser");
991  Document doc = parser.getDocument(objXml);
992  Element message = doc.getRootElement();
993  for (int var = 0; var < (int)message.getChildElements().size(); var++)
994  {
995  Element ele = message.getChildElements().at(var);
996  if(ele.getTagName()=="short")
997  {
998  t->insert(CastUtil::lexical_cast<short>(ele.getText()));
999  }
1000  }
1001  return t;
1002  }
1003  else if(cls=="long")
1004  {
1005  multiset<long> *t = new multiset<long>;
1006  XmlParser parser("Parser");
1007  Document doc = parser.getDocument(objXml);
1008  Element message = doc.getRootElement();
1009  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1010  {
1011  Element ele = message.getChildElements().at(var);
1012  if(ele.getTagName()=="long")
1013  {
1014  t->insert(CastUtil::lexical_cast<long>(ele.getText()));
1015  }
1016  }
1017  return t;
1018  }
1019  else if(cls=="bool")
1020  {
1021  multiset<bool> *t = new multiset<bool>;
1022  XmlParser parser("Parser");
1023  Document doc = parser.getDocument(objXml);
1024  Element message = doc.getRootElement();
1025  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1026  {
1027  Element ele = message.getChildElements().at(var);
1028  if(ele.getTagName()=="bool")
1029  {
1030  t->insert(CastUtil::lexical_cast<bool>(ele.getText()));
1031  }
1032  }
1033  return t;
1034  }
1035  else
1036  return _unserMulSet(objXml,cls);
1037 }
1038 
1039 void* XMLSerialize::unserializeq(string objXml)
1040 {
1041  string cls = objXml.substr(7,objXml.find(">")-7);
1042  if(cls=="string" || cls=="std::string")
1043  {
1044  queue<string> *t = new queue<string>;
1045  XmlParser parser("Parser");
1046  Document doc = parser.getDocument(objXml);
1047  Element message = doc.getRootElement();
1048  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1049  {
1050  Element ele = message.getChildElements().at(var);
1051  if(ele.getTagName()=="string" || ele.getTagName()=="std::string")
1052  {
1053  t->push(ele.getText());
1054  }
1055  }
1056  return t;
1057  }
1058  else if(cls=="double")
1059  {
1060  queue<double> *t = new queue<double>;
1061  XmlParser parser("Parser");
1062  Document doc = parser.getDocument(objXml);
1063  Element message = doc.getRootElement();
1064  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1065  {
1066  Element ele = message.getChildElements().at(var);
1067  if(ele.getTagName()=="double")
1068  {
1069  t->push(CastUtil::lexical_cast<double>(ele.getText()));
1070  }
1071  }
1072  return t;
1073  }
1074  else if(cls=="float")
1075  {
1076  queue<float> *t = new queue<float>;
1077  XmlParser parser("Parser");
1078  Document doc = parser.getDocument(objXml);
1079  Element message = doc.getRootElement();
1080  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1081  {
1082  Element ele = message.getChildElements().at(var);
1083  if(ele.getTagName()=="float")
1084  {
1085  t->push(CastUtil::lexical_cast<float>(ele.getText()));
1086  }
1087  }
1088  return t;
1089  }
1090  else if(cls=="int")
1091  {
1092  queue<int> *t = new queue<int>;
1093  XmlParser parser("Parser");
1094  Document doc = parser.getDocument(objXml);
1095  Element message = doc.getRootElement();
1096  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1097  {
1098  Element ele = message.getChildElements().at(var);
1099  if(ele.getTagName()=="int")
1100  {
1101  t->push(CastUtil::lexical_cast<int>(ele.getText()));
1102  }
1103  }
1104  return t;
1105  }
1106  else if(cls=="short")
1107  {
1108  queue<short> *t = new queue<short>;
1109  XmlParser parser("Parser");
1110  Document doc = parser.getDocument(objXml);
1111  Element message = doc.getRootElement();
1112  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1113  {
1114  Element ele = message.getChildElements().at(var);
1115  if(ele.getTagName()=="short")
1116  {
1117  t->push(CastUtil::lexical_cast<short>(ele.getText()));
1118  }
1119  }
1120  return t;
1121  }
1122  else if(cls=="long")
1123  {
1124  std::queue<long> *t = new queue<long>;
1125  XmlParser parser("Parser");
1126  Document doc = parser.getDocument(objXml);
1127  Element message = doc.getRootElement();
1128  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1129  {
1130  Element ele = message.getChildElements().at(var);
1131  if(ele.getTagName()=="long")
1132  {
1133  t->push(CastUtil::lexical_cast<long>(ele.getText()));
1134  }
1135  }
1136  return t;
1137  }
1138  else if(cls=="bool")
1139  {
1140  std::queue<bool> *t = new queue<bool>;
1141  XmlParser parser("Parser");
1142  Document doc = parser.getDocument(objXml);
1143  Element message = doc.getRootElement();
1144  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1145  {
1146  Element ele = message.getChildElements().at(var);
1147  if(ele.getTagName()=="bool")
1148  {
1149  t->push(CastUtil::lexical_cast<bool>(ele.getText()));
1150  }
1151  }
1152  return t;
1153  }
1154  else
1155  return _unserQ(objXml,cls);
1156 }
1157 
1158 void* XMLSerialize::unserializedq(string objXml)
1159 {
1160  string cls = objXml.substr(7,objXml.find(">")-7);
1161  if(cls=="string" || cls=="std::string")
1162  {
1163  deque<string> *t = new deque<string>;
1164  XmlParser parser("Parser");
1165  Document doc = parser.getDocument(objXml);
1166  Element message = doc.getRootElement();
1167  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1168  {
1169  Element ele = message.getChildElements().at(var);
1170  if(ele.getTagName()=="string" || ele.getTagName()=="std::string")
1171  {
1172  t->push_back(ele.getText());
1173  }
1174  }
1175  return t;
1176  }
1177  else if(cls=="double")
1178  {
1179  deque<double> *t = new deque<double>;
1180  XmlParser parser("Parser");
1181  Document doc = parser.getDocument(objXml);
1182  Element message = doc.getRootElement();
1183  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1184  {
1185  Element ele = message.getChildElements().at(var);
1186  if(ele.getTagName()=="double")
1187  {
1188  t->push_back(CastUtil::lexical_cast<double>(ele.getText()));
1189  }
1190  }
1191  return t;
1192  }
1193  else if(cls=="float")
1194  {
1195  deque<float> *t = new deque<float>;
1196  XmlParser parser("Parser");
1197  Document doc = parser.getDocument(objXml);
1198  Element message = doc.getRootElement();
1199  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1200  {
1201  Element ele = message.getChildElements().at(var);
1202  if(ele.getTagName()=="float")
1203  {
1204  t->push_back(CastUtil::lexical_cast<float>(ele.getText()));
1205  }
1206  }
1207  return t;
1208  }
1209  else if(cls=="int")
1210  {
1211  deque<int> *t = new deque<int>;
1212  XmlParser parser("Parser");
1213  Document doc = parser.getDocument(objXml);
1214  Element message = doc.getRootElement();
1215  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1216  {
1217  Element ele = message.getChildElements().at(var);
1218  if(ele.getTagName()=="int")
1219  {
1220  t->push_back(CastUtil::lexical_cast<int>(ele.getText()));
1221  }
1222  }
1223  return t;
1224  }
1225  else if(cls=="short")
1226  {
1227  deque<short> *t = new deque<short>;
1228  XmlParser parser("Parser");
1229  Document doc = parser.getDocument(objXml);
1230  Element message = doc.getRootElement();
1231  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1232  {
1233  Element ele = message.getChildElements().at(var);
1234  if(ele.getTagName()=="short")
1235  {
1236  t->push_back(CastUtil::lexical_cast<short>(ele.getText()));
1237  }
1238  }
1239  return t;
1240  }
1241  else if(cls=="long")
1242  {
1243  deque<long> *t = new deque<long>;
1244  XmlParser parser("Parser");
1245  Document doc = parser.getDocument(objXml);
1246  Element message = doc.getRootElement();
1247  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1248  {
1249  Element ele = message.getChildElements().at(var);
1250  if(ele.getTagName()=="long")
1251  {
1252  t->push_back(CastUtil::lexical_cast<long>(ele.getText()));
1253  }
1254  }
1255  return t;
1256  }
1257  else if(cls=="bool")
1258  {
1259  deque<bool> *t = new deque<bool>;
1260  XmlParser parser("Parser");
1261  Document doc = parser.getDocument(objXml);
1262  Element message = doc.getRootElement();
1263  for (int var = 0; var < (int)message.getChildElements().size(); var++)
1264  {
1265  Element ele = message.getChildElements().at(var);
1266  if(ele.getTagName()=="bool")
1267  {
1268  t->push_back(CastUtil::lexical_cast<bool>(ele.getText()));
1269  }
1270  }
1271  return t;
1272  }
1273  else
1274  return _unserDq(objXml,cls);
1275 }
1276 
1277 void* XMLSerialize::_unserSet(string objXml,string className)
1278 {
1279  void* obj = NULL;
1280  string libName = Constants::INTER_LIB_FILE;
1281  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
1282  if(dlib == NULL)
1283  {
1284  cerr << dlerror() << endl;
1285  exit(-1);
1286  }
1287  string methodname = "unSerialize"+className+"Set";
1288  void *mkr = dlsym(dlib, methodname.c_str());
1289  typedef void* (*RfPtr) (string);
1290  RfPtr f = (RfPtr)mkr;
1291  if(f!=NULL)
1292  {
1293  obj = f(objXml);
1294  }
1295  return obj;
1296 }
1297 
1298 void* XMLSerialize::_unserMulSet(string objXml,string className)
1299 {
1300  void* obj = NULL;
1301  string libName = Constants::INTER_LIB_FILE;
1302  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
1303  if(dlib == NULL)
1304  {
1305  cerr << dlerror() << endl;
1306  exit(-1);
1307  }
1308  string methodname = "unSerialize"+className+"MulSet";
1309  void *mkr = dlsym(dlib, methodname.c_str());
1310  typedef void* (*RfPtr) (string);
1311  RfPtr f = (RfPtr)mkr;
1312  if(f!=NULL)
1313  {
1314  obj = f(objXml);
1315  }
1316  return obj;
1317 }
1318 
1319 void* XMLSerialize::_unserQ(string objXml,string className)
1320 {
1321  void* obj = NULL;
1322  string libName = Constants::INTER_LIB_FILE;
1323  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
1324  if(dlib == NULL)
1325  {
1326  cerr << dlerror() << endl;
1327  exit(-1);
1328  }
1329  string methodname = "unSerialize"+className+"Q";
1330  void *mkr = dlsym(dlib, methodname.c_str());
1331  typedef void* (*RfPtr) (string);
1332  RfPtr f = (RfPtr)mkr;
1333  if(f!=NULL)
1334  {
1335  obj = f(objXml);
1336  }
1337  return obj;
1338 }
1339 
1340 void* XMLSerialize::_unserDq(string objXml,string className)
1341 {
1342  void* obj = NULL;
1343  string libName = Constants::INTER_LIB_FILE;
1344  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
1345  if(dlib == NULL)
1346  {
1347  cerr << dlerror() << endl;
1348  exit(-1);
1349  }
1350  string methodname = "unSerialize"+className+"Dq";
1351  void *mkr = dlsym(dlib, methodname.c_str());
1352  typedef void* (*RfPtr) (string);
1353  RfPtr f = (RfPtr)mkr;
1354  if(f!=NULL)
1355  {
1356  obj = f(objXml);
1357  }
1358  return obj;
1359 }
1360 
1361 void* XMLSerialize::_unserLis(string objXml,string className)
1362 {
1363  void* obj = NULL;
1364  string libName = Constants::INTER_LIB_FILE;
1365  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
1366  if(dlib == NULL)
1367  {
1368  cerr << dlerror() << endl;
1369  exit(-1);
1370  }
1371  string methodname = "unSerialize"+className+"Lis";
1372  void *mkr = dlsym(dlib, methodname.c_str());
1373  typedef void* (*RfPtr) (string);
1374  RfPtr f = (RfPtr)mkr;
1375  if(f!=NULL)
1376  {
1377  obj = f(objXml);
1378  }
1379  return obj;
1380 }
1381 
1382 void* XMLSerialize::_unserVec(string objXml,string className)
1383 {
1384  void* obj = NULL;
1385  string libName = Constants::INTER_LIB_FILE;
1386  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
1387  if(dlib == NULL)
1388  {
1389  cerr << dlerror() << endl;
1390  exit(-1);
1391  }
1392  string methodname = "unSerialize"+className+"Vec";
1393  void *mkr = dlsym(dlib, methodname.c_str());
1394  typedef void* (*RfPtr) (string);
1395  RfPtr f = (RfPtr)mkr;
1396  if(f!=NULL)
1397  {
1398  obj = f(objXml);
1399  }
1400  return obj;
1401 }
1402 
1403 
1404 void* XMLSerialize::_unser(string objXml,string className)
1405 {
1406  void* obj = NULL;
1407  string libName = Constants::INTER_LIB_FILE;
1408  void *dlib = dlopen(libName.c_str(), RTLD_NOW);
1409  if(dlib == NULL)
1410  {
1411  cerr << dlerror() << endl;
1412  exit(-1);
1413  }
1414  string methodname = "unSerialize"+className;
1415  void *mkr = dlsym(dlib, methodname.c_str());
1416  typedef void* (*RfPtr) (string);
1417  RfPtr f = (RfPtr)mkr;
1418  if(f!=NULL)
1419  {
1420  obj = f(objXml);
1421  }
1422  return obj;
1423 }