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         ~lexical_error() throw() override = default;
  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         ~format_mismatch() throw() override = default;
  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 = false;
  42         std::string buf;
  43
  44 public:
  45         LexicalConverter(const Fmt &f): fmt(f) { }
  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<<reinterpret_cast<const T &>(s))]);
 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 std::enable_if<HasFormattedOutput<T>::value>::type
 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 std::enable_if<HasFormattedInput<T>::value>::type
 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