Bumped version to 0.3.0

Added operator >> overload for Binary
Renamed the base64 methods, and switched the EncodeBase64 one to return a string (to make it easy to use elsewhere)
2026-07-27 14:13:42 -07:00 · 2012-01-21 02:51:56 -06:00 · 2012-01-21 02:01:37 -06:00 · 2012-01-21 01:33:49 -06:00 · 2012-01-21 01:18:37 -06:00 · 2012-01-21 00:08:35 -06:00
77 changed files with 3603 additions and 2483 deletions
@@ -0,0 +1,4 @@
+**.h = native
+**.c = native
+**.cpp = native
+**.txt = native
@@ -0,0 +1 @@
+syntax: glob
@@ -22,8 +22,8 @@ include(CheckCXXCompilerFlag)
 project(YAML_CPP)

 set(YAML_CPP_VERSION_MAJOR "0")
-set(YAML_CPP_VERSION_MINOR "2")
-set(YAML_CPP_VERSION_PATCH "5")
+set(YAML_CPP_VERSION_MINOR "3")
+set(YAML_CPP_VERSION_PATCH "0")
 set(YAML_CPP_VERSION "${YAML_CPP_VERSION_MAJOR}.${YAML_CPP_VERSION_MINOR}.${YAML_CPP_VERSION_PATCH}")

 enable_testing()
@@ -51,14 +51,15 @@ option(APPLE_UNIVERSAL_BIN "Apple: Build universal binary" OFF)
 option(MSVC_SHARED_RT "MSVC: Build with shared runtime libs (/MD)" ON)
 option(MSVC_STHREADED_RT "MSVC: Build with single-threaded static runtime libs (/ML until VS .NET 2003)" OFF)

-
 ###
 ### Sources, headers, directories and libs
 ###
+set(header_directory "include/yaml-cpp/")
+
 file(GLOB sources "src/[a-zA-Z]*.cpp")
 file(GLOB public_headers "include/yaml-cpp/[a-zA-Z]*.h")
 file(GLOB private_headers "src/[a-zA-Z]*.h")
- 
+
 if(YAML_CPP_BUILD_CONTRIB)
 	file(GLOB contrib_sources "src/contrib/[a-zA-Z]*.cpp")
 	file(GLOB contrib_public_headers "include/yaml-cpp/contrib/[a-zA-Z]*.h")
@@ -77,6 +78,7 @@ if(VERBOSE)
 endif()

 include_directories(${YAML_CPP_SOURCE_DIR}/include)
+include_directories(${YAML_CPP_SOURCE_DIR}/src)


 ###
@@ -209,7 +211,9 @@ else()
 	set(_library_dir lib)
 endif()

