Simple SFML GUI  0.2a
StringConvertions.hpp
1 #ifndef STRINGCONVERTIONS_HPP
2 #define STRINGCONVERTIONS_HPP
3 
4 #include <string>
5 #include <iomanip>
6 #include <sstream>
7 #include <vector>
8 #include <SFML/System/Vector2.hpp>
9 #include <SFML/System/Vector3.hpp>
10 #include <SFML/Graphics/Rect.hpp>
11 #include <SFML/Graphics/Color.hpp>
12 
13 char operator<<(char* out, const std::string& in);
14 
15 std::string& operator<<(std::string& out, char in);
16 
17 unsigned char operator<<(unsigned char* out, const std::string& in);
18 
19 std::string& operator<<(std::string& out, unsigned char in);
20 
21 
22 template<typename T>
23 void numericConvert(
24  T* out,
25  const std::string& in,
26  typename std::enable_if<!std::is_enum<T>::value>::type* dummy = 0
27 ) {
28  T backup(*out);
29  std::stringstream ss;
30  ss.imbue(std::locale("C"));
31  ss.str(in);
32  ss >> *out;
33  if(ss.fail())
34  *out = backup;
35 }
36 
37 template<typename T>
38 void numericConvert(
39  T* out,
40  const std::string& in,
41  typename std::enable_if<std::is_enum<T>::value>::type* dummy = 0
42 ) {
43  T backup(*out);
44  std::stringstream ss;
45  ss.imbue(std::locale("C"));
46  ss.str(in);
47  int tmp = 0;
48  ss >> tmp;
49  if(!ss.fail())
50  *out = static_cast<T>(tmp);
51 }
52 
53 template<typename T>
54 T operator<<(T* out, const std::string& in) {
55  numericConvert(out, in);
56  return *out;
57 }
58 
59 std::string& operator<<(std::string& out, sf::Color in);
60 sf::Color operator<<(sf::Color* out, const std::string& in);
61 
62 template<typename T>
63 std::string numericConvert(
64  const T& in,
65  typename std::enable_if<!std::is_enum<T>::value>::type* dummy = 0
66 ) {
67  std::stringstream ss;
68  ss.imbue(std::locale("C"));
69  ss << std::setprecision(32) << in;
70  return ss.str();
71 }
72 
73 template<typename T>
74 std::string numericConvert(
75  const T& in,
76  typename std::enable_if<std::is_enum<T>::value>::type* dummy = 0
77 ) {
78  std::stringstream ss;
79  ss.imbue(std::locale("C"));
80  ss << std::setprecision(32) << static_cast<int>(in);
81  return ss.str();
82 }
83 
84 template<typename T>
85 std::string& operator<<(std::string& out, const T& in) {
86  return out += numericConvert(in);
87 }
88 
89 template<typename F, typename S>
90 std::string& operator<<(std::string& out, const std::pair<F,S>& in) {
91  std::stringstream ss;
92  ss.imbue(std::locale("C"));
93  ss << std::setprecision(32);
94 
95  if(sizeof(F) < 4) {
96  ss << static_cast<long long>(in.first);
97  } else {
98  ss << in.first;
99  }
100 
101  ss << " ";
102 
103  if(sizeof(S) < 4) {
104  ss << static_cast<long long>(in.second);
105  } else {
106  ss << in.second;
107  }
108  return out += ss.str();
109 }
110 
111 template<typename F, typename S>
112 std::pair<F,S> operator<<(std::pair<F,S>* out, const std::string& in) {
113  std::pair<F,S> backup(*out);
114  std::stringstream ss;
115  ss.imbue(std::locale("C"));
116  ss.str(in);
117  if(!ss.good())
118  return *out;
119 
120  if(sizeof(F) < 4) {
121  long long i = 0;
122  ss >> i;
123  out->first = i;
124  } else {
125  ss >> out->first;
126  }
127 
128  if(ss.fail())
129  return (*out = backup);
130 
131  if(sizeof(S) < 4) {
132  long long i = 0;
133  ss >> i;
134  out->second = i;
135  } else {
136  ss >> out->second;
137  }
138 
139  if(ss.fail())
140  return (*out = backup);
141 
142  return *out;
143 }
144 
145 template<typename T>
146 std::string& operator<<(std::string& out, const sf::Vector2<T>& in) {
147  std::stringstream ss;
148  ss.imbue(std::locale("C"));
149  ss << std::setprecision(32) << in.x << " " << in.y;
150  return out += ss.str();
151 }
152 
153 template<typename T>
154 sf::Vector2<T> operator<<(sf::Vector2<T>* out, const std::string& in) {
155  sf::Vector2<T> backup(*out);
156  std::stringstream ss;
157  ss.imbue(std::locale("C"));
158  ss.str(in);
159  if(!ss.good())
160  return *out;
161 
162  ss >> out->x;
163  if(ss.fail())
164  return (*out = backup);
165 
166  ss >> out->y;
167  if(ss.fail())
168  return (*out = backup);
169 
170  return *out;
171 }
172 
173 template<typename T>
174 std::string& operator<<(std::string& out, const sf::Vector3<T>& in) {
175  std::stringstream ss;
176  ss.imbue(std::locale("C"));
177  ss << std::setprecision(32) << in.x << " " << in.y << " " << in.z;
178  return out += ss.str();
179 }
180 
181 template<typename T>
182 sf::Vector3<T> operator<<(sf::Vector3<T>* out, const std::string& in) {
183  sf::Vector3<T> backup(*out);
184  std::stringstream ss;
185  ss.imbue(std::locale("C"));
186  ss.str(in);
187  if(!ss.good())
188  return *out;
189 
190  ss >> out->x;
191  if(ss.fail())
192  return (*out = backup);
193 
194  ss >> out->y;
195  if(ss.fail())
196  return (*out = backup);
197 
198  ss >> out->z;
199  if(ss.fail())
200  return (*out = backup);
201 
202  return *out;
203 }
204 
205 template<typename T>
206 std::string& operator<<(std::string& out, const sf::Rect<T>& in) {
207  std::stringstream ss;
208  ss.imbue(std::locale("C"));
209  ss << std::setprecision(32) << in.left << " " << in.top << " " << in.width << " " << in.height;
210  return out += ss.str();
211 }
212 
213 template<typename T>
214 sf::Rect<T> operator<<(sf::Rect<T>* out, const std::string& in) {
215  sf::Rect<T> backup(*out);
216  std::stringstream ss;
217  ss.imbue(std::locale("C"));
218  ss.str(in);
219  if(!ss.good())
220  return backup;
221 
222  ss >> out->left;
223  if(ss.fail())
224  return (*out = backup);
225 
226  ss >> out->top;
227  if(ss.fail())
228  return (*out = backup);
229 
230  ss >> out->width;
231  if(ss.fail())
232  return (*out = backup);
233 
234  ss >> out->height;
235  if(ss.fail())
236  return (*out = backup);
237 
238  return *out;
239 }
240 
241 template<typename T>
242 std::string& operator<<(std::string& out, const std::vector<T>& in) {
243  std::stringstream ss;
244  ss.imbue(std::locale("C"));
245  ss << std::setprecision(32);
246  if(sizeof(T) < 4) {
247  for(const auto& e : in) {
248  int num = e;
249  ss << num << " ";
250  }
251  } else {
252  for(const auto& e : in) {
253  ss << e << " ";
254  }
255  }
256 
257  return out += ss.str();
258 }
259 
260 template<typename T>
261 std::string& operator<<(std::string& out, const std::vector<std::basic_string<T>>& in) {
262  std::stringstream ss;
263  ss.imbue(std::locale("C"));
264  ss << std::setprecision(32);
265 
266  for(const auto& e : in) {
267  ss << e << " ";
268  }
269 
270  return out += ss.str();
271 }
272 
273 template<typename T>
274 std::vector<T> operator<<(std::vector<T>* out, const std::string& in) {
275  std::stringstream ss;
276  ss.imbue(std::locale("C"));
277  ss << std::setprecision(32);
278  ss.str(in);
279 
280  if(sizeof(T) < 4) {
281  while(ss.good()) {
282  int tmp;
283  ss >> tmp;
284  if(ss.fail())
285  break;
286 
287  out->push_back(tmp);
288  }
289  } else {
290  while(ss.good()) {
291  T tmp;
292  ss >> tmp;
293  if(ss.fail())
294  break;
295 
296  out->push_back(tmp);
297  }
298  }
299 
300  return *out;
301 }
302 
303 template<typename T>
304 std::vector<std::basic_string<T>> operator<<(std::vector<std::basic_string<T>>* out, const std::string& in) {
305  std::stringstream ss;
306  ss.imbue(std::locale("C"));
307  ss << std::setprecision(32);
308  ss.str(in);
309 
310  while(ss.good()) {
311  std::basic_string<T> tmp;
312  ss >> tmp;
313  if(ss.fail())
314  break;
315 
316  out->push_back(tmp);
317  }
318 
319  return *out;
320 }
321 
322 #endif // STRINGCONVERIONS_HPP
S
Definition: S.hpp:8
Generated by   doxygen 1.8.13