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