Switched convert to a templated struct that can be specialized (so we can partially specialize it)

include/yaml-cpp/value.h

@@ -8,6 +8,7 @@
 
 #include "yaml-cpp/value/value.h"
 #include "yaml-cpp/value/impl.h"
+#include "yaml-cpp/value/convert.h"
 #include "yaml-cpp/value/detail/impl.h"
 
 #endif // VALUE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/value/convert.h

@@ -0,0 +1,30 @@
+#ifndef VALUE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+
+#include "yaml-cpp/value/value.h"
+#include <sstream>
+
+namespace YAML
+{
+	// std::string
+	template<>
+	struct convert<std::string> {
+		static Value encode(const std::string& rhs) {
+			return Value(rhs);
+		}
+		
+		static bool decode(const Value& value, std::string& rhs) {
+			if(value.Type() != ValueType::Scalar)
+				return false;
+			rhs = value.scalar();
+			return true;
+		}
+	};
+}
+
+#endif // VALUE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/value/detail/impl.h

@@ -78,7 +78,7 @@ namespace YAML
 		inline bool node_data::equals(detail::shared_node pNode, const T& rhs, detail::shared_memory_holder pMemory)
 		{
 			T lhs;
-			if(convert(Value(pNode, pMemory), lhs))
+			if(convert<T>::decode(Value(pNode, pMemory), lhs))
 				return lhs == rhs;
 			return false;
 		}
@@ -86,7 +86,7 @@ namespace YAML
 		template<typename T>
 		inline shared_node node_data::convert_to_node(const T& rhs, detail::shared_memory_holder pMemory)
 		{
-			Value value = convert(rhs);
+			Value value = convert<T>::encode(rhs);
 			pMemory->merge(*value.m_pMemory);
 			return value.m_pNode;
 		}

include/yaml-cpp/value/impl.h

@@ -51,7 +51,7 @@ namespace YAML
 	inline const T Value::as() const
 	{
 		T t;
-		if(convert<T>(*this, t))
+		if(convert<T>::decode(*this, t))
 			return t;
 		throw std::runtime_error("Unable to convert to type");
 	}
@@ -85,7 +85,7 @@ namespace YAML
 	template<typename T>
 	inline void Value::Assign(const T& rhs)
 	{
-		AssignData(convert<T>(rhs));
+		AssignData(convert<T>::encode(rhs));
 	}
 
 	template<>

include/yaml-cpp/value/value.h

@@ -83,10 +83,7 @@ namespace YAML
 	bool is(const Value& lhs, const Value& rhs);
 	
 	template<typename T>
-	Value convert(const T& rhs);
+	struct convert;
-	
-	template<typename T>
-	bool convert(const Value& value, T& rhs);
 }
 
 #endif // VALUE_VALUE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/value/convert.cpp

@@ -1,51 +1,45 @@
-#include "yaml-cpp/value.h"
+#include "yaml-cpp/value/convert.h"
-#include <sstream>
 
 namespace YAML
 {
-	// std::string
-	template<>
-	Value convert(const std::string& rhs) {
-		return Value(rhs);
-	}
 
-	template<>
+//#define YAML_DEFINE_CONVERT_STREAMABLE(type)\
-	bool convert(const Value& value, std::string& rhs) {
+//	template<> Value convert(const type& rhs) {\
-		if(value.Type() != ValueType::Scalar)
+//		std::stringstream stream;\
-			return false;
+//		stream << rhs;\
-		rhs = value.scalar();
+//		return Value(stream.str());\
-		return true;
+//	}\
-	}
+//	template<> bool convert(const Value& value, type& rhs) {\
-
+//		if(value.Type() != ValueType::Scalar)\
-#define YAML_DEFINE_CONVERT_STREAMABLE(type)\
+//			return false;\
-	template<> Value convert(const type& rhs) {\
+//		std::stringstream stream(value.scalar());\
-		std::stringstream stream;\
+//		stream >> rhs;\
-		stream << rhs;\
+//		return !!stream;\
-		return Value(stream.str());\
+//	}
-	}\
+//
-	template<> bool convert(const Value& value, type& rhs) {\
+//	YAML_DEFINE_CONVERT_STREAMABLE(int)
-		if(value.Type() != ValueType::Scalar)\
+//	YAML_DEFINE_CONVERT_STREAMABLE(unsigned)
-			return false;\
+//	YAML_DEFINE_CONVERT_STREAMABLE(short)
-		std::stringstream stream(value.scalar());\
+//	YAML_DEFINE_CONVERT_STREAMABLE(unsigned short)
-		stream >> rhs;\
+//	YAML_DEFINE_CONVERT_STREAMABLE(long)
-		return !!stream;\
+//	YAML_DEFINE_CONVERT_STREAMABLE(unsigned long)
-	}
+//	YAML_DEFINE_CONVERT_STREAMABLE(long long)
-
+//	YAML_DEFINE_CONVERT_STREAMABLE(unsigned long long)
-	YAML_DEFINE_CONVERT_STREAMABLE(int)
+//
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned)
+//	YAML_DEFINE_CONVERT_STREAMABLE(char)
-	YAML_DEFINE_CONVERT_STREAMABLE(short)
+//	YAML_DEFINE_CONVERT_STREAMABLE(unsigned char)
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned short)
+//
-	YAML_DEFINE_CONVERT_STREAMABLE(long)
+//	YAML_DEFINE_CONVERT_STREAMABLE(float)
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned long)
+//	YAML_DEFINE_CONVERT_STREAMABLE(double)
-	YAML_DEFINE_CONVERT_STREAMABLE(long long)
+//	YAML_DEFINE_CONVERT_STREAMABLE(long double)
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned long long)
+//	
-
+//#undef YAML_DEFINE_CONVERT_STREAMABLE
-	YAML_DEFINE_CONVERT_STREAMABLE(char)
+//	
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned char)
+//	template<typename K, typename V>
-
+//	Value convert<std::map<K, V> >(const std::map<K, V>& rhs) {
-	YAML_DEFINE_CONVERT_STREAMABLE(float)
+//		Value value(ValueType::Map);
-	YAML_DEFINE_CONVERT_STREAMABLE(double)
+//		for(std::map<K, V>::const_iterator it=rhs.begin();it!=rhs.end();++it)
-	YAML_DEFINE_CONVERT_STREAMABLE(long double)
+//			value[it->first] = it->second;
-	
+//		return value;
-#undef YAML_DEFINE_CONVERT_STREAMABLE
+//	}
 }

util/value.cpp

@@ -7,10 +7,10 @@ int main()
 	std::cout << value["key"].as<std::string>() << "\n";
 	value["key"]["key"] = "value";
 	std::cout << value["key"]["key"].as<std::string>() << "\n";
-	value[5] = "monkey";
+//	value[5] = "monkey";
-	std::cout << value[5].as<std::string>() << "\n";
+//	std::cout << value[5].as<std::string>() << "\n";
-	value["monkey"] = 5;
+//	value["monkey"] = 5;
-	std::cout << value["monkey"].as<int>() << "\n";
+//	std::cout << value["monkey"].as<int>() << "\n";
 	
 	return 0;
 }