-set(INCLUDE_INSTALL_DIR include/yaml-cpp)
+set(INCLUDE_INSTALL_ROOT_DIR include)
+
+set(INCLUDE_INSTALL_DIR ${INCLUDE_INSTALL_ROOT_DIR}/yaml-cpp)
 set(LIB_INSTALL_DIR "${_library_dir}${LIB_SUFFIX}")

 set(_INSTALL_DESTINATIONS
@@ -257,10 +261,9 @@ endif()

 install(TARGETS yaml-cpp ${_INSTALL_DESTINATIONS})
 install(
-	FILES
-		${public_headers}
-		${contrib_public_headers}
+	DIRECTORY ${header_directory}
 	DESTINATION ${INCLUDE_INSTALL_DIR}
+	FILES_MATCHING PATTERN "*.h"
 )

 if(UNIX)
@@ -1,7 +1,7 @@
 #ifndef ALIASMANAGER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define ALIASMANAGER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -1,7 +1,7 @@
 #ifndef ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -0,0 +1,66 @@
+#ifndef BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define BASE64_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 <string>
+#include <vector>
+
+namespace YAML
+{
+    class Node;
+    
+    std::string EncodeBase64(const unsigned char *data, std::size_t size);
+    std::vector<unsigned char> DecodeBase64(const std::string& input);
+    
+    class Binary {
+    public:
+        Binary(): m_unownedData(0), m_unownedSize(0) {}
+        Binary(const unsigned char *data, std::size_t size): m_unownedData(data), m_unownedSize(size) {}
+        
+        bool owned() const { return !m_unownedData; }
+        std::size_t size() const { return owned() ? m_data.size() : m_unownedSize; }
+        const unsigned char *data() const { return owned() ? &m_data[0] : m_unownedData; }
+        
+        void swap(std::vector<unsigned char>& rhs) {
+            if(m_unownedData) {
+                m_data.swap(rhs);
+                rhs.clear();
+                rhs.resize(m_unownedSize);
+                std::copy(m_unownedData, m_unownedData + m_unownedSize, &rhs[0]);
+                m_unownedData = 0;
+                m_unownedSize = 0;
+            } else {
+                m_data.swap(rhs);
+            }
+        }
+        
+        bool operator == (const Binary& rhs) const {
+            const std::size_t s = size();
+            if(s != rhs.size())
+                return false;
+            const unsigned char *d1 = data();
+            const unsigned char *d2 = rhs.data();
+            for(std::size_t i=0;i<s;i++) {
+                if(*d1++ != *d2++)
+                    return false;
+            }
+            return true;
+        }
+        
+        bool operator != (const Binary& rhs) const {
+            return !(*this == rhs);
+        }
+        
+    private:
+        std::vector<unsigned char> m_data;
+        const unsigned char *m_unownedData;
+        std::size_t m_unownedSize;
+    };
+    
+    void operator >> (const Node& node, Binary& binary);
+}
+
+#endif // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,7 +1,7 @@
 #ifndef ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -1,7 +1,7 @@
 #ifndef GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -1,18 +1,30 @@
 #ifndef CONVERSION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define CONVERSION_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#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/null.h"
 #include "yaml-cpp/traits.h"
+#include <limits>
 #include <string>
 #include <sstream>

 namespace YAML
 {
+	// traits for conversion
+	
+	template<typename T>
+	struct is_scalar_convertible { enum { value = is_numeric<T>::value }; };
+	
+	template<> struct is_scalar_convertible<std::string> { enum { value = true }; };
+	template<> struct is_scalar_convertible<bool> { enum { value = true }; };
+	template<> struct is_scalar_convertible<_Null> { enum { value = true }; };
+
+	// actual conversion
+	
 	inline bool Convert(const std::string& input, std::string& output) {
 		output = input;
 		return true;
@@ -21,12 +33,42 @@ namespace YAML
 	YAML_CPP_API bool Convert(const std::string& input, bool& output);
 	YAML_CPP_API bool Convert(const std::string& input, _Null& output);
 	
+	inline bool IsInfinity(const std::string& input) {
+		return input == ".inf" || input == ".Inf" || input == ".INF" || input == "+.inf" || input == "+.Inf" || input == "+.INF";
+	}
+	
+	inline bool IsNegativeInfinity(const std::string& input) {
+		return input == "-.inf" || input == "-.Inf" || input == "-.INF";
+	}
+	
+	inline bool IsNaN(const std::string& input) {
+		return input == ".nan" || input == ".NaN" || input == ".NAN";
+	}
+
+
 	template <typename T> 
 	inline bool Convert(const std::string& input, T& output, typename enable_if<is_numeric<T> >::type * = 0) {
 		std::stringstream stream(input);
 		stream.unsetf(std::ios::dec);
-		stream >> output;
-		return !!stream;
+        if((stream >> output) && (stream >> std::ws).eof())
+            return true;
+		
+		if(std::numeric_limits<T>::has_infinity) {
+			if(IsInfinity(input)) {
+				output = std::numeric_limits<T>::infinity();
+				return true;
+			} else if(IsNegativeInfinity(input)) {
+				output = -std::numeric_limits<T>::infinity();
+				return true;
+			}
+		}
+		
+		if(std::numeric_limits<T>::has_quiet_NaN && IsNaN(input)) {
+			output = std::numeric_limits<T>::quiet_NaN();
+			return true;
+		}
+		
+		return false;
 	}
 }

@@ -1,7 +1,7 @@
 #ifndef DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -1,7 +1,7 @@
 #ifndef EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -1,12 +1,13 @@
 #ifndef EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#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/dll.h"
+#include "yaml-cpp/binary.h"
 #include "yaml-cpp/emittermanip.h"
 #include "yaml-cpp/ostream.h"
 #include "yaml-cpp/noncopyable.h"
@@ -43,20 +44,24 @@ namespace YAML
 		bool SetIndent(unsigned n);
 		bool SetPreCommentIndent(unsigned n);
 		bool SetPostCommentIndent(unsigned n);
+        bool SetFloatPrecision(unsigned n);
+        bool SetDoublePrecision(unsigned n);
 		
 		// local setters
 		Emitter& SetLocalValue(EMITTER_MANIP value);
 		Emitter& SetLocalIndent(const _Indent& indent);
+        Emitter& SetLocalPrecision(const _Precision& precision);
 		
 		// overloads of write
 		Emitter& Write(const std::string& str);
 		Emitter& Write(bool b);
+		Emitter& Write(char ch);
 		Emitter& Write(const _Alias& alias);
 		Emitter& Write(const _Anchor& anchor);
 		Emitter& Write(const _Tag& tag);
 		Emitter& Write(const _Comment& comment);
 		Emitter& Write(const _Null& null);
-		Emitter& Write(const _Binary& binary);
+		Emitter& Write(const Binary& binary);
 		
 		template <typename T>
 		Emitter& WriteIntegralType(T value);
@@ -69,10 +74,12 @@ namespace YAML
 		void PreWriteStreamable(std::stringstream& str);
 		void PostWriteIntegralType(const std::stringstream& str);
 		void PostWriteStreamable(const std::stringstream& str);
+        
+        template<typename T> void SetStreamablePrecision(std::stringstream&) {}
+        unsigned GetFloatPrecision() const;
+        unsigned GetDoublePrecision() const;
 	
 	private:
-		enum ATOMIC_TYPE { AT_SCALAR, AT_SEQ, AT_BLOCK_SEQ, AT_FLOW_SEQ, AT_MAP, AT_BLOCK_MAP, AT_FLOW_MAP };
-		
 		void PreAtomicWrite();
 		bool GotoNextPreAtomicState();
 		void PostAtomicWrite();
@@ -119,20 +126,35 @@ namespace YAML
 		
 		std::stringstream str;
 		PreWriteStreamable(str);
+        SetStreamablePrecision<T>(str);
 		str << value;
 		PostWriteStreamable(str);
 		return *this;
 	}
 	
+    template<>
+    inline void Emitter::SetStreamablePrecision<float>(std::stringstream& str)
+    {
+		str.precision(GetFloatPrecision());
+    }
+
+    template<>
+    inline void Emitter::SetStreamablePrecision<double>(std::stringstream& str)
+    {
+		str.precision(GetDoublePrecision());
+    }
+
 	// overloads of insertion
 	inline Emitter& operator << (Emitter& emitter, const std::string& v) { return emitter.Write(v); }
 	inline Emitter& operator << (Emitter& emitter, bool v) { return emitter.Write(v); }
+	inline Emitter& operator << (Emitter& emitter, char v) { return emitter.Write(v); }
+	inline Emitter& operator << (Emitter& emitter, unsigned char v) { return emitter.Write(static_cast<char>(v)); }
 	inline Emitter& operator << (Emitter& emitter, const _Alias& v) { return emitter.Write(v); }
 	inline Emitter& operator << (Emitter& emitter, const _Anchor& v) { return emitter.Write(v); }
 	inline Emitter& operator << (Emitter& emitter, const _Tag& v) { return emitter.Write(v); }
 	inline Emitter& operator << (Emitter& emitter, const _Comment& v) { return emitter.Write(v); }
 	inline Emitter& operator << (Emitter& emitter, const _Null& v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, const _Binary& b) { return emitter.Write(b); }
+	inline Emitter& operator << (Emitter& emitter, const Binary& b) { return emitter.Write(b); }

 	inline Emitter& operator << (Emitter& emitter, const char *v) { return emitter.Write(std::string(v)); }

@@ -155,6 +177,10 @@ namespace YAML
 	inline Emitter& operator << (Emitter& emitter, _Indent indent) {
 		return emitter.SetLocalIndent(indent);
 	}
+    
+    inline Emitter& operator << (Emitter& emitter, _Precision precision) {
+        return emitter.SetLocalPrecision(precision);
+    }
 }

 #endif // EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,7 +1,7 @@
 #ifndef EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -125,16 +125,25 @@ namespace YAML
 	inline _Comment Comment(const std::string content) {
 		return _Comment(content);
 	}
