ffead.server.doc
Serialize.h
1 /*
2  Copyright 2009-2012, 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 #ifndef SERIALIZABLE_H_
17 #define SERIALIZABLE_H_
18 #include "XmlParser.h"
19 #include "CastUtil.h"
20 #include <stdexcept>
21 #include <dlfcn.h>
22 #include <cxxabi.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include "string"
26 #include <sstream>
27 #include <typeinfo>
28 #include "Object.h"
29 #include "queue"
30 #include "deque"
31 #include "list"
32 #include "map"
33 #include "set"
34 #include "stack"
35 #include "DateFormat.h"
36 #include "BinaryData.h"
37 #include "Constants.h"
38 #include "AMEFResources.h"
39 #include "JSONUtil.h"
40 
41 using namespace std;
42 typedef string (*SerPtr) (void*);
43 typedef void* (*UnSerPtr) (string);
44 
45 class Serialize {
46  static string demangle(const char *mangled);
47  static string getClassName(void* instance);
48  static string _handleAllSerialization(string className,void *t);
49  static void* _handleAllUnSerialization(string objXml,string className);
50  static string _ser(void* t,string classN);
51  static string _servec(void* t,string classN);
52  static string _serlis(void* t,string classN);
53  static string _serset(void* t,string classN);
54  static string _sermultiset(void* t,string classN);
55  static string _serq(void* t,string classN);
56  static string _serdq(void* t,string classN);
57  static string _ser(Object);
58  static void* _unser(string objXml,string classN);
59  static void* unserializevec(AMEFObject* root, string objXml);
60  static void* unserializelist(AMEFObject* root, string objXml);
61  static void* unserializeset(AMEFObject* root, string objXml);
62  static void* unserializemultiset(AMEFObject* root, string objXml);
63  static void* unserializeq(AMEFObject* root, string objXml);
64  static void* unserializedq(AMEFObject* root, string objXml);
65 
66  static void* _unserVec(string objXml,string className);
67  static void* _unserLis(string objXml,string className);
68  static void* _unserQ(string objXml,string className);
69  static void* _unserDq(string objXml,string className);
70  static void* _unserSet(string objXml,string className);
71  static void* _unserMulSet(string objXml,string className);
72 
73  template <class T> static string serializeset(set<T> t)
74  {
75  set<T> st = t;
76  T td;
77  int cnt = 0;
78  const char *mangled = typeid(td).name();
79  string className = demangle(mangled);
80  className = "set<" + className + ">";
81  AMEFEncoder enc;
82  AMEFObject object;
83  object.setName(className);
84  while(cnt++<(int)t.size())
85  {
86  object.addPacket(serialize<T>(*st.begin()));
87  st.erase(st.begin());
88  }
89  return enc.encodeB(&object, false);
90  }
91  template <class T> static string serializemultiset(multiset<T> t)
92  {
93  multiset<T> st = t;
94  T td;
95  int cnt = 0;
96  const char *mangled = typeid(td).name();
97  string className = demangle(mangled);
98  className = "multiset<" + className + ">";
99  AMEFEncoder enc;
100  AMEFObject object;
101  object.setName(className);
102  while(cnt++<(int)t.size())
103  {
104  object.addPacket(serialize<T>(*st.begin()));
105  st.erase(st.begin());
106  }
107  return enc.encodeB(&object, false);
108  }
109  template <class T> static string serializevec(vector<T> t)
110  {
111  vector<T> st = t;
112  T td;
113  int cnt = 0;
114  const char *mangled = typeid(td).name();
115  string className = demangle(mangled);
116  className = "vector<" + className + ">";
117  AMEFEncoder enc;
118  AMEFObject object;
119  object.setName(className);
120  while(cnt++<(int)t.size())
121  {
122  object.addPacket(serialize<T>(*st.begin()));
123  st.erase(st.begin());
124  }
125  return enc.encodeB(&object, false);
126  }
127  template <class T> static string serializedq(deque<T> t)
128  {
129  deque<T> st = t;
130  T td;
131  int cnt = 0;
132  const char *mangled = typeid(td).name();
133  string className = demangle(mangled);
134  className = "deque<" + className + ">";
135  AMEFEncoder enc;
136  AMEFObject object;
137  object.setName(className);
138  while(cnt++<(int)t.size())
139  {
140  object.addPacket(serialize<T>(*st.begin()));
141  st.erase(st.begin());
142  }
143  return enc.encodeB(&object, false);
144  }
145  template <class T> static string serializelist(list<T> t)
146  {
147  list<T> st = t;
148  T td;
149  int cnt = 0;
150  const char *mangled = typeid(td).name();
151  string className = demangle(mangled);
152  className = "list<" + className + ">";
153  AMEFEncoder enc;
154  AMEFObject object;
155  object.setName(className);
156  while(cnt++<(int)t.size())
157  {
158  object.addPacket(serialize<T>(*st.begin()));
159  st.erase(st.begin());
160  }
161  return enc.encodeB(&object, false);
162  }
163  template <class T> static string serializeq(std::queue<T> t)
164  {
165  std::queue<T> tt = t;
166  T td;
167  const char *mangled = typeid(td).name();
168  string className = demangle(mangled);
169  className = "queue<" + className + ">";
170  AMEFEncoder enc;
171  AMEFObject object;
172  object.setName(className);
173  if(!tt.empty())
174  {
175  for(int var=0;var<(int)tt.size();var++)
176  {
177  object.addPacket(serialize<T>(tt.front()));
178  tt.pop();
179  }
180  }
181  return enc.encodeB(&object, false);
182  }
183  /*template <class T> static string serializestack(stack<T> t)
184  {
185  stack<T> tt = t;
186  T td;
187  const char *mangled = typeid(td).name();
188  string className = demangle(mangled);
189  className = "stack<" + className + ">";
190  AMEFEncoder enc;
191  AMEFObject object;
192  object.setName(className);
193  if(!tt.empty())
194  {
195  for(int var=0;var<(int)tt.size();var++)
196  {
197  object.addPacket(serialize<T>(tt.front()));
198  tt.pop();
199  }
200  }
201  return enc.encodeB(&object, false);
202  }*/
203 public:
204  Serialize(){}
205  ~Serialize(){}
206 
207  template <class T> static string serialize(T t)
208  {
209  string objXml;
210  const char *mangled = typeid(t).name();
211  string className = demangle(mangled);
212  return _handleAllSerialization(className,&t);
213  }
214  static string serializeObject(Object t)
215  {
216  return _handleAllSerialization(t.getTypeName(),t.getVoidPointer());
217  }
218 
219  static string serializeUnknown(void* t,string className)
220  {
221  return _handleAllSerialization(className,t);
222  }
223 
224  template <class K,class V> static string serialize(map<K,V> mp)
225  {
226  map<K,V> mpt = mp;
227  AMEFEncoder enc;
228  AMEFObject object;
229  K k;
230  const char *mangled = typeid(k).name();
231  string kclassName = demangle(mangled);
232  V v;
233  *mangled = typeid(v).name();
234  string vclassName = demangle(mangled);
235  kclassName = "map<"+kclassName+":"+vclassName+">";
236  object.setName(kclassName);
237  while (mpt.begin()!=mpt.end())
238  {
239  string key = serialize<K>(mpt.begin()->first);
240  string value = serialize<V>(mpt.begin()->second);
241  mpt.erase(mpt.begin());
242  object.addPacket(value, key);
243  }
244  return enc.encodeB(&object, false);
245  }
246 
247  template <class K,class V> static string serialize(multimap<K,V> mp)
248  {
249  multimap<K,V> mpt = mp;
250  AMEFEncoder enc;
251  AMEFObject object;
252  K k;
253  const char *mangled = typeid(k).name();
254  string kclassName = demangle(mangled);
255  V v;
256  *mangled = typeid(v).name();
257  string vclassName = demangle(mangled);
258  kclassName = "multimap<"+kclassName+":"+vclassName+">";
259  object.setName(kclassName);
260  while (mpt.begin()!=mpt.end())
261  {
262  string key = serialize<K>(mpt.begin()->first);
263  string value = serialize<V>(mpt.begin()->second);
264  mpt.erase(mpt.begin());
265  object.addPacket(value, key);
266  }
267  return enc.encodeB(&object, false);
268  }
269 
270  template <class T> T static unserialize(string objXml)
271  {
272  T t;
273  const char *mangled = typeid(t).name();
274  string className = demangle(mangled);
275  return *(T*)_handleAllUnSerialization(objXml,className);
276  }
277 
278  static void* unSerializeUnknown(string objXml,string className)
279  {
280  return _handleAllUnSerialization(objXml,className);
281  }
282 };
283 #endif