#include <sstream>
#include <string>
#include <stdexcept>
+#include <msp/core/meta.h>
#include "fmt.h"
namespace Msp {
{
private:
Fmt fmt;
+ bool filled;
std::string buf;
public:
- LexicalConverter(const Fmt &f): fmt(f) { }
- LexicalConverter(const std::string &s, const Fmt &f): fmt(f), buf(s) { }
+ LexicalConverter(const Fmt &f): fmt(f), filled(false) { }
+ LexicalConverter(const std::string &s, const Fmt &f): fmt(f), filled(true), buf(s) { }
const Fmt &get_fmt() const { return fmt; }
- const std::string &get() const { return buf; }
+ const std::string &get() const;
void result(const std::string &);
};
// Generic operators using stringstream
template<typename T>
-void operator<<(LexicalConverter &c, const T &v)
+struct HasFormattedOutput: Sfinae
+{
+ static std::ostream &s;
+ static T &v;
+
+ /* The expression must depend on the template parameter, or the compiler
+ will give an error. */
+ template<typename U>
+ static Yes f(int (*)[sizeof(s<<HasFormattedOutput<U>::v)]);
+ template<typename U>
+ static No f(...);
+
+ enum { value = Evaluate<sizeof(f<T>(0))>::value };
+};
+
+template<typename T>
+struct HasFormattedInput: Sfinae
+{
+ static std::istream &s;
+ static T &v;
+
+ template<typename U>
+ static Yes f(int (*)[sizeof(s>>HasFormattedOutput<U>::v)]);
+ template<typename U>
+ static No f(...);
+
+ enum { value = Evaluate<sizeof(f<T>(0))>::value };
+};
+
+
+template<typename T>
+typename EnableIf<HasFormattedOutput<T>::value, void>::Yes
+operator<<(LexicalConverter &c, const T &v)
{
std::ostringstream ss;
ss<<c.get_fmt()<<v;
}
template<typename T>
-void operator>>(const LexicalConverter &c, T &v)
+typename EnableIf<HasFormattedInput<T>::value, void>::Yes
+operator>>(const LexicalConverter &c, T &v)
{
std::istringstream ss(c.get());
ss.setf(std::ios_base::fmtflags(0), std::ios_base::skipws);