-	
-	struct _Binary {
-		_Binary(const char *data_, std::size_t size_): data(data_), size(size_) {}
-		const char *data;
-		std::size_t size;
-	};
-	
-	inline _Binary Binary(const char *data, std::size_t size) {
-		return _Binary(data, size);
-	}
+    
+    struct _Precision {
+        _Precision(int floatPrecision_, int doublePrecision_): floatPrecision(floatPrecision_), doublePrecision(doublePrecision_) {}
+        
+        int floatPrecision;
+        int doublePrecision;
+    };
+    
+    inline _Precision FloatPrecision(int n) {
+        return _Precision(n, -1);
+    }
+
+    inline _Precision DoublePrecision(int n) {
+        return _Precision(-1, n);
+    }
+
+    inline _Precision Precision(int n) {
+        return _Precision(n, n);
+    }
 }

 #endif // EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,7 +1,7 @@
 #ifndef EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -1,7 +1,7 @@
 #ifndef EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -1,7 +1,7 @@
 #ifndef ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -1,7 +1,7 @@
 #ifndef LTNODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define LTNODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -1,7 +1,7 @@
 #ifndef MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -1,18 +1,18 @@
 #ifndef NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#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/conversion.h"
 #include "yaml-cpp/dll.h"
 #include "yaml-cpp/exceptions.h"
