1 #ifndef MSP_STRINGS_LEXICALCAST_H_
2 #define MSP_STRINGS_LEXICALCAST_H_
7 #include <msp/core/meta.h>
13 Thrown for errors in lexical conversions.
15 class lexical_error: public std::runtime_error
18 lexical_error(const std::string &w): runtime_error(w) { }
23 Thrown when the format is unsuitable for the type being converted.
25 class format_mismatch: public lexical_error
28 format_mismatch(const std::string &w): lexical_error(w) { }
33 Helper class for lexical_cast to facilitate operator overloading.
35 class LexicalConverter
43 LexicalConverter(const Fmt &f): fmt(f) { }
44 LexicalConverter(const std::string &s, const Fmt &f): fmt(f), filled(true), buf(s) { }
46 const Fmt &get_fmt() const { return fmt; }
47 const std::string &get() const;
48 void result(const std::string &);
52 void operator<<(LexicalConverter &, char);
53 void operator<<(LexicalConverter &, signed char);
54 void operator<<(LexicalConverter &, short);
55 void operator<<(LexicalConverter &, int);
56 void operator<<(LexicalConverter &, long);
57 void operator<<(LexicalConverter &, unsigned char);
58 void operator<<(LexicalConverter &, unsigned short);
59 void operator<<(LexicalConverter &, unsigned);
60 void operator<<(LexicalConverter &, unsigned long);
62 void operator<<(LexicalConverter &, long long);
63 void operator<<(LexicalConverter &, unsigned long long);
65 void operator<<(LexicalConverter &, bool);
66 void operator<<(LexicalConverter &, float);
67 void operator<<(LexicalConverter &, double);
68 void operator<<(LexicalConverter &, long double);
69 void operator<<(LexicalConverter &, const std::string &);
70 void operator<<(LexicalConverter &, const char *);
71 void operator<<(LexicalConverter &, const void *);
73 void operator>>(const LexicalConverter &, char &);
74 void operator>>(const LexicalConverter &, signed char &);
75 void operator>>(const LexicalConverter &, short &);
76 void operator>>(const LexicalConverter &, int &);
77 void operator>>(const LexicalConverter &, long &);
78 void operator>>(const LexicalConverter &, unsigned char &);
79 void operator>>(const LexicalConverter &, unsigned short &);
80 void operator>>(const LexicalConverter &, unsigned int &);
81 void operator>>(const LexicalConverter &, unsigned long &);
83 void operator>>(const LexicalConverter &, long long &);
84 void operator>>(const LexicalConverter &, unsigned long long &);
86 void operator>>(const LexicalConverter &, bool &);
87 void operator>>(const LexicalConverter &, float &);
88 void operator>>(const LexicalConverter &, double &);
89 void operator>>(const LexicalConverter &, long double &);
90 void operator>>(const LexicalConverter &, std::string &);
92 // Generic operators using stringstream
94 struct CheckFormattedOutput: Sfinae
96 static std::ostream &s;
98 static Yes f(int (*)[sizeof(s<<reinterpret_cast<const T &>(s))]);
102 struct CheckFormattedInput: Sfinae
104 static std::istream &s;
106 static Yes f(int (*)[sizeof(s>>reinterpret_cast<T &>(s))]);
110 template<typename T> struct HasFormattedOutput: Sfinae::Evaluate<CheckFormattedOutput, T> { };
111 template<typename T> struct HasFormattedInput: Sfinae::Evaluate<CheckFormattedInput, T> { };
115 typename std::enable_if<HasFormattedOutput<T>::value>::type
116 operator<<(LexicalConverter &c, const T &v)
118 std::ostringstream ss;
119 ss << c.get_fmt() << v;
124 typename std::enable_if<HasFormattedInput<T>::value>::type
125 operator>>(const LexicalConverter &c, T &v)
127 std::istringstream ss(c.get());
128 ss.setf(std::ios_base::fmtflags(0), std::ios_base::skipws);
130 if(ss.fail() || !ss.eof())
131 throw lexical_error("conversion failure");
135 Helper struct to provide partial template specialization.
137 template<typename T, typename F>
141 struct LexicalCast<T, std::string>
143 static T cast(const std::string &s, const Fmt &f = Fmt())
145 LexicalConverter conv(s, f);
153 struct LexicalCast<std::string, F>
155 static std::string cast(const F &v, const Fmt &f = Fmt())
157 LexicalConverter conv(f);
164 struct LexicalCast<std::string, std::string>
166 static std::string cast(const std::string &v, const Fmt &f = Fmt())
168 LexicalConverter conv(f);
174 /** Perform a lexical conversion between a string and another type. The source
175 type can normally be deduced by the compiler, so this can be used just like the
176 standard C++ casts. A format may additionally be specified to force a specific
178 template<typename T, typename F>
179 inline T lexical_cast(const F &v, const Fmt &f = Fmt())
181 return LexicalCast<T, F>::cast(v, f);