From ff0d3252cad08280b9c320b3fea5a11c80406c23 Mon Sep 17 00:00:00 2001
From: Mikko Rasa <tdb@tdb.fi>
Date: Sat, 1 Dec 2012 22:50:39 +0200
Subject: [PATCH] Filter the types that get fallback lexical conversion
 operators

Only enable the operators for types that already have iostream formatting
operators defined.  Having them exist for everything would interfere with
some other stuff I'm going to commit in a moment.
---
 source/core/meta.h           | 29 +++++++++++++++++++++++++++
 source/strings/lexicalcast.h | 38 ++++++++++++++++++++++++++++++++++--
 2 files changed, 65 insertions(+), 2 deletions(-)

diff --git a/source/core/meta.h b/source/core/meta.h
index 0034512..9230965 100644
--- a/source/core/meta.h
+++ b/source/core/meta.h
@@ -11,6 +11,7 @@ template<typename T>
 struct RemoveConst<const T>
 { typedef T Type; };
 
+
 template<typename T>
 struct RemoveReference
 { typedef T Type; };
@@ -19,6 +20,34 @@ template<typename T>
 struct RemoveReference<T &>
 { typedef T Type; };
 
+
+template<bool c, typename R>
+struct EnableIf;
+
+template<typename R>
+struct EnableIf<true, R>
+{ typedef R Yes; };
+
+template<typename R>
+struct EnableIf<false, R>
+{ typedef R No; };
+
+
+/**
+Common fragments used in SFINAE-based decider constructs.
+*/
+struct Sfinae
+{
+	struct Yes { char c[2]; };
+	struct No { char c; };
+
+	template<size_t s>
+	struct Evaluate
+	{
+		enum { value = (s==sizeof(Yes)) };
+	};
+};
+
 } // namespace Msp
 
 #endif
diff --git a/source/strings/lexicalcast.h b/source/strings/lexicalcast.h
index c6a17da..80963f4 100644
--- a/source/strings/lexicalcast.h
+++ b/source/strings/lexicalcast.h
@@ -4,6 +4,7 @@
 #include <sstream>
 #include <string>
 #include <stdexcept>
+#include <msp/core/meta.h>
 #include "fmt.h"
 
 namespace Msp {
@@ -89,7 +90,39 @@ void operator>>(const LexicalConverter &, 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;
@@ -97,7 +130,8 @@ void operator<<(LexicalConverter &c, const T &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);
-- 
2.43.0