-#include "yaml-cpp/iterator.h"
-#include "yaml-cpp/ltnode.h"
 #include "yaml-cpp/mark.h"
 #include "yaml-cpp/noncopyable.h"
+#include "yaml-cpp/conversion.h"
+#include "yaml-cpp/iterator.h"
+#include "yaml-cpp/ltnode.h"
 #include <iostream>
 #include <map>
 #include <memory>
@@ -66,7 +66,7 @@ namespace YAML
 		const T to() const;

 		template <typename T>
-		friend YAML_CPP_API void operator >> (const Node& node, T& value);
+		friend YAML_CPP_API typename enable_if<is_scalar_convertible<T> >::type operator >> (const Node& node, T& value);

 		// retrieval for maps and sequences
 		template <typename T>
@@ -77,7 +77,9 @@ namespace YAML
 		
 		// specific to maps
 		const Node *FindValue(const char *key) const;
+		const Node *FindValue(char *key) const;
 		const Node& operator [] (const char *key) const;
+		const Node& operator [] (char *key) const;

 		// for tags
 		const std::string& Tag() const { return m_tag; }
@@ -1,7 +1,7 @@
 #ifndef NODEIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define NODEIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -20,7 +20,7 @@ namespace YAML
 	}

 	template <typename T>
-	inline void operator >> (const Node& node, T& value) {
+	inline typename enable_if<is_scalar_convertible<T> >::type operator >> (const Node& node, T& value) {
 		if(!ConvertScalar(node, value))
 			throw InvalidScalar(node.m_mark);
 	}
@@ -68,10 +68,18 @@ namespace YAML
 	inline const Node *Node::FindValue(const char *key) const {
 		return FindValue(std::string(key));
 	}
+
+	inline const Node *Node::FindValue(char *key) const {
+		return FindValue(std::string(key));
+	}
 	
 	inline const Node& Node::operator [] (const char *key) const {
 		return GetValue(std::string(key));
 	}
+
+	inline const Node& Node::operator [] (char *key) const {
+		return GetValue(std::string(key));
+	}
 }

 #endif // NODEIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jesse Beder	572e940c83	Bumped version to 0.3.0	2012-01-21 02:51:56 -06:00
