6fe3cb366b24015ea215c127913db9f43ac42276
[libs/core.git] / source / strings / lexicalcast.h
1 #ifndef MSP_STRINGS_LEXICALCAST_H_
2 #define MSP_STRINGS_LEXICALCAST_H_
3
4 #include <sstream>
5 #include <string>
6 #include <stdexcept>
7 #include <msp/core/meta.h>
8 #include "fmt.h"
9
10 namespace Msp {
11
12 /**
13 Thrown for errors in lexical conversions.
14 */
15 class lexical_error: public std::runtime_error
16 {
17 public:
18         lexical_error(const std::string &w): runtime_error(w) { }
19         virtual ~lexical_error() throw() { }
20 };
21
22
23 /**
24 Thrown when the format is unsuitable for the type being converted.
25 */
26 class format_mismatch: public lexical_error
27 {
28 public:
29         format_mismatch(const std::string &w): lexical_error(w) { }
30         virtual ~format_mismatch() throw() { }
31 };
32
33
34 /**
35 Helper class for lexical_cast to facilitate operator overloading.
36 */
37 class LexicalConverter
38 {
39 private:
40         Fmt fmt;
41         bool filled;
42         std::string buf;
43
44 public:
45         LexicalConverter(const Fmt &f): fmt(f), filled(false) { }
46         LexicalConverter(const std::string &s, const Fmt &f): fmt(f), filled(true), buf(s) { }
47
48         const Fmt &get_fmt() const { return fmt; }
49         const std::string &get() const;
50         void result(const std::string &);
51 };
52
53
54 void operator<<(LexicalConverter &, char);
55 void operator<<(LexicalConverter &, signed char);
56 void operator<<(LexicalConverter &, short);
57 void operator<<(LexicalConverter &, int);
58 void operator<<(LexicalConverter &, long);
59 void operator<<(LexicalConverter &, unsigned char);
60 void operator<<(LexicalConverter &, unsigned short);
61 void operator<<(LexicalConverter &, unsigned);
62 void operator<<(LexicalConverter &, unsigned long);
63 #ifdef __GNUC__
64 void operator<<(LexicalConverter &, long long);
65 void operator<<(LexicalConverter &, unsigned long long);
66 #endif
67 void operator<<(LexicalConverter &, bool);
68 void operator<<(LexicalConverter &, float);
69 void operator<<(LexicalConverter &, double);
70 void operator<<(LexicalConverter &, long double);
71 void operator<<(LexicalConverter &, const std::string &);
72 void operator<<(LexicalConverter &, const char *);
73 void operator<<(LexicalConverter &, const void *);
74
75 void operator>>(const LexicalConverter &, char &);
76 void operator>>(const LexicalConverter &, signed char &);
77 void operator>>(const LexicalConverter &, short &);
78 void operator>>(const LexicalConverter &, int &);
79 void operator>>(const LexicalConverter &, long &);
80 void operator>>(const LexicalConverter &, unsigned char &);
81 void operator>>(const LexicalConverter &, unsigned short &);
82 void operator>>(const LexicalConverter &, unsigned int &);
83 void operator>>(const LexicalConverter &, unsigned long &);
84 #ifdef __GNUC__
85 void operator>>(const LexicalConverter &, long long &);
86 void operator>>(const LexicalConverter &, unsigned long long &);
87 #endif
88 void operator>>(const LexicalConverter &, bool &);
89 void operator>>(const LexicalConverter &, float &);
90 void operator>>(const LexicalConverter &, double &);
91 void operator>>(const LexicalConverter &, long double &);
92 void operator>>(const LexicalConverter &, std::string &);
93
94 // Generic operators using stringstream
95
96 struct CheckFormattedOutput: Sfinae
97 {
98         static std::ostream &s;
99         template<typename T>
100         static Yes f(int (*)[sizeof(s<<T())]);
101         using Sfinae::f;
102 };
103
104 struct CheckFormattedInput: Sfinae
105 {
106         static std::istream &s;
107         template<typename T>
108         static Yes f(int (*)[sizeof(s>>reinterpret_cast<T &>(s))]);
109         using Sfinae::f;
110 };
111
112 template<typename T> struct HasFormattedOutput: Sfinae::Evaluate<CheckFormattedOutput, T> { };
113 template<typename T> struct HasFormattedInput: Sfinae::Evaluate<CheckFormattedInput, T> { };
114
115
116 template<typename T>
117 typename EnableIf<HasFormattedOutput<T>::value, void>::Yes
118 operator<<(LexicalConverter &c, const T &v)
119 {
120         std::ostringstream ss;
121         ss << c.get_fmt() << v;
122         c.result(ss.str());
123 }
124
125 template<typename T>
126 typename EnableIf<HasFormattedInput<T>::value, void>::Yes
127 operator>>(const LexicalConverter &c, T &v)
128 {
129         std::istringstream ss(c.get());
130         ss.setf(std::ios_base::fmtflags(0), std::ios_base::skipws);
131         ss >> v;
132         if(ss.fail() || !ss.eof())
133                 throw lexical_error("conversion failure");
134 }
135
136 /**
137 Helper struct to provide partial template specialization.
138 */
139 template<typename T, typename F>
140 struct LexicalCast;
141
142 template<typename T>
143 struct LexicalCast<T, std::string>
144 {
145         static T cast(const std::string &s, const Fmt &f = Fmt())
146         {
147                 LexicalConverter conv(s, f);
148                 T result;
149                 conv >> result;
150                 return result;
151         }
152 };
153
154 template<typename F>
155 struct LexicalCast<std::string, F>
156 {
157         static std::string cast(const F &v, const Fmt &f = Fmt())
158         {
159                 LexicalConverter conv(f);
160                 conv << v;
161                 return conv.get();
162         }
163 };
164
165 template<>
166 struct LexicalCast<std::string, std::string>
167 {
168         static std::string cast(const std::string &v, const Fmt &f = Fmt())
169         {
170                 LexicalConverter conv(f);
171                 conv << v;
172                 return conv.get();
173         }
174 };
175
176 /** Perform a lexical conversion between a string and another type.  The source
177 type can normally be deduced by the compiler, so this can be used just like the
178 standard C++ casts.  A format may additionally be specified to force a specific
179 interpretation. */
180 template<typename T, typename F>
181 inline T lexical_cast(const F &v, const Fmt &f = Fmt())
182 {
183         return LexicalCast<T, F>::cast(v, f);
184 }
185
186 } // namespace Msp
187
188 #endif