ffead.server.doc
CastUtil.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 /*
17  * CastUtil.h
18  *
19  * Created on: Aug 5, 2012
20  * Author: Sumeet
21  */
22 
23 #ifndef CASTUTIL_H_
24 #define CASTUTIL_H_
25 #include "sstream"
26 #include <stdlib.h>
27 #include "StringUtil.h"
28 #include <cxxabi.h>
29 #include "cstring"
30 #include <stdio.h>
31 using namespace std;
32 
33 class CastUtil {
34  static string demangle(const char *mangled)
35  {
36  int status;
37  char *demangled;
38  using namespace abi;
39  demangled = __cxa_demangle(mangled, NULL, 0, &status);
40  string s(demangled);
41  delete demangled;
42  return s;
43  }
44  template <typename T> static string getClassName(T t)
45  {
46  const char *mangled = typeid(t).name();
47  string tn = demangle(mangled);
48  if(tn[tn.length()-1]=='*')
49  tn = tn.substr(0,tn.length()-1);
50  return tn;
51  }
52 public:
53  CastUtil();
54  virtual ~CastUtil();
55  template <typename T, typename R> static R cast(const T& val)
56  {
57  return lexical_cast<R>(val);
58  }
59 
60  template <typename T> static T lexical_cast(const short& val)
61  {
62  T t;
63  stringstream ss;
64  ss << val;
65  ss >> t;
66  if(ss)
67  {
68  return t;
69  }
70  else
71  {
72  string tn = getClassName(t);
73  throw ("Conversion exception - short to " + tn);
74  }
75  }
76  template <typename T> static T lexical_cast(const unsigned short& val)
77  {
78  T t;
79  stringstream ss;
80  ss << val;
81  ss >> t;
82  if(ss)
83  {
84  return t;
85  }
86  else
87  {
88  string tn = getClassName(t);
89  throw ("Conversion exception - unsigned short to " + tn);
90  }
91  }
92  template <typename T> static T lexical_cast(const int& val)
93  {
94  T t;
95  stringstream ss;
96  ss << val;
97  ss >> t;
98  if(ss)
99  {
100  return t;
101  }
102  else
103  {
104  string tn = getClassName(t);
105  throw ("Conversion exception - int to " + tn);
106  }
107  }
108  template <typename T> static T lexical_cast(const unsigned int& val)
109  {
110  T t;
111  stringstream ss;
112  ss << val;
113  ss >> t;
114  if(ss)
115  {
116  return t;
117  }
118  else
119  {
120  string tn = getClassName(t);
121  throw ("Conversion exception - unsigned int to " + tn);
122  }
123  }
124  template <typename T> static T lexical_cast(const long& val)
125  {
126  T t;
127  stringstream ss;
128  ss << val;
129  ss >> t;
130  if(ss)
131  {
132  return t;
133  }
134  else
135  {
136  string tn = getClassName(t);
137  throw ("Conversion exception - long to " + tn);
138  }
139  }
140  template <typename T> static T lexical_cast(const unsigned long& val)
141  {
142  T t;
143  stringstream ss;
144  ss << val;
145  ss >> t;
146  if(ss)
147  {
148  return t;
149  }
150  else
151  {
152  string tn = getClassName(t);
153  throw ("Conversion exception - unsigned long to " + tn);
154  }
155  }
156  template <typename T> static T lexical_cast(const long long& val)
157  {
158  T t;
159  stringstream ss;
160  ss << val;
161  ss >> t;
162  if(ss)
163  {
164  return t;
165  }
166  else
167  {
168  string tn = getClassName(t);
169  throw ("Conversion exception - long long to " + tn);
170  }
171  }
172  template <typename T> static T lexical_cast(const unsigned long long& val)
173  {
174  T t;
175  stringstream ss;
176  ss << val;
177  ss >> t;
178  if(ss)
179  {
180  return t;
181  }
182  else
183  {
184  string tn = getClassName(t);
185  throw ("Conversion exception - unsigned long long to " + tn);
186  }
187  }
188  template <typename T> static T lexical_cast(const double& val)
189  {
190  T t;
191  stringstream ss;
192  ss << val;
193  ss >> t;
194  if(ss)
195  {
196  return t;
197  }
198  else
199  {
200  string tn = getClassName(t);
201  throw ("Conversion exception - double to " + tn);
202  }
203  }
204  template <typename T> static T lexical_cast(const float& val)
205  {
206  T t;
207  stringstream ss;
208  ss << val;
209  ss >> t;
210  if(ss)
211  {
212  return t;
213  }
214  else
215  {
216  string tn = getClassName(t);
217  throw ("Conversion exception - float to " + tn);
218  }
219  }
220  template <typename T> static T lexical_cast(const bool& val)
221  {
222  T t;
223  stringstream ss;
224  ss << val;
225  ss >> t;
226  if(ss)
227  {
228  return t;
229  }
230  else
231  {
232  string tn = getClassName(t);
233  throw ("Conversion exception - bool to " + tn);
234  }
235  }
236  template <typename T> static T lexical_cast(const string& val)
237  {
238  return lexical_cast<T>(val.c_str());
239  }
240  template <typename T> static T lexical_cast(const char* val)
241  {
242  T t;
243  string tn = getClassName(t);
244  char* endptr;
245  if(tn=="double" || tn=="float")
246  {
247  double d = 0;
248  d = strtod(val, &endptr);
249  if(*endptr)
250  {
251  throw "Conversion exception - string to double";
252  }
253  t = d;
254  }
255  else if(tn=="int")
256  {
257  int d = 1;
258  d = strtol(val, &endptr, 10);
259  if(*endptr)
260  {
261  throw "Conversion exception - string to int";
262  }
263  t = d;
264  }
265  else if(tn=="short")
266  {
267  short d = 1;
268  d = strtol(val, &endptr, 10);
269  if(*endptr)
270  {
271  throw "Conversion exception - string to short";
272  }
273  t = d;
274  }
275  else if(tn=="long")
276  {
277  long d = 1;
278  d = strtol(val, &endptr, 10);
279  if(*endptr)
280  {
281  throw "Conversion exception - string to long";
282  }
283  t = d;
284  }
285  else if(tn=="size_t")
286  {
287  long int d = 1;
288  d = strtol(val, &endptr, 10);
289  if(*endptr)
290  {
291  throw "Conversion exception - string to size_t";
292  }
293  t = (size_t)d;
294  }
295  else if(tn=="unsigned short")
296  {
297  unsigned short d = 1;
298  d = strtoul(val, &endptr, 10);
299  if(*endptr)
300  {
301  throw "Conversion exception - string to unsigned short";
302  }
303  t = d;
304  }
305  else if(tn=="unsigned int")
306  {
307  unsigned int d = 1;
308  d = strtoul(val, &endptr, 10);
309  if(*endptr)
310  {
311  throw "Conversion exception - string to unsigned int";
312  }
313  t = d;
314  }
315  else if(tn=="unsigned long")
316  {
317  unsigned long d = 1;
318  d = strtoul(val, &endptr, 10);
319  if(*endptr)
320  {
321  throw "Conversion exception - string to unsigned long";
322  }
323  t = d;
324  }
325  else if(tn=="long long")
326  {
327  long long d = -1;
328  if(sscanf(val, "%lld", &d)==1)
329  t = d;
330  else
331  {
332  throw "Conversion exception - string to long long";
333  }
334  }
335  else if(tn=="unsigned long long")
336  {
337  unsigned long long d = -1;
338  if(sscanf(val, "%llu", &d)==1)
339  t = d;
340  else
341  {
342  throw "Conversion exception - string to unsigned long long";
343  }
344  }
345  else if(tn=="bool")
346  {
347  bool d = false;
348  if(StringUtil::toLowerCopy(val)=="true" || StringUtil::toLowerCopy(val)=="1")
349  d = true;
350  else if(StringUtil::toLowerCopy(val)=="false" || StringUtil::toLowerCopy(val)=="0")
351  d = false;
352  else
353  {
354  throw "Conversion exception - string to bool";
355  }
356  t = d;
357  }
358  else if(tn=="std::string" || tn=="string")
359  {
360  if(strlen(val)==0)return t;
361  stringstream ss;
362  ss << val;
363  ss >> t;
364  if(ss)
365  {
366  return t;
367  }
368  else
369  {
370  throw "Conversion exception - string to string";
371  }
372  }
373  else
374  {
375  throw "Generic Conversion exception";
376  }
377  return t;
378  }
379 };
380 
381 #endif /* CASTUTIL_H_ */