Jesse Beder	01eb370300	Added operator >> overload for Binary	2012-01-21 02:01:37 -06:00
Jesse Beder	d760d037ca	Renamed the base64 methods, and switched the EncodeBase64 one to return a string (to make it easy to use elsewhere)	2012-01-21 01:33:49 -06:00
Jesse Beder	6105d4cfeb	Refactored the base64 binary to its own space with a unified class that (will) be used for parsing (in addition to emitting)	2012-01-21 01:18:37 -06:00
Jesse Beder	e145488547	Added back yaml.h (since it used to be generated)	2012-01-21 00:08:35 -06:00
Jesse Beder	b688c93050	Put all the old-api stuff back in the main folder, for simplicity	2012-01-20 23:55:39 -06:00
Jesse Beder	1723523c43	Removed the new API from the default branch	2012-01-20 23:50:39 -06:00
Jesse Beder	d772361f15	Fixed hex and oct emitting (it now adds the 0x or 0 prefix)	2012-01-13 00:00:11 -06:00
Jesse Beder	a441e1a14c	Added test for new API octal/hex conversion	2012-01-12 23:55:15 -06:00
Jesse Beder	fb0802097c	Fixed double -> int conversion (now throws) for old API	2012-01-12 23:52:51 -06:00
Jesse Beder	643ea61a98	Updated new API conversion to handle nan/inf and to throw when the conversion didn't use the entire string (e.g., parsing 1.2 as an integer)	2012-01-12 23:49:05 -06:00
Jesse Beder	d1e4c2640c	Added default parameters for the as<> function (new API)	2012-01-12 01:03:31 -06:00
Jesse Beder	ddc578dbd7	Added LoadFile and LoadAllFromFile (new API)	2012-01-11 21:31:01 -06:00
Jesse Beder	8906ae9a0d	Fixed bug in parsing escaped newline (it was being clipped like a regular newline)	2012-01-11 17:55:27 -06:00
Jesse Beder	4e350e5808	Removed some extra stuff in the comment/newline in flow map tests, which really should be illegal (since implicit keys can't span multiple lines). It would be impossible to fix if we keep the immediate-output we're doing now - the only way to prevent it would be to hold on to a key's text until we got to the value token to make sure it could be an implicit key	2012-01-11 17:06:27 -06:00
Jesse Beder	7ace0e93d2	Fixed signed/unsigned mismatch with the new precision code	2012-01-11 16:50:06 -06:00
Jesse Beder	0e61ddb6d9	Added parsing emitter tests with the new API, two fail	2012-01-11 16:41:13 -06:00
Jesse Beder	97fa02a484	Disallowed a plain scalar with just a dash	2012-01-11 16:39:24 -06:00
Jesse Beder	5024caa69c	Added float/double precision setters	2012-01-11 14:34:04 -06:00
Jesse Beder	21ed2b5817	Added explicit conversion from an iterator value to a Node. This conversion was always allowed (since the iterator value is derived from Node, but since Node has a templated constructor, that would take precedence over the derived-to-base conversion. This didn't seem to be a problem in gcc or clang, but MSVC seems to have trouble. (new API)	2012-01-11 13:58:18 -06:00
Jesse Beder	92a35581d7	Added boost find/includes to the new API CMake instructions	2012-01-11 13:19:31 -06:00
Jesse Beder	5b32d89222	Fixed compiler error in iterator_base friend forward declaration in node on clang (and I hope MSVC), plus warnings on clang	2012-01-07 01:42:21 -06:00
Jesse Beder	812a2dc684	Fixed assignment with an empty node (new API) - a segfault that only showed up in debuggable	2011-12-20 22:19:54 -06:00
Jesse Beder	add460947b	Added overload for emitting unsigned char	2011-11-14 17:00:28 -06:00
Jesse Beder	3099d51ba4	Added single character emitting	2011-11-14 16:23:14 -06:00
Jesse Beder	6f4608ce05	Added missing includes (iostream) for the tests	2011-11-13 16:12:39 -06:00
Jesse Beder	5abfbf5aac	Added (unspecified-type) bool conversions for Node (new API)	2011-11-13 16:05:42 -06:00
Jesse Beder	d78d16532a	Set the default operator >> to not compile unless there is a scalar conversion, so it doesn't interfere with user-defined types	2011-11-01 17:19:03 -05:00
Jesse Beder	62634f53ec	Fixed emitter bug with colon at the end of a scalar in a flow collection	2011-10-31 19:16:17 -05:00
Jesse Beder	860365b263	Switched the utf bom checking to putback in the stream (instead of keeping a secondary buffer), which fixes a bug when there's only one ascii character	2011-10-20 22:29:41 -05:00
Jesse Beder	e8e5d4bc40	Fixed typo in computing private headers (no effect on the build, just for the project files)	2011-10-20 21:50:47 -05:00
Jesse Beder	b077e8390e	Added parser test for single char input (that fails)	2011-10-20 13:53:27 -05:00
Jesse Beder	c953ce0b07	Fixed broken includes when using the old api	2011-10-18 15:13:10 -05:00
Jesse Beder	f87dced5c9	Fixed installation (we now install the whole include header tree)	2011-10-18 14:55:31 -05:00
Jesse Beder	62361e6f27	Added a .hgignore file that ignores the generated yaml.h	2011-10-18 14:48:07 -05:00
Jesse Beder	70e1eb3f9c	Fixed the #ifdefs for the api stuff	2011-10-18 14:47:35 -05:00
Jesse Beder	77cc54585f	Couldn't get the copy command to work for yaml.h, so switched to configure_file	2011-10-18 14:43:48 -05:00
Jesse Beder	e69f51ee16	Split the yaml.h file into new/old API, which we'll then copy to yaml.h at build time (so the right one gets installed)	2011-10-18 00:16:51 -05:00
Jesse Beder	ee795d7e3e	Merged with the main branch, which just updated version count to 0.2.7	2011-09-18 00:26:18 -05:00
Jesse Beder	f6d6c90aa9	Updated old api spectests with common spec examples	2011-09-17 23:57:40 -05:00
Jesse Beder	d9c7bcf32f	Set the default build to the old API, and removed the duplicate spec test implementation for the old api	2011-09-17 23:46:48 -05:00
Jesse Beder	f3b230693a	Moved conversion.cpp to the old api, where it belongs	2011-09-14 01:49:06 -05:00
Jesse Beder	f64f619c29	Added bool conversions	2011-09-14 01:48:36 -05:00
Jesse Beder	8e5fc0e304	Added tag release-0.2.7 for changeset d0bed6918076	2011-09-14 01:23:25 -05:00
Jesse Beder	976e8b184c	Bumped version to 0.2.7	2011-09-14 01:23:15 -05:00
Jesse Beder	e5d0366797	Added Dump()	2011-09-13 14:49:00 -05:00
Jesse Beder	c3798d9bd4	Added tags to Node emitter output	2011-09-13 14:47:33 -05:00
Jesse Beder	40c47f6312	Finished adding old spec tests	2011-09-13 14:31:00 -05:00
Jesse Beder	e3d5ec189d	Switched YAML::Parse to YAML::Load, and added LoadAll	2011-09-13 14:24:47 -05:00
Jesse Beder	5be19ccbfd	Added 7.x and 8.x tests with tags - all that's left is multiple docs in stream	2011-09-13 14:20:32 -05:00
Jesse Beder	98830a4a15	Added 6.x tests with tags	2011-09-13 14:18:00 -05:00
Jesse Beder	3a88c4b4a1	Added IsNull, IsScalar, IsSequence, IsMap functions, so you don't have to query Type()	2011-09-13 14:10:27 -05:00
Jesse Beder	69af9b420a	Copied 2.x tests with tags	2011-09-13 14:07:22 -05:00
Jesse Beder	0987b234c3	Added tags to Node	2011-09-13 14:00:47 -05:00
Jesse Beder	2dfccbb945	Added a convert<> specialization for YAML::_Null (so you can say node[YAML::Null])	2011-09-13 02:03:56 -05:00
Jesse Beder	a9be4849d8	Copied over the 8.x tests that don't have tags	2011-09-13 01:56:44 -05:00
Jesse Beder	b1100d7c54	Copied over the 7.x tests that don't have tags	2011-09-13 01:46:42 -05:00
Jesse Beder	64e381f2c1	Copied over the 6.x tests that don't have tags	2011-09-13 01:36:27 -05:00
Jesse Beder	f6b728d56c	Copied over the 5.x tests	2011-09-13 01:28:32 -05:00
Jesse Beder	edd6650536	Copied over all the 2.x tests that are (a) single doc and (b) don't have tags	2011-09-13 01:23:30 -05:00
Jesse Beder	a04dfdeb07	Factored out spec examples, and sketched skeleton for spec tests for new API	2011-09-12 22:55:37 -05:00
Jesse Beder	1721750d9e	Added temp variable tests	2011-09-12 22:09:16 -05:00
Jesse Beder	a8f82af604	Switched Node::operator=(const Node&) to not force itself to create its node first (since we're just assigning them)	2011-09-12 22:05:43 -05:00
Jesse Beder	0c321a6dc6	Switched the node_ref to always create its data (since now the Node itself doesn't always create itself)	2011-09-12 22:03:11 -05:00
Jesse Beder	08b3ddfd3e	Set the pimpl node in Node to be optional, so we don't create unnecessary guys every time you call Node tmp = foo[value];	2011-09-12 21:59:47 -05:00
Jesse Beder	fddc991b60	Fixed NodeBuilder bug when an alias was in a map - we weren't pushing that guy as a key	2011-09-12 14:24:27 -05:00
Jesse Beder	3337df7ca2	Fixed new API node key/value insertion in NodeBuilder (it was using the wrong condition on when it had added a key already)	2011-09-12 13:25:41 -05:00
Jesse Beder	41533a8c49	Added failing self-reference tests	2011-09-12 12:48:51 -05:00
Jesse Beder	a6e1d4cf74	Added two alias tests	2011-09-12 12:42:23 -05:00
Jesse Beder	5397a93702	Implemented std::map decode (and fixed bug in the Node iterator - the reference_type should be just a plain value, since it's created on-the-fly)	2011-09-12 00:29:39 -05:00
Jesse Beder	b9583dde76	Added reading/writing std::list	2011-09-11 23:18:19 -05:00
Jesse Beder	f22f38f7f2	Added reading/writing std::vector	2011-09-11 23:14:52 -05:00
Jesse Beder	9e62bf8349	Removed the (unimplemented) operator <, and added operator == (in place of is()) for nodes	2011-09-11 22:56:04 -05:00
Jesse Beder	f9d826c22a	Added mutable operator[] for integral types (you can only grow the sequence if you specify the next element)	2011-09-11 22:51:49 -05:00
Jesse Beder	4770ec798c	Implemented operator[] specialization, but only const (should the sequence be mutable?)	2011-09-11 21:51:04 -05:00
Jesse Beder	4568dd0b19	Started specialization for operator[] for integers	2011-09-11 21:32:47 -05:00
Jesse Beder	a308b73e8a	Set the map iterator to filter over undefined items	2011-09-11 19:44:27 -05:00
Jesse Beder	c2a8a2c1f7	Added failing map iterator count test	2011-09-11 17:36:08 -05:00
Jesse Beder	a03af5dd73	Implemented the map size computation	2011-09-11 17:16:26 -05:00
Jesse Beder	b50264e74d	Switched the implementation of maps from list<pair> to map (but just pointer comparison)	2011-09-11 16:56:38 -05:00
Jesse Beder	ecdd9cc66d	Added computing and caching the sequence size	2011-09-11 16:21:36 -05:00
Jesse Beder	3a90454d50	Added some small map tests	2011-09-11 16:02:31 -05:00
Jesse Beder	2d81e46655	Added dependency management (to cause nodes to become defined if their children do)	2011-09-11 15:59:53 -05:00
Jesse Beder	b4963ab0fa	Added a few simple node tests, and the sequence one doesn't pass (let's work now)	2011-09-10 23:31:12 -05:00
Jesse Beder	432268917b	Started Node tests (for the new API Node)	2011-09-10 23:22:30 -05:00
Jesse Beder	2d06df474b	Fixed up the old API stuff, and removed the util/value (since it's no longer needed)	2011-09-10 23:11:28 -05:00
Jesse Beder	03fc837236	Set up util/parse for the new API	2011-09-10 23:03:02 -05:00
Jesse Beder	80cf3c98db	Fixed minor things that used the old API, compiles/links/runs\!	2011-09-10 22:59:27 -05:00
Jesse Beder	f7b2247217	Added stubs for spec and parser tests with the new API	2011-09-10 18:05:35 -05:00
Jesse Beder	36c63980b9	Moved old api tests to subfolder	2011-09-10 18:02:07 -05:00
Jesse Beder	0d1b5224c8	Major switch from Value -> Node. The library compiles with the new API, but tests are still oldies, and don't compile	2011-09-10 17:57:23 -05:00
Jesse Beder	ac81d7c883	Start of moving Value -> Node and Node -> old API Node (with a #define toggle)	2011-09-10 17:18:15 -05:00
Jesse Beder	78b7a1b8a9	Added helper emitter functions, but we have a problem: YAML::Value is already a manipulator	2011-09-10 16:50:44 -05:00
Jesse Beder	12364895cb	Implemented value events emitter	2011-09-10 16:23:18 -05:00
Jesse Beder	5012063143	Fixed node iterator	2011-09-10 14:36:10 -05:00
Jesse Beder	c3b0ba9d61	New iterators work\!	2011-09-10 14:16:50 -05:00
Jesse Beder	4fdbb748ec	Updated the node/value classes with the new iterators, they compile until we try to instantiate anything	2011-09-10 14:11:42 -05:00
Jesse Beder	b1730ea3da	Finished the main iterator stuff, now have to hook it to the nodes/values	2011-09-10 14:06:49 -05:00
Jesse Beder	3865d37bc7	Halfway towards factoring out a node_iterator, and then building iterator on top of it	2011-09-10 13:20:22 -05:00
Jesse Beder	f5a9d4c8e3	Started emitting events for Values	2011-09-10 12:42:42 -05:00
Jesse Beder	09beb5c47a	Implemented sugar Parse() functions	2011-09-09 23:40:19 -05:00
Jesse Beder	6e03bebeb0	Implemented (untested) the value builder	2011-09-09 23:28:21 -05:00
Jesse Beder	a7bdf08c7e	Map iterator works\!	2011-09-09 19:25:11 -05:00
Jesse Beder	cf198080d0	Sequence iterator works\!	2011-09-09 19:22:17 -05:00
Jesse Beder	190a556756	Switched iterators to typedef's, with a bit of finagling so we can forward-declare them	2011-09-09 19:07:37 -05:00
Jesse Beder	9aa3eb56f2	Base iterator stuff compiles :)	2011-09-09 18:46:37 -05:00
Jesse Beder	ff1a8fc59a	Started writing new iterators	2011-09-09 16:17:59 -05:00
Jesse Beder	7bbf712c36	Made the 'data' member optional in node_ref - it's only created on-demand, so we don't waste extra memory every time we do Value tmp = v;	2011-09-09 14:26:55 -05:00
Jesse Beder	9b985c5ce2	Switched value = otherValue to assign the actual nodes after setting the reference (so that tmp = foo['bar']; tmp = other; is the same as foo['bar'] = other;)	2011-09-09 14:02:18 -05:00
Jesse Beder	d3bbd08273	Added append()	2011-09-09 02:51:35 -05:00
Jesse Beder	4f8680b540	Switched operator[] access to node reference equality, not node equality	2011-09-09 02:39:36 -05:00
Jesse Beder	ec95e61c04	Switched memory to using shared nodes, and node_data to keep only naked node pointers, not shared nodes (to break the cycle, and we don't need weak pointers because their memory is guaranteed to exist, via 'memory')	2011-09-09 02:29:17 -05:00
Jesse Beder	6ffc9ac788	Added half of the std::map conversion (we don't have reading from Values yet)	2011-09-08 02:10:04 -05:00
Jesse Beder	0e197b8723	Added back the streamable conversions	2011-09-08 02:05:03 -05:00
Jesse Beder	3d84f57008	Switched convert to a templated struct that can be specialized (so we can partially specialize it)	2011-09-08 02:02:15 -05:00
Jesse Beder	a7ebb3615a	Added streamable conversions	2011-09-08 00:48:40 -05:00
Jesse Beder	a95baeafd6	Implemented conversion for std::string, including a bypass-accessor to the scalar value	2011-09-07 15:49:01 -05:00
Jesse Beder	1ab16bac62	Set the 'memory' to only store node_refs, not nodes	2011-09-07 14:56:04 -05:00
Jesse Beder	4aa61944fe	Implemented is()	2011-09-07 14:46:25 -05:00
Jesse Beder	e225509210	Added (another) layer - now 'node_ref' is between node and node_data, and it decrees whether nodes are identical	2011-09-07 14:44:18 -05:00
Jesse Beder	d1eca90216	Implemented map get(), and it would work (I think) if we implemented convert() for strings	2011-09-07 03:36:50 -05:00
Jesse Beder	020cd97915	Set up map searching by templated key	2011-09-07 03:21:24 -05:00
Jesse Beder	f0174ca08b	Reorganized so that we don't have cyclic include problems	2011-09-07 02:59:58 -05:00
Jesse Beder	fed95c5da4	Implemented map access by already-existing node	2011-09-07 02:39:59 -05:00
Jesse Beder	a530630f1c	Started implementing node_data	2011-09-07 00:45:28 -05:00
Jesse Beder	00e4a56d15	Compiles/links assignment to string	2011-09-07 00:20:23 -05:00
Jesse Beder	1e6877043e	Value stuff compiles/links with lots of placeholder functions	2011-09-07 00:12:24 -05:00
Jesse Beder	248b18a2d0	Sketched more of the implementation	2011-09-06 23:11:38 -05:00
Jesse Beder	7e79edc058	Moved the value header to its own subfolder	2011-09-06 16:06:46 -05:00
Jesse Beder	8b97dfe77e	Sketched out interface for YAML::Value	2011-09-06 01:43:15 -05:00
Jesse Beder	3eeb270ef5	Merged from trunk	2011-09-06 01:10:27 -05:00
Jesse Beder	c1d75dd4f7	Added notes about the two failing tests - that they're (I think) bugs in the YAML spec	2011-09-06 01:05:14 -05:00
Jesse Beder	dd1eb715c4	Switched YAML::Binary interface to use unsigned chars, not chars	2011-09-06 00:39:31 -05:00
Jesse Beder	fadca5a89d	Added overload for operator [] for char * (non-const version)	2011-09-06 00:32:53 -05:00
Jesse Beder	7e129c9b64	Fixed empty string emitter bug (it now with auto-quote it	2011-09-06 00:24:10 -05:00
Jesse Beder	3e94c0a037	Switched the 'pragma once' to only happen on MSVC, or gcc >= 3.4 (it was causing trouble on the sun compiler)	2011-09-06 00:16:03 -05:00
Jesse Beder	d7feb2e9b9	Added api sketch	2011-09-04 19:50:08 -05:00
Jesse Beder	8ba5e3fbf6	Added .hgeol for native eols	2011-08-24 02:59:58 -05:00
Jesse Beder	857c7d93a0	update tags	2011-08-24 13:44:56 +00:00
Jesse Beder	b690648308	Removed ATOMIC_TYPE, an old enum that wasn't used any more	2011-08-22 21:37:51 +00:00
Jesse Beder	d904b600a9	Added test for anchor/alias in flow	2011-08-04 21:50:04 +00:00
Jesse Beder	bacb74e8ec	Forced a newline after any comments	2011-08-04 21:47:57 +00:00
Jesse Beder	b1ac3289b8	Included <cstddef> for NULL	2011-08-04 18:47:37 +00:00
Jesse Beder	835b86d9f7	Fixed negative infinity parsing	2011-07-10 18:29:44 +00:00
Jesse Beder	94dc63af04	Added parsing .inf and .nan (and friend)	2011-07-10 16:27:40 +00:00
Jesse Beder	50474b6b9f	Fixed includedir for the .pc.cmake file	2011-05-29 02:17:49 +00:00
Jesse Beder	4c3926a5c7	Added emitting std::set (and refactored the stl emitters a bit)	2011-05-18 21:07:25 +00:00
Jesse Beder	9fbcfe9ec5	Added include <cstdlib> for using 'NULL' (apparently gcc 4.6 is more strict)	2011-05-03 21:55:49 +00:00
Jesse Beder	d98687afc3	Set version to 0.2.6	2011-03-30 01:33:02 +00:00