Bump version to 0.5.2

Run clang-format
Fixed linker error on Visual Studio with a shared lib by moving the static methods node_data::equals to an instance method on node.
2026-07-27 14:13:42 -07:00 · 2015-03-29 21:31:56 -05:00 · 2015-03-29 21:27:20 -05:00 · 2015-03-29 21:11:53 -05:00 · 2015-03-29 14:31:22 -05:00 · 2015-02-21 12:34:19 -06:00
406 changed files with 297117 additions and 26168 deletions
@@ -0,0 +1,47 @@
+---
+# BasedOnStyle:  Google
+AccessModifierOffset: -1
+ConstructorInitializerIndentWidth: 4
+AlignEscapedNewlinesLeft: true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakTemplateDeclarations: true
+AlwaysBreakBeforeMultilineStrings: true
+BreakBeforeBinaryOperators: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BinPackParameters: true
+ColumnLimit:     80
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+DerivePointerBinding: true
+ExperimentalAutoDetectBinPacking: false
+IndentCaseLabels: true
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCSpaceBeforeProtocolList: false
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 60
+PenaltyBreakString: 1000
+PenaltyBreakFirstLessLess: 120
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerBindsToType: true
+SpacesBeforeTrailingComments: 2
+Cpp11BracedListStyle: true
+Standard:        Auto
+IndentWidth:     2
+TabWidth:        8
+UseTab:          Never
+BreakBeforeBraces: Attach
+IndentFunctionDeclarationAfterType: true
+SpacesInParentheses: false
+SpacesInAngles:  false
+SpaceInEmptyParentheses: false
+SpacesInCStyleCastParentheses: false
+SpaceAfterControlStatementKeyword: true
+SpaceBeforeAssignmentOperators: true
+ContinuationIndentWidth: 4
+...
+
@@ -23,7 +23,7 @@ project(YAML_CPP)

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

 enable_testing()
@@ -54,6 +54,29 @@ option(MSVC_STHREADED_RT "MSVC: Build with single-threaded static runtime libs (
 ###
 ### Sources, headers, directories and libs
 ###
+
+# From http://www.cmake.org/pipermail/cmake/2010-March/035992.html:
+# function to collect all the sources from sub-directories
+# into a single list
+function(add_sources)
+  get_property(is_defined GLOBAL PROPERTY SRCS_LIST DEFINED)
+  if(NOT is_defined)
+    define_property(GLOBAL PROPERTY SRCS_LIST
+      BRIEF_DOCS "List of source files"
+      FULL_DOCS "List of all source files in the entire project")
+  endif()
+  # make absolute paths
+  set(SRCS)
+  foreach(s IN LISTS ARGN)
+    if(NOT IS_ABSOLUTE "${s}")
+      get_filename_component(s "${s}" ABSOLUTE)
+    endif()
+    list(APPEND SRCS "${s}")
+  endforeach()
+  # append to global list
+  set_property(GLOBAL APPEND PROPERTY SRCS_LIST "${SRCS}")
+endfunction(add_sources)
+
 set(header_directory "include/yaml-cpp/")

 file(GLOB sources "src/[a-zA-Z]*.cpp")
@@ -68,6 +91,16 @@ else()
 	add_definitions(-DYAML_CPP_NO_CONTRIB)
 endif()

+set(library_sources
+  ${sources}
+  ${public_headers}
+  ${private_headers}
+  ${contrib_sources}
+  ${contrib_public_headers}
+  ${contrib_private_headers}
+)
+add_sources(${library_sources})
+
 if(VERBOSE)
 	message(STATUS "sources: ${sources}")
 	message(STATUS "public_headers: ${public_headers}")
@@ -87,6 +120,9 @@ include_directories(${Boost_INCLUDE_DIRS})
 ###
 ### General compilation settings
 ###
+set(yaml_c_flags ${CMAKE_C_FLAGS})
+set(yaml_cxx_flags ${CMAKE_CXX_FLAGS})
+
 if(BUILD_SHARED_LIBS)
 	set(LABEL_SUFFIX "shared")
 else()
@@ -113,8 +149,9 @@ if(WIN32)
 	endif()
 endif()

-# GCC specialities
-if(CMAKE_COMPILER_IS_GNUCXX)
+# GCC or Clang specialities
+if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU" OR
+   "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
 	### General stuff
 	if(WIN32)
 		set(CMAKE_SHARED_LIBRARY_PREFIX "")	# DLLs do not have a "lib" prefix
@@ -140,16 +177,19 @@ if(CMAKE_COMPILER_IS_GNUCXX)
 		set(GCC_EXTRA_OPTIONS "${GCC_EXTRA_OPTIONS} ${FLAG_TESTED}")
 	endif()
 	#
-	set(CMAKE_CXX_FLAGS "-Wall ${GCC_EXTRA_OPTIONS} -pedantic -Wno-long-long ${CMAKE_CXX_FLAGS}")
-	#
-	add_custom_target(debuggable $(MAKE) clean
-		COMMAND ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE=Debug ${CMAKE_SOURCE_DIR}
-		COMMENT "Adjusting settings for debug compilation"
-		VERBATIM)
-	add_custom_target(releasable $(MAKE) clean
-		COMMAND ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE=Release ${CMAKE_SOURCE_DIR}
-		COMMENT "Adjusting settings for release compilation"
-		VERBATIM)
+	set(yaml_cxx_flags "-Wall ${GCC_EXTRA_OPTIONS} -pedantic -Wno-long-long ${yaml_cxx_flags}")
+
+	### Make specific
+	if(${CMAKE_BUILD_TOOL} MATCHES make OR ${CMAKE_BUILD_TOOL} MATCHES gmake)
+		add_custom_target(debuggable $(MAKE) clean
+			COMMAND ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE=Debug ${CMAKE_SOURCE_DIR}
+			COMMENT "Adjusting settings for debug compilation"
+			VERBATIM)
+		add_custom_target(releasable $(MAKE) clean
+			COMMAND ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE=Release ${CMAKE_SOURCE_DIR}
+			COMMENT "Adjusting settings for release compilation"
+			VERBATIM)
+	endif()
 endif()

 # Microsoft VisualC++ specialities
@@ -175,7 +215,7 @@ if(MSVC)
 		endif()

 		# correct linker options
-		foreach(flag_var  CMAKE_C_FLAGS  CMAKE_CXX_FLAGS)
+		foreach(flag_var  yaml_c_flags  yaml_cxx_flags)
 			foreach(config_name  ""  DEBUG  RELEASE  MINSIZEREL  RELWITHDEBINFO)
 				set(var_name "${flag_var}")
 				if(NOT "${config_name}" STREQUAL "")
@@ -201,7 +241,7 @@ if(MSVC)
 	# /W3 = set warning level; see http://msdn.microsoft.com/en-us/library/thxezb7y.aspx
 	# /wd4127 = disable warning C4127 "conditional expression is constant"; see http://msdn.microsoft.com/en-us/library/6t66728h.aspx
 	# /wd4355 = disable warning C4355 "'this' : used in base member initializer list"; http://msdn.microsoft.com/en-us/library/3c594ae3.aspx
-	set(CMAKE_CXX_FLAGS "/W3 /wd4127 /wd4355 /D_SCL_SECURE_NO_WARNINGS ${CMAKE_CXX_FLAGS}")
+	set(yaml_cxx_flags "/W3 /wd4127 /wd4355 ${yaml_cxx_flags}")
 endif()


@@ -229,13 +269,9 @@ set(_INSTALL_DESTINATIONS
 ###
 ### Library
 ###
-add_library(yaml-cpp
-	${sources}
-	${public_headers}
-	${private_headers}
-	${contrib_sources}
-	${contrib_public_headers}
-	${contrib_private_headers}
+add_library(yaml-cpp ${library_sources})
+set_target_properties(yaml-cpp PROPERTIES
+  COMPILE_FLAGS "${yaml_c_flags} ${yaml_cxx_flags}"
 )

 set_target_properties(yaml-cpp PROPERTIES
@@ -269,6 +305,18 @@ install(
 	FILES_MATCHING PATTERN "*.h"
 )

+export(
+    TARGETS yaml-cpp
+    FILE "${PROJECT_BINARY_DIR}/yaml-cpp-targets.cmake")
+export(PACKAGE yaml-cpp)
+set(EXPORT_TARGETS yaml-cpp CACHE INTERNAL "export targets")
+
+set(CONFIG_INCLUDE_DIRS "${YAML_CPP_SOURCE_DIR}/include")
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/yaml-cpp-config.cmake.in
+	"${PROJECT_BINARY_DIR}/yaml-cpp-config.cmake" @ONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/yaml-cpp-config-version.cmake.in
+	"${PROJECT_BINARY_DIR}/yaml-cpp-config-version.cmake" @ONLY)
+
 if(UNIX)
 	set(PC_FILE ${CMAKE_BINARY_DIR}/yaml-cpp.pc)
 	configure_file("yaml-cpp.pc.cmake" ${PC_FILE} @ONLY)
@@ -283,3 +331,10 @@ if(YAML_CPP_BUILD_TOOLS)
 	add_subdirectory(test)
 	add_subdirectory(util)
 endif()
+
+### Formatting
+get_property(all_sources GLOBAL PROPERTY SRCS_LIST)
+add_custom_target(format
+	COMMAND clang-format --style=file -i ${all_sources}
+	COMMENT "Running clang-format"
+	VERBATIM)
@@ -1,16 +1,17 @@
 #ifndef ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define ANCHOR_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
+#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 <cstddef>

-namespace YAML
-{
-	typedef std::size_t anchor_t;
-	const anchor_t NullAnchor = 0;
+namespace YAML {
+typedef std::size_t anchor_t;
+const anchor_t NullAnchor = 0;
 }

-#endif // ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#endif  // ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,62 +1,67 @@
 #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
+#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
-{
-    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;
-    };
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+YAML_CPP_API std::string EncodeBase64(const unsigned char *data,
+                                      std::size_t size);
+YAML_CPP_API std::vector<unsigned char> DecodeBase64(const std::string &input);
+
+class YAML_CPP_API 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.begin());
+      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;
+};
 }

-#endif // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#endif  // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,7 +1,9 @@
 #ifndef ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define ANCHORDICT_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
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -9,34 +11,27 @@

 #include "../anchor.h"

-namespace YAML
-{
-  /// AnchorDict
-  /// . An object that stores and retrieves values correlating to anchor_t
-  ///   values.
-  /// . Efficient implementation that can make assumptions about how anchor_t
-  ///   values are assigned by the Parser class.
-  template <class T>
-  class AnchorDict
-  {
-  public:
-    void Register(anchor_t anchor, T value)
-    {
-      if (anchor > m_data.size())
-      {
-        m_data.resize(anchor);
-      }
-      m_data[anchor - 1] = value;
+namespace YAML {
+/// AnchorDict
+/// . An object that stores and retrieves values correlating to anchor_t
+///   values.
+/// . Efficient implementation that can make assumptions about how anchor_t
+///   values are assigned by the Parser class.
+template <class T>
+class AnchorDict {
+ public:
+  void Register(anchor_t anchor, T value) {
+    if (anchor > m_data.size()) {
+      m_data.resize(anchor);
    }
-    
-    T Get(anchor_t anchor) const
-    {
-      return m_data[anchor - 1];
-    }
-  
-  private:
-    std::vector<T> m_data;
-  };
+    m_data[anchor - 1] = value;
+  }
+
+  T Get(anchor_t anchor) const { return m_data[anchor - 1]; }
+
+ private:
+  std::vector<T> m_data;
+};
 }

-#endif // ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#endif  // ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,133 +1,147 @@
 #ifndef GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define GRAPHBUILDER_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
+#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/mark.h"
 #include <string>

-namespace YAML
-{
-  class Parser;
-  
-  // GraphBuilderInterface
-  // . Abstraction of node creation
-  // . pParentNode is always NULL or the return value of one of the NewXXX()
-  //   functions.
-  class GraphBuilderInterface
-  {
-  public:
-    // Create and return a new node with a null value.
-    virtual void *NewNull(const Mark& mark, void *pParentNode) = 0;
-    
-    // Create and return a new node with the given tag and value.
-    virtual void *NewScalar(const Mark& mark, const std::string& tag, void *pParentNode, const std::string& value) = 0;
-    
-    // Create and return a new sequence node
-    virtual void *NewSequence(const Mark& mark, const std::string& tag, void *pParentNode) = 0;
-    // Add pNode to pSequence.  pNode was created with one of the NewXxx()
-    // functions and pSequence with NewSequence().
-    virtual void AppendToSequence(void *pSequence, void *pNode) = 0;
-    // Note that no moew entries will be added to pSequence
-    virtual void SequenceComplete(void *pSequence) {(void)pSequence;}
-    
-    // Create and return a new map node
-    virtual void *NewMap(const Mark& mark, const std::string& tag, void *pParentNode) = 0;
-    // Add the pKeyNode => pValueNode mapping to pMap.  pKeyNode and pValueNode
-    // were created with one of the NewXxx() methods and pMap with NewMap().
-    virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) = 0;
-    // Note that no more assignments will be made in pMap
-    virtual void MapComplete(void *pMap) {(void)pMap;}
-    
-    // Return the node that should be used in place of an alias referencing
-    // pNode (pNode by default)
-    virtual void *AnchorReference(const Mark& mark, void *pNode) {(void)mark; return pNode;}
-  };
-  
-  // Typesafe wrapper for GraphBuilderInterface.  Assumes that Impl defines
-  // Node, Sequence, and Map types.  Sequence and Map must derive from Node
-  // (unless Node is defined as void).  Impl must also implement function with
-  // all of the same names as the virtual functions in GraphBuilderInterface
-  // -- including the ones with default implementations -- but with the
-  // prototypes changed to accept an explicit Node*, Sequence*, or Map* where
-  // appropriate.
-  template <class Impl>
-  class GraphBuilder : public GraphBuilderInterface
-  {
-  public:
-    typedef typename Impl::Node Node;
-    typedef typename Impl::Sequence Sequence;
-    typedef typename Impl::Map Map;
-    
-    GraphBuilder(Impl& impl) : m_impl(impl)
-    {
-      Map* pMap = NULL;
-      Sequence* pSeq = NULL;
-      Node* pNode = NULL;
-      
-      // Type consistency checks
-      pNode = pMap;
-      pNode = pSeq;
-    }
-    
-    GraphBuilderInterface& AsBuilderInterface() {return *this;}
-    
-    virtual void *NewNull(const Mark& mark, void* pParentNode) {
-      return CheckType<Node>(m_impl.NewNull(mark, AsNode(pParentNode)));
-    }
-    
-    virtual void *NewScalar(const Mark& mark, const std::string& tag, void *pParentNode, const std::string& value) {
-      return CheckType<Node>(m_impl.NewScalar(mark, tag, AsNode(pParentNode), value));
-    }
-    
-    virtual void *NewSequence(const Mark& mark, const std::string& tag, void *pParentNode) {
-      return CheckType<Sequence>(m_impl.NewSequence(mark, tag, AsNode(pParentNode)));
-    }
-    virtual void AppendToSequence(void *pSequence, void *pNode) {
-      m_impl.AppendToSequence(AsSequence(pSequence), AsNode(pNode));
-    }
-    virtual void SequenceComplete(void *pSequence) {
-      m_impl.SequenceComplete(AsSequence(pSequence));
-    }
-    
-    virtual void *NewMap(const Mark& mark, const std::string& tag, void *pParentNode) {
-      return CheckType<Map>(m_impl.NewMap(mark, tag, AsNode(pParentNode)));
-    }
-    virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) {
-      m_impl.AssignInMap(AsMap(pMap), AsNode(pKeyNode), AsNode(pValueNode));
-    }
-    virtual void MapComplete(void *pMap) {
-      m_impl.MapComplete(AsMap(pMap));
-    }
-    
-    virtual void *AnchorReference(const Mark& mark, void *pNode) {
-      return CheckType<Node>(m_impl.AnchorReference(mark, AsNode(pNode)));
-    }
-  
-  private:
-    Impl& m_impl;
-    
-    // Static check for pointer to T
-    template <class T, class U>
-    static T* CheckType(U* p) {return p;}
-    
-    static Node *AsNode(void *pNode) {return static_cast<Node*>(pNode);}
-    static Sequence *AsSequence(void *pSeq) {return static_cast<Sequence*>(pSeq);}
-    static Map *AsMap(void *pMap) {return static_cast<Map*>(pMap);}
-  };
-  
-  void *BuildGraphOfNextDocument(Parser& parser, GraphBuilderInterface& graphBuilder);
-  
-  template <class Impl>
-  typename Impl::Node *BuildGraphOfNextDocument(Parser& parser, Impl& impl)
-  {
-    GraphBuilder<Impl> graphBuilder(impl);
-    return static_cast<typename Impl::Node *>(BuildGraphOfNextDocument(
-      parser, graphBuilder
-    ));
+namespace YAML {
+class Parser;
+
+// GraphBuilderInterface
+// . Abstraction of node creation
+// . pParentNode is always NULL or the return value of one of the NewXXX()
+//   functions.
+class GraphBuilderInterface {
+ public:
+  // Create and return a new node with a null value.
+  virtual void *NewNull(const Mark &mark, void *pParentNode) = 0;
+
+  // Create and return a new node with the given tag and value.
+  virtual void *NewScalar(const Mark &mark, const std::string &tag,
+                          void *pParentNode, const std::string &value) = 0;
+
+  // Create and return a new sequence node
+  virtual void *NewSequence(const Mark &mark, const std::string &tag,
+                            void *pParentNode) = 0;
+
+  // Add pNode to pSequence.  pNode was created with one of the NewXxx()
+  // functions and pSequence with NewSequence().
+  virtual void AppendToSequence(void *pSequence, void *pNode) = 0;
+
+  // Note that no moew entries will be added to pSequence
+  virtual void SequenceComplete(void *pSequence) { (void)pSequence; }
+
+  // Create and return a new map node
+  virtual void *NewMap(const Mark &mark, const std::string &tag,
+                       void *pParentNode) = 0;
+
+  // Add the pKeyNode => pValueNode mapping to pMap.  pKeyNode and pValueNode
+  // were created with one of the NewXxx() methods and pMap with NewMap().
+  virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) = 0;
+
+  // Note that no more assignments will be made in pMap
+  virtual void MapComplete(void *pMap) { (void)pMap; }
+
+  // Return the node that should be used in place of an alias referencing
+  // pNode (pNode by default)
+  virtual void *AnchorReference(const Mark &mark, void *pNode) {
+    (void)mark;
+    return pNode;
  }
+};
+
+// Typesafe wrapper for GraphBuilderInterface.  Assumes that Impl defines
+// Node, Sequence, and Map types.  Sequence and Map must derive from Node
+// (unless Node is defined as void).  Impl must also implement function with
+// all of the same names as the virtual functions in GraphBuilderInterface
+// -- including the ones with default implementations -- but with the
+// prototypes changed to accept an explicit Node*, Sequence*, or Map* where
+// appropriate.
+template <class Impl>
+class GraphBuilder : public GraphBuilderInterface {
+ public:
+  typedef typename Impl::Node Node;
+  typedef typename Impl::Sequence Sequence;
+  typedef typename Impl::Map Map;
+
+  GraphBuilder(Impl &impl) : m_impl(impl) {
+    Map *pMap = NULL;
+    Sequence *pSeq = NULL;
+    Node *pNode = NULL;
+
+    // Type consistency checks
+    pNode = pMap;
+    pNode = pSeq;
+  }
+
+  GraphBuilderInterface &AsBuilderInterface() { return *this; }
+
+  virtual void *NewNull(const Mark &mark, void *pParentNode) {
+    return CheckType<Node>(m_impl.NewNull(mark, AsNode(pParentNode)));
+  }
+
+  virtual void *NewScalar(const Mark &mark, const std::string &tag,
+                          void *pParentNode, const std::string &value) {
+    return CheckType<Node>(
+        m_impl.NewScalar(mark, tag, AsNode(pParentNode), value));
+  }
+
+  virtual void *NewSequence(const Mark &mark, const std::string &tag,
+                            void *pParentNode) {
+    return CheckType<Sequence>(
+        m_impl.NewSequence(mark, tag, AsNode(pParentNode)));
+  }
+  virtual void AppendToSequence(void *pSequence, void *pNode) {
+    m_impl.AppendToSequence(AsSequence(pSequence), AsNode(pNode));
+  }
+  virtual void SequenceComplete(void *pSequence) {
+    m_impl.SequenceComplete(AsSequence(pSequence));
+  }
+
+  virtual void *NewMap(const Mark &mark, const std::string &tag,
+                       void *pParentNode) {
+    return CheckType<Map>(m_impl.NewMap(mark, tag, AsNode(pParentNode)));
+  }
+  virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) {
+    m_impl.AssignInMap(AsMap(pMap), AsNode(pKeyNode), AsNode(pValueNode));
+  }
+  virtual void MapComplete(void *pMap) { m_impl.MapComplete(AsMap(pMap)); }
+
+  virtual void *AnchorReference(const Mark &mark, void *pNode) {
+    return CheckType<Node>(m_impl.AnchorReference(mark, AsNode(pNode)));
+  }
+
+ private:
+  Impl &m_impl;
+
+  // Static check for pointer to T
+  template <class T, class U>
+  static T *CheckType(U *p) {
+    return p;
+  }
+
+  static Node *AsNode(void *pNode) { return static_cast<Node *>(pNode); }
+  static Sequence *AsSequence(void *pSeq) {
+    return static_cast<Sequence *>(pSeq);
+  }
+  static Map *AsMap(void *pMap) { return static_cast<Map *>(pMap); }
+};
+
+void *BuildGraphOfNextDocument(Parser &parser,
+                               GraphBuilderInterface &graphBuilder);
+
+template <class Impl>
+typename Impl::Node *BuildGraphOfNextDocument(Parser &parser, Impl &impl) {
+  GraphBuilder<Impl> graphBuilder(impl);
+  return static_cast<typename Impl::Node *>(
+      BuildGraphOfNextDocument(parser, graphBuilder));
+}
 }

-#endif // GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#endif  // GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,28 +1,37 @@
 #ifndef DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define DLL_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
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

-// The following ifdef block is the standard way of creating macros which make exporting
-// from a DLL simpler. All files within this DLL are compiled with the yaml_cpp_EXPORTS
-// symbol defined on the command line. this symbol should not be defined on any project
-// that uses this DLL. This way any other project whose source files include this file see
-// YAML_CPP_API functions as being imported from a DLL, whereas this DLL sees symbols
+// The following ifdef block is the standard way of creating macros which make
+// exporting
+// from a DLL simpler. All files within this DLL are compiled with the
+// yaml_cpp_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any
+// project
+// that uses this DLL. This way any other project whose source files include
+// this file see
+// YAML_CPP_API functions as being imported from a DLL, whereas this DLL sees
+// symbols
 // defined with this macro as being exported.
 #undef YAML_CPP_API

-#ifdef YAML_CPP_DLL // Using or Building YAML-CPP DLL (definition defined manually)
-	#ifdef yaml_cpp_EXPORTS // Building YAML-CPP DLL (definition created by CMake or defined manually)
-	//	#pragma message( "Defining YAML_CPP_API for DLL export" )
-		#define YAML_CPP_API __declspec(dllexport)
-	#else // yaml_cpp_EXPORTS
-	//	#pragma message( "Defining YAML_CPP_API for DLL import" )
-		#define YAML_CPP_API __declspec(dllimport)
-	#endif // yaml_cpp_EXPORTS
-#else //YAML_CPP_DLL
+#ifdef YAML_CPP_DLL      // Using or Building YAML-CPP DLL (definition defined
+                         // manually)
+#ifdef yaml_cpp_EXPORTS  // Building YAML-CPP DLL (definition created by CMake
+                         // or defined manually)
+//	#pragma message( "Defining YAML_CPP_API for DLL export" )
+#define YAML_CPP_API __declspec(dllexport)
+#else  // yaml_cpp_EXPORTS
+//	#pragma message( "Defining YAML_CPP_API for DLL import" )
+#define YAML_CPP_API __declspec(dllimport)
+#endif  // yaml_cpp_EXPORTS
+#else   // YAML_CPP_DLL
 #define YAML_CPP_API
-#endif // YAML_CPP_DLL
+#endif  // YAML_CPP_DLL

-#endif // DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#endif  // DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,45 +1,57 @@
 #ifndef EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITFROMEVENTS_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
+#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/eventhandler.h"
 #include <stack>

-namespace YAML
-{
-	class Emitter;
-	
-	class EmitFromEvents: public EventHandler
-	{
-	public:
-		EmitFromEvents(Emitter& emitter);
-		
-		virtual void OnDocumentStart(const Mark& mark);
-		virtual void OnDocumentEnd();
-		
-		virtual void OnNull(const Mark& mark, anchor_t anchor);
-		virtual void OnAlias(const Mark& mark, anchor_t anchor);
-		virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value);
-		
-		virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor);
-		virtual void OnSequenceEnd();
-		
-		virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor);
-		virtual void OnMapEnd();
-		
-	private:
-		void BeginNode();
-		void EmitProps(const std::string& tag, anchor_t anchor);
-		
-	private:
-		Emitter& m_emitter;
-		
-		struct State { enum value { WaitingForSequenceEntry, WaitingForKey, WaitingForValue }; };
-		std::stack<State::value> m_stateStack;
-	};
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
+
+namespace YAML {
+struct Mark;
+}  // namespace YAML
+
+namespace YAML {
+class Emitter;
+
+class EmitFromEvents : public EventHandler {
+ public:
+  EmitFromEvents(Emitter& emitter);
+
+  virtual void OnDocumentStart(const Mark& mark);
+  virtual void OnDocumentEnd();
+
+  virtual void OnNull(const Mark& mark, anchor_t anchor);
+  virtual void OnAlias(const Mark& mark, anchor_t anchor);
+  virtual void OnScalar(const Mark& mark, const std::string& tag,
+                        anchor_t anchor, const std::string& value);
+
+  virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
+                               anchor_t anchor, EmitterStyle::value style);
+  virtual void OnSequenceEnd();
+
+  virtual void OnMapStart(const Mark& mark, const std::string& tag,
+                          anchor_t anchor, EmitterStyle::value style);
+  virtual void OnMapEnd();
+
+ private:
+  void BeginNode();
+  void EmitProps(const std::string& tag, anchor_t anchor);
+
+ private:
+  Emitter& m_emitter;
+
+  struct State {
+    enum value { WaitingForSequenceEntry, WaitingForKey, WaitingForValue };
+  };
+  std::stack<State::value> m_stateStack;
+};
 }

-#endif // EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#endif  // EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,209 +1,254 @@
 #ifndef EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITTER_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
+#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 <cstddef>
+#include <memory>
+#include <sstream>
+#include <string>

-#include "yaml-cpp/dll.h"
 #include "yaml-cpp/binary.h"
+#include "yaml-cpp/dll.h"
 #include "yaml-cpp/emitterdef.h"
 #include "yaml-cpp/emittermanip.h"
 #include "yaml-cpp/noncopyable.h"
 #include "yaml-cpp/null.h"
 #include "yaml-cpp/ostream_wrapper.h"
-#include <memory>
-#include <string>
-#include <sstream>

-namespace YAML
-{
-	class EmitterState;
-	
-	class YAML_CPP_API Emitter: private noncopyable
-	{
-	public:
-		Emitter();
-        explicit Emitter(std::ostream& stream);
-		~Emitter();
-		
-		// output
-		const char *c_str() const;
-        std::size_t size() const;
-		
-		// state checking
-		bool good() const;
-		const std::string GetLastError() const;
-		
-		// global setters
-		bool SetOutputCharset(EMITTER_MANIP value);
-		bool SetStringFormat(EMITTER_MANIP value);
-		bool SetBoolFormat(EMITTER_MANIP value);
-		bool SetIntBase(EMITTER_MANIP value);
-		bool SetSeqFormat(EMITTER_MANIP value);
-		bool SetMapFormat(EMITTER_MANIP value);
-		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& n);
-		Emitter& Write(const Binary& binary);
-		
-		template <typename T>
-		Emitter& WriteIntegralType(T value);
-		
-		template <typename T>
-		Emitter& WriteStreamable(T value);
+namespace YAML {
+class Binary;
+struct _Null;
+}  // namespace YAML

-	private:
-        template<typename T> void SetStreamablePrecision(std::stringstream&) {}
-        unsigned GetFloatPrecision() const;
-        unsigned GetDoublePrecision() const;
-        
-        void PrepareIntegralStream(std::stringstream& stream) const;
-        void StartedScalar();
-	
-	private:
-		void EmitBeginDoc();
-		void EmitEndDoc();
-		void EmitBeginSeq();
-		void EmitEndSeq();
-		void EmitBeginMap();
-		void EmitEndMap();
-		void EmitNewline();
-		void EmitKindTag();
-		void EmitTag(bool verbatim, const _Tag& tag);
-		
-        void PrepareNode(EmitterNodeType::value child);
-        void PrepareTopNode(EmitterNodeType::value child);
-        void FlowSeqPrepareNode(EmitterNodeType::value child);
-        void BlockSeqPrepareNode(EmitterNodeType::value child);
+namespace YAML {
+class EmitterState;

-        void FlowMapPrepareNode(EmitterNodeType::value child);
+class YAML_CPP_API Emitter : private noncopyable {
+ public:
+  Emitter();
+  explicit Emitter(std::ostream& stream);
+  ~Emitter();

-        void FlowMapPrepareLongKey(EmitterNodeType::value child);
-        void FlowMapPrepareLongKeyValue(EmitterNodeType::value child);
-        void FlowMapPrepareSimpleKey(EmitterNodeType::value child);
-        void FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child);
+  // output
+  const char* c_str() const;
+  std::size_t size() const;

-        void BlockMapPrepareNode(EmitterNodeType::value child);
+  // state checking
+  bool good() const;
+  const std::string GetLastError() const;

-        void BlockMapPrepareLongKey(EmitterNodeType::value child);
-        void BlockMapPrepareLongKeyValue(EmitterNodeType::value child);
-        void BlockMapPrepareSimpleKey(EmitterNodeType::value child);
-        void BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child);
-        
-        void SpaceOrIndentTo(bool requireSpace, unsigned indent);
-        
-		const char *ComputeFullBoolName(bool b) const;
-		bool CanEmitNewline() const;
-		
-	private:
-		std::auto_ptr<EmitterState> m_pState;
-		ostream_wrapper m_stream;
-	};
-	
-	template <typename T>
-	inline Emitter& Emitter::WriteIntegralType(T value)
-	{
-		if(!good())
-			return *this;
-		
-        PrepareNode(EmitterNodeType::Scalar);
+  // global setters
+  bool SetOutputCharset(EMITTER_MANIP value);
+  bool SetStringFormat(EMITTER_MANIP value);
+  bool SetBoolFormat(EMITTER_MANIP value);
+  bool SetIntBase(EMITTER_MANIP value);
+  bool SetSeqFormat(EMITTER_MANIP value);
+  bool SetMapFormat(EMITTER_MANIP value);
+  bool SetIndent(std::size_t n);
+  bool SetPreCommentIndent(std::size_t n);
+  bool SetPostCommentIndent(std::size_t n);
+  bool SetFloatPrecision(std::size_t n);
+  bool SetDoublePrecision(std::size_t n);

-        std::stringstream stream;
-        PrepareIntegralStream(stream);
-        stream << value;
-        m_stream << stream.str();
-        
-        StartedScalar();
+  // local setters
+  Emitter& SetLocalValue(EMITTER_MANIP value);
+  Emitter& SetLocalIndent(const _Indent& indent);
+  Emitter& SetLocalPrecision(const _Precision& precision);

-		return *this;
-	}
+  // 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& n);
+  Emitter& Write(const Binary& binary);

-	template <typename T>
-	inline Emitter& Emitter::WriteStreamable(T value)
-	{
-		if(!good())
-			return *this;
-		
-        PrepareNode(EmitterNodeType::Scalar);
+  template <typename T>
+  Emitter& WriteIntegralType(T value);

-		std::stringstream stream;
-        SetStreamablePrecision<T>(stream);
-		stream << value;
-        m_stream << stream.str();
-        
-        StartedScalar();
+  template <typename T>
+  Emitter& WriteStreamable(T value);

-		return *this;
-	}
-	
-    template<>
-    inline void Emitter::SetStreamablePrecision<float>(std::stringstream& stream)
-    {
-		stream.precision(GetFloatPrecision());
-    }
+ private:
+  template <typename T>
+  void SetStreamablePrecision(std::stringstream&) {}
+  std::size_t GetFloatPrecision() const;
+  std::size_t GetDoublePrecision() const;

-    template<>
-    inline void Emitter::SetStreamablePrecision<double>(std::stringstream& stream)
-    {
-		stream.precision(GetDoublePrecision());
-    }
+  void PrepareIntegralStream(std::stringstream& stream) const;
+  void StartedScalar();

-	// 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); }
+ private:
+  void EmitBeginDoc();
+  void EmitEndDoc();
+  void EmitBeginSeq();
+  void EmitEndSeq();
+  void EmitBeginMap();
+  void EmitEndMap();
+  void EmitNewline();
+  void EmitKindTag();
+  void EmitTag(bool verbatim, const _Tag& tag);

-	inline Emitter& operator << (Emitter& emitter, const char *v) { return emitter.Write(std::string(v)); }
+  void PrepareNode(EmitterNodeType::value child);
+  void PrepareTopNode(EmitterNodeType::value child);
+  void FlowSeqPrepareNode(EmitterNodeType::value child);
+  void BlockSeqPrepareNode(EmitterNodeType::value child);

-	inline Emitter& operator << (Emitter& emitter, int v) { return emitter.WriteIntegralType(v); }
-	inline Emitter& operator << (Emitter& emitter, unsigned int v) { return emitter.WriteIntegralType(v); }
-	inline Emitter& operator << (Emitter& emitter, short v) { return emitter.WriteIntegralType(v); }
-	inline Emitter& operator << (Emitter& emitter, unsigned short v) { return emitter.WriteIntegralType(v); }
-	inline Emitter& operator << (Emitter& emitter, long v) { return emitter.WriteIntegralType(v); }
-	inline Emitter& operator << (Emitter& emitter, unsigned long v) { return emitter.WriteIntegralType(v); }
-	inline Emitter& operator << (Emitter& emitter, long long v) { return emitter.WriteIntegralType(v); }
-	inline Emitter& operator << (Emitter& emitter, unsigned long long v) { return emitter.WriteIntegralType(v); }
+  void FlowMapPrepareNode(EmitterNodeType::value child);

-	inline Emitter& operator << (Emitter& emitter, float v) { return emitter.WriteStreamable(v); }
-	inline Emitter& operator << (Emitter& emitter, double v) { return emitter.WriteStreamable(v); }
+  void FlowMapPrepareLongKey(EmitterNodeType::value child);
+  void FlowMapPrepareLongKeyValue(EmitterNodeType::value child);
+  void FlowMapPrepareSimpleKey(EmitterNodeType::value child);
+  void FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child);

-	inline Emitter& operator << (Emitter& emitter, EMITTER_MANIP value) {
-		return emitter.SetLocalValue(value);
-	}
-	
-	inline Emitter& operator << (Emitter& emitter, _Indent indent) {
-		return emitter.SetLocalIndent(indent);
-	}
-    
-    inline Emitter& operator << (Emitter& emitter, _Precision precision) {
-        return emitter.SetLocalPrecision(precision);
-    }
+  void BlockMapPrepareNode(EmitterNodeType::value child);
+
+  void BlockMapPrepareLongKey(EmitterNodeType::value child);
+  void BlockMapPrepareLongKeyValue(EmitterNodeType::value child);
+  void BlockMapPrepareSimpleKey(EmitterNodeType::value child);
+  void BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child);
+
+  void SpaceOrIndentTo(bool requireSpace, std::size_t indent);
+
+  const char* ComputeFullBoolName(bool b) const;
+  bool CanEmitNewline() const;
+
+ private:
+  std::auto_ptr<EmitterState> m_pState;
+  ostream_wrapper m_stream;
+};
+
+template <typename T>
+inline Emitter& Emitter::WriteIntegralType(T value) {
+  if (!good())
+    return *this;
+
+  PrepareNode(EmitterNodeType::Scalar);
+
+  std::stringstream stream;
+  PrepareIntegralStream(stream);
+  stream << value;
+  m_stream << stream.str();
+
+  StartedScalar();
+
+  return *this;
 }

-#endif // EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+template <typename T>
+inline Emitter& Emitter::WriteStreamable(T value) {
+  if (!good())
+    return *this;
+
+  PrepareNode(EmitterNodeType::Scalar);
+
+  std::stringstream stream;
+  SetStreamablePrecision<T>(stream);
+  stream << value;
+  m_stream << stream.str();
+
+  StartedScalar();
+
+  return *this;
+}
+
+template <>
+inline void Emitter::SetStreamablePrecision<float>(std::stringstream& stream) {
+  stream.precision(GetFloatPrecision());
+}
+
+template <>
+inline void Emitter::SetStreamablePrecision<double>(std::stringstream& stream) {
+  stream.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 char* v) {
+  return emitter.Write(std::string(v));
+}
+
+inline Emitter& operator<<(Emitter& emitter, int v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned int v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, short v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned short v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, long v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned long v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, long long v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned long long v) {
+  return emitter.WriteIntegralType(v);
+}
+
+inline Emitter& operator<<(Emitter& emitter, float v) {
+  return emitter.WriteStreamable(v);
+}
+inline Emitter& operator<<(Emitter& emitter, double v) {
+  return emitter.WriteStreamable(v);
+}
+
+inline Emitter& operator<<(Emitter& emitter, EMITTER_MANIP value) {
+  return emitter.SetLocalValue(value);
+}
+
+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,13 +1,16 @@
 #ifndef EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITTERDEF_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
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

-namespace YAML
-{
-    struct EmitterNodeType { enum value { None, Property, Scalar, FlowSeq, BlockSeq, FlowMap, BlockMap }; };
+namespace YAML {
+struct EmitterNodeType {
+  enum value { NoType, Property, Scalar, FlowSeq, BlockSeq, FlowMap, BlockMap };
+};
 }

-#endif // EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#endif  // EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,149 +1,137 @@
 #ifndef EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITTERMANIP_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
+#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>

-namespace YAML
-{
-	enum EMITTER_MANIP {
-		// general manipulators
-		Auto,
-		TagByKind,
-		Newline,
+namespace YAML {
+enum EMITTER_MANIP {
+  // general manipulators
+  Auto,
+  TagByKind,
+  Newline,

-		// output character set
-		EmitNonAscii,
-		EscapeNonAscii,
-		
-		// string manipulators
-		// Auto, // duplicate
-		SingleQuoted,
-		DoubleQuoted,
-		Literal,
-		
-		// bool manipulators
-		YesNoBool,  // yes, no
-		TrueFalseBool,  // true, false
-		OnOffBool,  // on, off
-		UpperCase,  // TRUE, N
-		LowerCase,  // f, yes
-		CamelCase,  // No, Off
-		LongBool,  // yes, On
-		ShortBool,  // y, t
-		
-		// int manipulators
-		Dec,
-		Hex,
-		Oct,
-		
-		// document manipulators
-		BeginDoc,
-		EndDoc,
-		
-		// sequence manipulators
-		BeginSeq,
-		EndSeq,
-		Flow,
-		Block,
-		
-		// map manipulators
-		BeginMap,
-		EndMap,
-		Key,
-		Value,
-		// Flow, // duplicate
-		// Block, // duplicate
-		// Auto, // duplicate
-		LongKey
-	};
-	
-	struct _Indent {
-		_Indent(int value_): value(value_) {}
-		int value;
-	};
-	
-	inline _Indent Indent(int value) {
-		return _Indent(value);
-	}
-	
-	struct _Alias {
-		_Alias(const std::string& content_): content(content_) {}
-		std::string content;
-	};
-	
-	inline _Alias Alias(const std::string content) {
-		return _Alias(content);
-	}
-	
-	struct _Anchor {
-		_Anchor(const std::string& content_): content(content_) {}
-		std::string content;
-	};
+  // output character set
+  EmitNonAscii,
+  EscapeNonAscii,

-	inline _Anchor Anchor(const std::string content) {
-		return _Anchor(content);
-	}
-	
-	struct _Tag {
-		struct Type { enum value { Verbatim, PrimaryHandle, NamedHandle }; };
-		
-		explicit _Tag(const std::string& prefix_, const std::string& content_, Type::value type_)
-		: prefix(prefix_), content(content_), type(type_)
-		{
-		}
-		std::string prefix;
-		std::string content;
-		Type::value type;
-	};
-	
-	inline _Tag VerbatimTag(const std::string content) {
-		return _Tag("", content, _Tag::Type::Verbatim);
-	}
+  // string manipulators
+  // Auto, // duplicate
+  SingleQuoted,
+  DoubleQuoted,
+  Literal,

-	inline _Tag LocalTag(const std::string content) {
-		return _Tag("", content, _Tag::Type::PrimaryHandle);
-	}
+  // bool manipulators
+  YesNoBool,      // yes, no
+  TrueFalseBool,  // true, false
+  OnOffBool,      // on, off
+  UpperCase,      // TRUE, N
+  LowerCase,      // f, yes
+  CamelCase,      // No, Off
+  LongBool,       // yes, On
+  ShortBool,      // y, t

-	inline _Tag LocalTag(const std::string& prefix, const std::string content) {
-		return _Tag(prefix, content, _Tag::Type::NamedHandle);
-	}
+  // int manipulators
+  Dec,
+  Hex,
+  Oct,

-	inline _Tag SecondaryTag(const std::string content) {
-		return _Tag("", content, _Tag::Type::NamedHandle);
-	}
+  // document manipulators
+  BeginDoc,
+  EndDoc,

-	struct _Comment {
-		_Comment(const std::string& content_): content(content_) {}
-		std::string content;
-	};
-	
-	inline _Comment Comment(const std::string content) {
-		return _Comment(content);
-	}
-    
-    struct _Precision {
-        _Precision(int floatPrecision_, int doublePrecision_): floatPrecision(floatPrecision_), doublePrecision(doublePrecision_) {}
-        
-        int floatPrecision;
-        int doublePrecision;
-    };
-    
-    inline _Precision FloatPrecision(int n) {
-        return _Precision(n, -1);
-    }
+  // sequence manipulators
+  BeginSeq,
+  EndSeq,
+  Flow,
+  Block,

-    inline _Precision DoublePrecision(int n) {
-        return _Precision(-1, n);
-    }
+  // map manipulators
+  BeginMap,
+  EndMap,
+  Key,
+  Value,
+  // Flow, // duplicate
+  // Block, // duplicate
+  // Auto, // duplicate
+  LongKey
+};

-    inline _Precision Precision(int n) {
-        return _Precision(n, n);
-    }
+struct _Indent {
+  _Indent(int value_) : value(value_) {}
+  int value;
+};
+
+inline _Indent Indent(int value) { return _Indent(value); }
+
+struct _Alias {
+  _Alias(const std::string& content_) : content(content_) {}
+  std::string content;
+};
+
+inline _Alias Alias(const std::string content) { return _Alias(content); }
+
+struct _Anchor {
+  _Anchor(const std::string& content_) : content(content_) {}
+  std::string content;
+};
+
+inline _Anchor Anchor(const std::string content) { return _Anchor(content); }
+
+struct _Tag {
+  struct Type {
+    enum value { Verbatim, PrimaryHandle, NamedHandle };
+  };
+
+  explicit _Tag(const std::string& prefix_, const std::string& content_,
+                Type::value type_)
+      : prefix(prefix_), content(content_), type(type_) {}
+  std::string prefix;
+  std::string content;
+  Type::value type;
+};
+
+inline _Tag VerbatimTag(const std::string content) {
+  return _Tag("", content, _Tag::Type::Verbatim);
 }

-#endif // EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+inline _Tag LocalTag(const std::string content) {
+  return _Tag("", content, _Tag::Type::PrimaryHandle);
+}
+
+inline _Tag LocalTag(const std::string& prefix, const std::string content) {
+  return _Tag(prefix, content, _Tag::Type::NamedHandle);
+}
+
+inline _Tag SecondaryTag(const std::string content) {
+  return _Tag("", content, _Tag::Type::NamedHandle);
+}
+
+struct _Comment {
+  _Comment(const std::string& content_) : content(content_) {}
+  std::string content;
+};
+
+inline _Comment Comment(const std::string content) { return _Comment(content); }
+
+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
@@ -0,0 +1,16 @@
+#ifndef EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERSTYLE_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
+
+namespace YAML {
+struct EmitterStyle {
+  enum value { Default, Block, Flow };
+};
+}
+
+#endif  // EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,36 +1,40 @@
 #ifndef EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EVENTHANDLER_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
+#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/anchor.h"
 #include <string>

-namespace YAML
-{
-	struct Mark;
-	
-	class EventHandler
-	{
-	public:
-		virtual ~EventHandler() {}
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/emitterstyle.h"

-		virtual void OnDocumentStart(const Mark& mark) = 0;
-		virtual void OnDocumentEnd() = 0;
-		
-		virtual void OnNull(const Mark& mark, anchor_t anchor) = 0;
-		virtual void OnAlias(const Mark& mark, anchor_t anchor) = 0;
-		virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value) = 0;
+namespace YAML {
+struct Mark;

-		virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor) = 0;
-		virtual void OnSequenceEnd() = 0;
+class EventHandler {
+ public:
+  virtual ~EventHandler() {}

-		virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor) = 0;
-		virtual void OnMapEnd() = 0;
-	};
+  virtual void OnDocumentStart(const Mark& mark) = 0;
+  virtual void OnDocumentEnd() = 0;
+
+  virtual void OnNull(const Mark& mark, anchor_t anchor) = 0;
+  virtual void OnAlias(const Mark& mark, anchor_t anchor) = 0;
+  virtual void OnScalar(const Mark& mark, const std::string& tag,
+                        anchor_t anchor, const std::string& value) = 0;
+
+  virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
+                               anchor_t anchor, EmitterStyle::value style) = 0;
+  virtual void OnSequenceEnd() = 0;
+
+  virtual void OnMapStart(const Mark& mark, const std::string& tag,
+                          anchor_t anchor, EmitterStyle::value style) = 0;
+  virtual void OnMapEnd() = 0;
+};
 }

-#endif // EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
+#endif  // EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,201 +1,227 @@
 #ifndef EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EXCEPTIONS_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
+#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/mark.h"
 #include "yaml-cpp/traits.h"
 #include <stdexcept>
 #include <string>
 #include <sstream>

-namespace YAML
-{
-	// error messages
-	namespace ErrorMsg
-	{
-		const char * const YAML_DIRECTIVE_ARGS    = "YAML directives must have exactly one argument";
-		const char * const YAML_VERSION           = "bad YAML version: ";
-		const char * const YAML_MAJOR_VERSION     = "YAML major version too large";
-		const char * const REPEATED_YAML_DIRECTIVE= "repeated YAML directive";
-		const char * const TAG_DIRECTIVE_ARGS     = "TAG directives must have exactly two arguments";
-		const char * const REPEATED_TAG_DIRECTIVE = "repeated TAG directive";
-		const char * const CHAR_IN_TAG_HANDLE     = "illegal character found while scanning tag handle";
-		const char * const TAG_WITH_NO_SUFFIX     = "tag handle with no suffix";
-		const char * const END_OF_VERBATIM_TAG    = "end of verbatim tag not found";
-		const char * const END_OF_MAP             = "end of map not found";
-		const char * const END_OF_MAP_FLOW        = "end of map flow not found";
-		const char * const END_OF_SEQ             = "end of sequence not found";
-		const char * const END_OF_SEQ_FLOW        = "end of sequence flow not found";
-		const char * const MULTIPLE_TAGS          = "cannot assign multiple tags to the same node";
-		const char * const MULTIPLE_ANCHORS       = "cannot assign multiple anchors to the same node";
-		const char * const MULTIPLE_ALIASES       = "cannot assign multiple aliases to the same node";
-		const char * const ALIAS_CONTENT          = "aliases can't have any content, *including* tags";
-		const char * const INVALID_HEX            = "bad character found while scanning hex number";
-		const char * const INVALID_UNICODE        = "invalid unicode: ";
-		const char * const INVALID_ESCAPE         = "unknown escape character: ";
-		const char * const UNKNOWN_TOKEN          = "unknown token";
-		const char * const DOC_IN_SCALAR          = "illegal document indicator in scalar";
-		const char * const EOF_IN_SCALAR          = "illegal EOF in scalar";
-		const char * const CHAR_IN_SCALAR         = "illegal character in scalar";
-		const char * const TAB_IN_INDENTATION     = "illegal tab when looking for indentation";
-		const char * const FLOW_END               = "illegal flow end";
-		const char * const BLOCK_ENTRY            = "illegal block entry";
-		const char * const MAP_KEY                = "illegal map key";
-		const char * const MAP_VALUE              = "illegal map value";
-		const char * const ALIAS_NOT_FOUND        = "alias not found after *";
-		const char * const ANCHOR_NOT_FOUND       = "anchor not found after &";
-		const char * const CHAR_IN_ALIAS          = "illegal character found while scanning alias";
-		const char * const CHAR_IN_ANCHOR         = "illegal character found while scanning anchor";
-		const char * const ZERO_INDENT_IN_BLOCK   = "cannot set zero indentation for a block scalar";
-		const char * const CHAR_IN_BLOCK          = "unexpected character in block scalar";
-		const char * const AMBIGUOUS_ANCHOR       = "cannot assign the same alias to multiple nodes";
-		const char * const UNKNOWN_ANCHOR         = "the referenced anchor is not defined";
+namespace YAML {
+// error messages
+namespace ErrorMsg {
+const char* const YAML_DIRECTIVE_ARGS =
+    "YAML directives must have exactly one argument";
+const char* const YAML_VERSION = "bad YAML version: ";
+const char* const YAML_MAJOR_VERSION = "YAML major version too large";
+const char* const REPEATED_YAML_DIRECTIVE = "repeated YAML directive";
+const char* const TAG_DIRECTIVE_ARGS =
+    "TAG directives must have exactly two arguments";
+const char* const REPEATED_TAG_DIRECTIVE = "repeated TAG directive";
+const char* const CHAR_IN_TAG_HANDLE =
+    "illegal character found while scanning tag handle";
+const char* const TAG_WITH_NO_SUFFIX = "tag handle with no suffix";
+const char* const END_OF_VERBATIM_TAG = "end of verbatim tag not found";
+const char* const END_OF_MAP = "end of map not found";
+const char* const END_OF_MAP_FLOW = "end of map flow not found";
+const char* const END_OF_SEQ = "end of sequence not found";
+const char* const END_OF_SEQ_FLOW = "end of sequence flow not found";
+const char* const MULTIPLE_TAGS =
+    "cannot assign multiple tags to the same node";
+const char* const MULTIPLE_ANCHORS =
+    "cannot assign multiple anchors to the same node";
+const char* const MULTIPLE_ALIASES =
+    "cannot assign multiple aliases to the same node";
+const char* const ALIAS_CONTENT =
+    "aliases can't have any content, *including* tags";
+const char* const INVALID_HEX = "bad character found while scanning hex number";
+const char* const INVALID_UNICODE = "invalid unicode: ";
+const char* const INVALID_ESCAPE = "unknown escape character: ";
+const char* const UNKNOWN_TOKEN = "unknown token";
+const char* const DOC_IN_SCALAR = "illegal document indicator in scalar";
+const char* const EOF_IN_SCALAR = "illegal EOF in scalar";
+const char* const CHAR_IN_SCALAR = "illegal character in scalar";
+const char* const TAB_IN_INDENTATION =
+    "illegal tab when looking for indentation";
+const char* const FLOW_END = "illegal flow end";
+const char* const BLOCK_ENTRY = "illegal block entry";
+const char* const MAP_KEY = "illegal map key";
+const char* const MAP_VALUE = "illegal map value";
+const char* const ALIAS_NOT_FOUND = "alias not found after *";
+const char* const ANCHOR_NOT_FOUND = "anchor not found after &";
+const char* const CHAR_IN_ALIAS =
+    "illegal character found while scanning alias";
+const char* const CHAR_IN_ANCHOR =
+    "illegal character found while scanning anchor";
+const char* const ZERO_INDENT_IN_BLOCK =
+    "cannot set zero indentation for a block scalar";
+const char* const CHAR_IN_BLOCK = "unexpected character in block scalar";
+const char* const AMBIGUOUS_ANCHOR =
+    "cannot assign the same alias to multiple nodes";
+const char* const UNKNOWN_ANCHOR = "the referenced anchor is not defined";

-		const char * const INVALID_SCALAR         = "invalid scalar";
-		const char * const KEY_NOT_FOUND          = "key not found";
-        const char * const BAD_CONVERSION         = "bad conversion";
-		const char * const BAD_DEREFERENCE        = "bad dereference";
-        const char * const BAD_SUBSCRIPT          = "operator[] call on a scalar";
-        const char * const BAD_PUSHBACK           = "appending to a non-sequence";
-        const char * const BAD_INSERT             = "inserting in a non-convertible-to-map";
-		
-		const char * const UNMATCHED_GROUP_TAG    = "unmatched group tag";
-		const char * const UNEXPECTED_END_SEQ     = "unexpected end sequence token";
-		const char * const UNEXPECTED_END_MAP     = "unexpected end map token";
-		const char * const SINGLE_QUOTED_CHAR     = "invalid character in single-quoted string";
-		const char * const INVALID_ANCHOR         = "invalid anchor";
-		const char * const INVALID_ALIAS          = "invalid alias";
-		const char * const INVALID_TAG            = "invalid tag";
-        const char * const BAD_FILE               = "bad file";
+const char* const INVALID_NODE =
+    "invalid node; this may result from using a map iterator as a sequence "
+    "iterator, or vice-versa";
+const char* const INVALID_SCALAR = "invalid scalar";
+const char* const KEY_NOT_FOUND = "key not found";
+const char* const BAD_CONVERSION = "bad conversion";
+const char* const BAD_DEREFERENCE = "bad dereference";
+const char* const BAD_SUBSCRIPT = "operator[] call on a scalar";
+const char* const BAD_PUSHBACK = "appending to a non-sequence";
+const char* const BAD_INSERT = "inserting in a non-convertible-to-map";

-		template <typename T>
-		inline const std::string KEY_NOT_FOUND_WITH_KEY(const T&, typename disable_if<is_numeric<T> >::type * = 0) {
-			return KEY_NOT_FOUND;
-		}
+const char* const UNMATCHED_GROUP_TAG = "unmatched group tag";
+const char* const UNEXPECTED_END_SEQ = "unexpected end sequence token";
+const char* const UNEXPECTED_END_MAP = "unexpected end map token";
+const char* const SINGLE_QUOTED_CHAR =
+    "invalid character in single-quoted string";
+const char* const INVALID_ANCHOR = "invalid anchor";
+const char* const INVALID_ALIAS = "invalid alias";
+const char* const INVALID_TAG = "invalid tag";
+const char* const BAD_FILE = "bad file";

-		inline const std::string KEY_NOT_FOUND_WITH_KEY(const std::string& key) {
-			std::stringstream stream;
-			stream << KEY_NOT_FOUND << ": " << key;
-			return stream.str();
-		}
-		
-		template <typename T>
-		inline const std::string KEY_NOT_FOUND_WITH_KEY(const T& key, typename enable_if<is_numeric<T> >::type * = 0) {
-			std::stringstream stream;
-			stream << KEY_NOT_FOUND << ": " << key;
-			return stream.str();
-		}
-	}
-
-	class Exception: public std::runtime_error {
-	public:
-		Exception(const Mark& mark_, const std::string& msg_)
-		: std::runtime_error(build_what(mark_, msg_)), mark(mark_), msg(msg_) {}
-		virtual ~Exception() throw() {}
-
-		Mark mark;
-		std::string msg;
-
-	private:
-		static const std::string build_what(const Mark& mark, const std::string& msg) {
-			std::stringstream output;
-			output << "yaml-cpp: error at line " << mark.line+1 << ", column " << mark.column+1 << ": " << msg;
-			return output.str();
-		}
-	};
-
-	class ParserException: public Exception {
-	public:
-		ParserException(const Mark& mark_, const std::string& msg_)
-			: Exception(mark_, msg_) {}
-	};
-
-	class RepresentationException: public Exception {
-	public:
-		RepresentationException(const Mark& mark_, const std::string& msg_)
-			: Exception(mark_, msg_) {}
-	};
-
-	// representation exceptions
-	class InvalidScalar: public RepresentationException {
-	public:
-		InvalidScalar(const Mark& mark_)
-			: RepresentationException(mark_, ErrorMsg::INVALID_SCALAR) {}
-	};
-
-	class KeyNotFound: public RepresentationException {
-	public:
-		template <typename T>
-		KeyNotFound(const Mark& mark_, const T& key_)
-			: RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) {}
-	};
-	
-	template <typename T>
-	class TypedKeyNotFound: public KeyNotFound {
-	public:
-		TypedKeyNotFound(const Mark& mark_, const T& key_)
-			: KeyNotFound(mark_, key_), key(key_) {}
-		virtual ~TypedKeyNotFound() throw() {}
-
-		T key;
-	};
-
-	template <typename T>
-	inline TypedKeyNotFound <T> MakeTypedKeyNotFound(const Mark& mark, const T& key) {
-		return TypedKeyNotFound <T> (mark, key);
-	}
-
-	class BadConversion: public RepresentationException {
-	public:
-		BadConversion()
-        : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_CONVERSION) {}
-	};
-
-    template<typename T>
-	class TypedBadConversion: public BadConversion {
-	public:
-		TypedBadConversion()
-        : BadConversion() {}
-	};
-
-	class BadDereference: public RepresentationException {
-	public:
-		BadDereference()
-		: RepresentationException(Mark::null_mark(), ErrorMsg::BAD_DEREFERENCE) {}
-	};
-
-	class BadSubscript: public RepresentationException {
-	public:
-		BadSubscript()
-		: RepresentationException(Mark::null_mark(), ErrorMsg::BAD_SUBSCRIPT) {}
-	};
-
-	class BadPushback: public RepresentationException {
-	public:
-		BadPushback()
-		: RepresentationException(Mark::null_mark(), ErrorMsg::BAD_PUSHBACK) {}
-	};
-	
-	class BadInsert: public RepresentationException {
-	public:
-		BadInsert()
-		: RepresentationException(Mark::null_mark(), ErrorMsg::BAD_INSERT) {}
-	};
-
-	class EmitterException: public Exception {
-	public:
-		EmitterException(const std::string& msg_)
-		: Exception(Mark::null_mark(), msg_) {}
-	};
-    
-    class BadFile: public Exception {
-    public:
-        BadFile(): Exception(Mark::null_mark(), ErrorMsg::BAD_FILE) {}
-    };
+template <typename T>
+inline const std::string KEY_NOT_FOUND_WITH_KEY(
+    const T&, typename disable_if<is_numeric<T> >::type* = 0) {
+  return KEY_NOT_FOUND;
 }

-#endif // EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+inline const std::string KEY_NOT_FOUND_WITH_KEY(const std::string& key) {
+  std::stringstream stream;
+  stream << KEY_NOT_FOUND << ": " << key;
+  return stream.str();
+}
+
+template <typename T>
+inline const std::string KEY_NOT_FOUND_WITH_KEY(
+    const T& key, typename enable_if<is_numeric<T> >::type* = 0) {
+  std::stringstream stream;
+  stream << KEY_NOT_FOUND << ": " << key;
+  return stream.str();
+}
+}
+
+class Exception : public std::runtime_error {
+ public:
+  Exception(const Mark& mark_, const std::string& msg_)
+      : std::runtime_error(build_what(mark_, msg_)), mark(mark_), msg(msg_) {}
+  virtual ~Exception() throw() {}
+
+  Mark mark;
+  std::string msg;
+
+ private:
+  static const std::string build_what(const Mark& mark,
+                                      const std::string& msg) {
+    std::stringstream output;
+    output << "yaml-cpp: error at line " << mark.line + 1 << ", column "
+           << mark.column + 1 << ": " << msg;
+    return output.str();
+  }
+};
+
+class ParserException : public Exception {
+ public:
+  ParserException(const Mark& mark_, const std::string& msg_)
+      : Exception(mark_, msg_) {}
+};
+
+class RepresentationException : public Exception {
+ public:
+  RepresentationException(const Mark& mark_, const std::string& msg_)
+      : Exception(mark_, msg_) {}
+};
+
+// representation exceptions
+class InvalidScalar : public RepresentationException {
+ public:
+  InvalidScalar(const Mark& mark_)
+      : RepresentationException(mark_, ErrorMsg::INVALID_SCALAR) {}
+};
+
+class KeyNotFound : public RepresentationException {
+ public:
+  template <typename T>
+  KeyNotFound(const Mark& mark_, const T& key_)
+      : RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) {
+  }
+};
+
+template <typename T>
+class TypedKeyNotFound : public KeyNotFound {
+ public:
+  TypedKeyNotFound(const Mark& mark_, const T& key_)
+      : KeyNotFound(mark_, key_), key(key_) {}
+  virtual ~TypedKeyNotFound() throw() {}
+
+  T key;
+};
+
+template <typename T>
+inline TypedKeyNotFound<T> MakeTypedKeyNotFound(const Mark& mark,
+                                                const T& key) {
+  return TypedKeyNotFound<T>(mark, key);
+}
+
+class InvalidNode : public RepresentationException {
+ public:
+  InvalidNode()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::INVALID_NODE) {}
+};
+
+class BadConversion : public RepresentationException {
+ public:
+  BadConversion()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_CONVERSION) {}
+};
+
+template <typename T>
+class TypedBadConversion : public BadConversion {
+ public:
+  TypedBadConversion() : BadConversion() {}
+};
+
+class BadDereference : public RepresentationException {
+ public:
+  BadDereference()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_DEREFERENCE) {}
+};
+
+class BadSubscript : public RepresentationException {
+ public:
+  BadSubscript()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_SUBSCRIPT) {}
+};
+
+class BadPushback : public RepresentationException {
+ public:
+  BadPushback()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_PUSHBACK) {}
+};
+
+class BadInsert : public RepresentationException {
+ public:
+  BadInsert()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_INSERT) {}
+};
+
+class EmitterException : public Exception {
+ public:
+  EmitterException(const std::string& msg_)
+      : Exception(Mark::null_mark(), msg_) {}
+};
+
+class BadFile : public Exception {
+ public:
+  BadFile() : Exception(Mark::null_mark(), ErrorMsg::BAD_FILE) {}
+};
+}
+
+#endif  // EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,26 +1,27 @@
 #ifndef MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define MARK_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
+#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"

-namespace YAML
-{
-	struct YAML_CPP_API Mark {
-		Mark(): pos(0), line(0), column(0) {}
-		
-		static const Mark null_mark() { return Mark(-1, -1, -1); }
-		
-		int pos;
-		int line, column;
-		
-	private:
-		Mark(int pos_, int line_, int column_): pos(pos_), line(line_), column(column_) {}
-	};
+namespace YAML {
+struct YAML_CPP_API Mark {
+  Mark() : pos(0), line(0), column(0) {}
+
+  static const Mark null_mark() { return Mark(-1, -1, -1); }
+
+  int pos;
+  int line, column;
+
+ private:
+  Mark(int pos_, int line_, int column_)
+      : pos(pos_), line(line_), column(column_) {}
+};
 }

-#endif // MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#endif  // MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,224 +1,286 @@
 #ifndef NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define NODE_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
+#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/binary.h"
-#include "yaml-cpp/node/node.h"
-#include "yaml-cpp/node/iterator.h"
-#include "yaml-cpp/null.h"
 #include <limits>
 #include <list>
 #include <map>
 #include <sstream>
 #include <vector>

-namespace YAML
-{
-    namespace conversion {
-        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";
-        }
-    }
-    
-	// std::string
-	template<>
-	struct convert<std::string> {
-		static Node encode(const std::string& rhs) {
-			return Node(rhs);
-		}
-		
-		static bool decode(const Node& node, std::string& rhs) {
-			if(!node.IsScalar())
-				return false;
-			rhs = node.Scalar();
-			return true;
-		}
-	};
-	
-	template<>
-	struct convert<_Null> {
-		static Node encode(const _Null& /* rhs */) {
-			return Node();
-		}
-		
-		static bool decode(const Node& node, _Null& /* rhs */) {
-			return node.IsNull();
-		}
-	};
-	
-#define YAML_DEFINE_CONVERT_STREAMABLE(type)\
-	template<>\
-	struct convert<type> {\
-		static Node encode(const type& rhs) {\
-			std::stringstream stream;\
-			stream << rhs;\
-			return Node(stream.str());\
-		}\
-		\
-		static bool decode(const Node& node, type& rhs) {\
-			if(node.Type() != NodeType::Scalar)\
-				return false;\
-            const std::string& input = node.Scalar();\
-			std::stringstream stream(input);\
-            stream.unsetf(std::ios::dec);\
-			if((stream >> rhs) && (stream >> std::ws).eof())\
-                return true;\
-            if(std::numeric_limits<type>::has_infinity) {\
-                if(conversion::IsInfinity(input)) {\
-                    rhs = std::numeric_limits<type>::infinity();\
-                    return true;\
-                } else if(conversion::IsNegativeInfinity(input)) {\
-                    rhs = -std::numeric_limits<type>::infinity();\
-                    return true;\
-                }\
-            }\
-            \
-            if(std::numeric_limits<type>::has_quiet_NaN && conversion::IsNaN(input)) {\
-                rhs = std::numeric_limits<type>::quiet_NaN();\
-                return true;\
-            }\
-            \
-            return false;\
-		}\
-	}
-	
-	YAML_DEFINE_CONVERT_STREAMABLE(int);
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned);
-	YAML_DEFINE_CONVERT_STREAMABLE(short);
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned short);
-	YAML_DEFINE_CONVERT_STREAMABLE(long);
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned long);
-	YAML_DEFINE_CONVERT_STREAMABLE(long long);
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned long long);
-	
-	YAML_DEFINE_CONVERT_STREAMABLE(char);
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned char);
-	
-	YAML_DEFINE_CONVERT_STREAMABLE(float);
-	YAML_DEFINE_CONVERT_STREAMABLE(double);
-	YAML_DEFINE_CONVERT_STREAMABLE(long double);
-	
-#undef YAML_DEFINE_CONVERT_STREAMABLE
-	
-	// bool
-	template<>
-	struct convert<bool> {
-		static Node encode(bool rhs) {
-			return rhs ? Node("true") : Node("false");
-		}
-		
-		static bool decode(const Node& node, bool& rhs);
-	};
+#include "yaml-cpp/binary.h"
+#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/type.h"
+#include "yaml-cpp/null.h"

-	// std::map
-	template<typename K, typename V>
-	struct convert<std::map<K, V> > {
-		static Node encode(const std::map<K, V>& rhs) {
-			Node node(NodeType::Map);
-			for(typename std::map<K, V>::const_iterator it=rhs.begin();it!=rhs.end();++it)
-                node.force_insert(it->first, it->second);
-			return node;
-		}
-		
-		static bool decode(const Node& node, std::map<K, V>& rhs) {
-			if(!node.IsMap())
-				return false;
+namespace YAML {
+class Binary;
+struct _Null;
+template <typename T>
+struct convert;
+}  // namespace YAML

-			rhs.clear();
-			for(const_iterator it=node.begin();it!=node.end();++it)
-#if defined(__GNUC__) && __GNUC__ < 4
-//workaround for GCC 3:
-				rhs[it->first.template as<K>()] = it->second.template as<V>();
-#else
-				rhs[it->first.as<K>()] = it->second.as<V>();
-#endif
-			return true;
-		}
-	};
-	
-	// std::vector
-	template<typename T>
-	struct convert<std::vector<T> > {
-		static Node encode(const std::vector<T>& rhs) {
-			Node node(NodeType::Sequence);
-			for(typename std::vector<T>::const_iterator it=rhs.begin();it!=rhs.end();++it)
-				node.push_back(*it);
-			return node;
-		}
-		
-		static bool decode(const Node& node, std::vector<T>& rhs) {
-			if(!node.IsSequence())
-				return false;
-			
-			rhs.clear();
-			for(const_iterator it=node.begin();it!=node.end();++it)
-#if defined(__GNUC__) && __GNUC__ < 4
-//workaround for GCC 3:
-				rhs.push_back(it->template as<T>());
-#else
-				rhs.push_back(it->as<T>());
-#endif
-			return true;
-		}
-	};
-	
-	// std::list
-	template<typename T>
-	struct convert<std::list<T> > {
-		static Node encode(const std::list<T>& rhs) {
-			Node node(NodeType::Sequence);
-			for(typename std::list<T>::const_iterator it=rhs.begin();it!=rhs.end();++it)
-				node.push_back(*it);
-			return node;
-		}
-		
-		static bool decode(const Node& node, std::list<T>& rhs) {
-			if(!node.IsSequence())
-				return false;
-			
-			rhs.clear();
-			for(const_iterator it=node.begin();it!=node.end();++it)
-#if defined(__GNUC__) && __GNUC__ < 4
-//workaround for GCC 3:
-				rhs.push_back(it->template as<T>());
-#else
-				rhs.push_back(it->as<T>());
-#endif
-			return true;
-		}
-	};
-    
-    // binary
-    template<>
-	struct convert<Binary> {
-		static Node encode(const Binary& rhs) {
-            return Node(EncodeBase64(rhs.data(), rhs.size()));
-		}
-		
-		static bool decode(const Node& node, Binary& rhs) {
-			if(!node.IsScalar())
-				return false;
-            
-            std::vector<unsigned char> data = DecodeBase64(node.Scalar());
-            if(data.empty() && !node.Scalar().empty())
-                return false;
-            
-            rhs.swap(data);
-            return true;
-		}
-	};
+namespace YAML {
+namespace conversion {
+inline bool IsInfinity(const std::string& input) {
+  return input == ".inf" || input == ".Inf" || input == ".INF" ||
+         input == "+.inf" || input == "+.Inf" || input == "+.INF";
 }

-#endif // NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+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";
+}
+}
+
+// std::string
+template <>
+struct convert<std::string> {
+  static Node encode(const std::string& rhs) { return Node(rhs); }
+
+  static bool decode(const Node& node, std::string& rhs) {
+    if (!node.IsScalar())
+      return false;
+    rhs = node.Scalar();
+    return true;
+  }
+};
+
+// C-strings can only be encoded
+template <>
+struct convert<const char*> {
+  static Node encode(const char*& rhs) { return Node(rhs); }
+};
+
+template <std::size_t N>
+struct convert<const char[N]> {
+  static Node encode(const char(&rhs)[N]) { return Node(rhs); }
+};
+
+template <>
+struct convert<_Null> {
+  static Node encode(const _Null& /* rhs */) { return Node(); }
+
+  static bool decode(const Node& node, _Null& /* rhs */) {
+    return node.IsNull();
+  }
+};
+
+#define YAML_DEFINE_CONVERT_STREAMABLE(type, negative_op)                \
+  template <>                                                            \
+  struct convert<type> {                                                 \
+    static Node encode(const type& rhs) {                                \
+      std::stringstream stream;                                          \
+      stream.precision(std::numeric_limits<type>::digits10 + 1);         \
+      stream << rhs;                                                     \
+      return Node(stream.str());                                         \
+    }                                                                    \
+                                                                         \
+    static bool decode(const Node& node, type& rhs) {                    \
+      if (node.Type() != NodeType::Scalar)                               \
+        return false;                                                    \
+      const std::string& input = node.Scalar();                          \
+      std::stringstream stream(input);                                   \
+      stream.unsetf(std::ios::dec);                                      \
+      if ((stream >> std::noskipws >> rhs) && (stream >> std::ws).eof()) \
+        return true;                                                     \
+      if (std::numeric_limits<type>::has_infinity) {                     \
+        if (conversion::IsInfinity(input)) {                             \
+          rhs = std::numeric_limits<type>::infinity();                   \
+          return true;                                                   \
+        } else if (conversion::IsNegativeInfinity(input)) {              \
+          rhs = negative_op std::numeric_limits<type>::infinity();       \
+          return true;                                                   \
+        }                                                                \
+      }                                                                  \
+                                                                         \
+      if (std::numeric_limits<type>::has_quiet_NaN &&                    \
+          conversion::IsNaN(input)) {                                    \
+        rhs = std::numeric_limits<type>::quiet_NaN();                    \
+        return true;                                                     \
+      }                                                                  \
+                                                                         \
+      return false;                                                      \
+    }                                                                    \
+  }
+
+#define YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(type) \
+  YAML_DEFINE_CONVERT_STREAMABLE(type, -)
+
+#define YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(type) \
+  YAML_DEFINE_CONVERT_STREAMABLE(type, +)
+
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(int);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(short);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long long);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned short);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long long);
+
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(char);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(signed char);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned char);
+
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(float);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(double);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long double);
+
+#undef YAML_DEFINE_CONVERT_STREAMABLE_SIGNED
+#undef YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED
+#undef YAML_DEFINE_CONVERT_STREAMABLE
+
+// bool
+template <>
+struct convert<bool> {
+  static Node encode(bool rhs) { return rhs ? Node("true") : Node("false"); }
+
+  YAML_CPP_API static bool decode(const Node& node, bool& rhs);
+};
+
+// std::map
+template <typename K, typename V>
+struct convert<std::map<K, V> > {
+  static Node encode(const std::map<K, V>& rhs) {
+    Node node(NodeType::Map);
+    for (typename std::map<K, V>::const_iterator it = rhs.begin();
+         it != rhs.end(); ++it)
+      node.force_insert(it->first, it->second);
+    return node;
+  }
+
+  static bool decode(const Node& node, std::map<K, V>& rhs) {
+    if (!node.IsMap())
+      return false;
+
+    rhs.clear();
+    for (const_iterator it = node.begin(); it != node.end(); ++it)
+#if defined(__GNUC__) && __GNUC__ < 4
+      // workaround for GCC 3:
+      rhs[it->first.template as<K>()] = it->second.template as<V>();
+#else
+      rhs[it->first.as<K>()] = it->second.as<V>();
+#endif
+    return true;
+  }
+};
+
+// std::vector
+template <typename T>
+struct convert<std::vector<T> > {
+  static Node encode(const std::vector<T>& rhs) {
+    Node node(NodeType::Sequence);
+    for (typename std::vector<T>::const_iterator it = rhs.begin();
+         it != rhs.end(); ++it)
+      node.push_back(*it);
+    return node;
+  }
+
+  static bool decode(const Node& node, std::vector<T>& rhs) {
+    if (!node.IsSequence())
+      return false;
+
+    rhs.clear();
+    for (const_iterator it = node.begin(); it != node.end(); ++it)
+#if defined(__GNUC__) && __GNUC__ < 4
+      // workaround for GCC 3:
+      rhs.push_back(it->template as<T>());
+#else
+      rhs.push_back(it->as<T>());
+#endif
+    return true;
+  }
+};
+
+// std::list
+template <typename T>
+struct convert<std::list<T> > {
+  static Node encode(const std::list<T>& rhs) {
+    Node node(NodeType::Sequence);
+    for (typename std::list<T>::const_iterator it = rhs.begin();
+         it != rhs.end(); ++it)
+      node.push_back(*it);
+    return node;
+  }
+
+  static bool decode(const Node& node, std::list<T>& rhs) {
+    if (!node.IsSequence())
+      return false;
+
+    rhs.clear();
+    for (const_iterator it = node.begin(); it != node.end(); ++it)
+#if defined(__GNUC__) && __GNUC__ < 4
+      // workaround for GCC 3:
+      rhs.push_back(it->template as<T>());
+#else
+      rhs.push_back(it->as<T>());
+#endif
+    return true;
+  }
+};
+
+// std::pair
+template <typename T, typename U>
+struct convert<std::pair<T, U> > {
+  static Node encode(const std::pair<T, U>& rhs) {
+    Node node(NodeType::Sequence);
+    node.push_back(rhs.first);
+    node.push_back(rhs.second);
+    return node;
+  }
+
+  static bool decode(const Node& node, std::pair<T, U>& rhs) {
+    if (!node.IsSequence())
+      return false;
+    if (node.size() != 2)
+      return false;
+
+#if defined(__GNUC__) && __GNUC__ < 4
+    // workaround for GCC 3:
+    rhs.first = node[0].template as<T>();
+#else
+    rhs.first = node[0].as<T>();
+#endif
+#if defined(__GNUC__) && __GNUC__ < 4
+    // workaround for GCC 3:
+    rhs.second = node[1].template as<U>();
+#else
+    rhs.second = node[1].as<U>();
+#endif
+    return true;
+  }
+};
+
+// binary
+template <>
+struct convert<Binary> {
+  static Node encode(const Binary& rhs) {
+    return Node(EncodeBase64(rhs.data(), rhs.size()));
+  }
+
+  static bool decode(const Node& node, Binary& rhs) {
+    if (!node.IsScalar())
+      return false;
+
+    std::vector<unsigned char> data = DecodeBase64(node.Scalar());
+    if (data.empty() && !node.Scalar().empty())
+      return false;
+
+    rhs.swap(data);
+    return true;
+  }
+};
+}
+
+#endif  // NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,26 +1,26 @@
 #ifndef NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define NODE_DETAIL_BOOL_TYPE_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
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

-namespace YAML
-{
-	namespace detail
-	{
-		struct unspecified_bool {
-			struct NOT_ALLOWED;
-			static void true_value(NOT_ALLOWED*) {}
-		};
-		typedef void (*unspecified_bool_type)(unspecified_bool::NOT_ALLOWED*);
-	}
+namespace YAML {
+namespace detail {
+struct unspecified_bool {
+  struct NOT_ALLOWED;
+  static void true_value(NOT_ALLOWED*) {}
+};
+typedef void (*unspecified_bool_type)(unspecified_bool::NOT_ALLOWED*);
+}
 }

-#define YAML_CPP_OPERATOR_BOOL()\
-operator YAML::detail::unspecified_bool_type() const\
-{\
-	return this->operator!() ? 0 : &YAML::detail::unspecified_bool::true_value;\
-}
+#define YAML_CPP_OPERATOR_BOOL()                                            \
+  operator YAML::detail::unspecified_bool_type() const {                    \
+    return this->operator!() ? 0                                            \
+                             : &YAML::detail::unspecified_bool::true_value; \
+  }

-#endif // NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#endif  // NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,163 +1,177 @@
 #ifndef NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define NODE_DETAIL_IMPL_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
+#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/node/detail/node.h"
 #include "yaml-cpp/node/detail/node_data.h"
 #include <boost/type_traits.hpp>

-namespace YAML
-{
-	namespace detail
-	{
-		template<typename Key, typename Enable = void>
-		struct get_idx {
-			static node *get(const std::vector<node *>& /* sequence */, const Key& /* key */, shared_memory_holder /* pMemory */) {
-				return 0;
-			}
-		};
+namespace YAML {
+namespace detail {
+template <typename Key, typename Enable = void>
+struct get_idx {
+  static node* get(const std::vector<node*>& /* sequence */,
+                   const Key& /* key */, shared_memory_holder /* pMemory */) {
+    return 0;
+  }
+};

-		template<typename Key>
-		struct get_idx<Key, typename boost::enable_if<boost::is_unsigned<Key> >::type> {
-			static node *get(const std::vector<node *>& sequence, const Key& key, shared_memory_holder /* pMemory */) {
-				return key < sequence.size() ? sequence[key] : 0;
-			}
+template <typename Key>
+struct get_idx<
+    Key, typename boost::enable_if_c<boost::is_unsigned<Key>::value &&
+                                     !boost::is_same<Key, bool>::value>::type> {
+  static node* get(const std::vector<node*>& sequence, const Key& key,
+                   shared_memory_holder /* pMemory */) {
+    return key < sequence.size() ? sequence[key] : 0;
+  }

-			static node *get(std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) {
-				if(key > sequence.size())
-					return 0;
-				if(key == sequence.size())
-					sequence.push_back(&pMemory->create_node());
-				return sequence[key];
-			}
-		};
-		
-		template<typename Key>
-		struct get_idx<Key, typename boost::enable_if<boost::is_signed<Key> >::type> {
-			static node *get(const std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) {
-				return key >= 0 ? get_idx<std::size_t>::get(sequence, static_cast<std::size_t>(key), pMemory) : 0;
-			}
-			static node *get(std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) {
-				return key >= 0 ? get_idx<std::size_t>::get(sequence, static_cast<std::size_t>(key), pMemory) : 0;
-			}
-		};
+  static node* get(std::vector<node*>& sequence, const Key& key,
+                   shared_memory_holder pMemory) {
+    if (key > sequence.size())
+      return 0;
+    if (key == sequence.size())
+      sequence.push_back(&pMemory->create_node());
+    return sequence[key];
+  }
+};

-		// indexing
-		template<typename Key>
-		inline node& node_data::get(const Key& key, shared_memory_holder pMemory) const
-		{
-			switch(m_type) {
-				case NodeType::Map:
-					break;
-				case NodeType::Undefined:
-				case NodeType::Null:
-					return pMemory->create_node();
-				case NodeType::Sequence:
-					if(node *pNode = get_idx<Key>::get(m_sequence, key, pMemory))
-						return *pNode;
-					return pMemory->create_node();
-				case NodeType::Scalar:
-                    throw BadSubscript();
-			}
+template <typename Key>
+struct get_idx<Key, typename boost::enable_if<boost::is_signed<Key> >::type> {
+  static node* get(const std::vector<node*>& sequence, const Key& key,
+                   shared_memory_holder pMemory) {
+    return key >= 0 ? get_idx<std::size_t>::get(
+                          sequence, static_cast<std::size_t>(key), pMemory)
+                    : 0;
+  }
+  static node* get(std::vector<node*>& sequence, const Key& key,
+                   shared_memory_holder pMemory) {
+    return key >= 0 ? get_idx<std::size_t>::get(
+                          sequence, static_cast<std::size_t>(key), pMemory)
+                    : 0;
+  }
+};

-			for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) {
-				if(equals(*it->first, key, pMemory))
-					return *it->second;
-			}
-			
-			return pMemory->create_node();
-		}
-		
-		template<typename Key>
-		inline node& node_data::get(const Key& key, shared_memory_holder pMemory)
-		{
-			switch(m_type) {
-				case NodeType::Map:
-					break;
-				case NodeType::Undefined:
-				case NodeType::Null:
-				case NodeType::Sequence:
-					if(node *pNode = get_idx<Key>::get(m_sequence, key, pMemory)) {
-						m_type = NodeType::Sequence;
-						return *pNode;
-					}
-					
-					convert_to_map(pMemory);
-					break;
-				case NodeType::Scalar:
-                    throw BadSubscript();
-			}
-			
-			for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) {
-				if(equals(*it->first, key, pMemory))
-					return *it->second;
-			}
-			
-			node& k = convert_to_node(key, pMemory);
-			node& v = pMemory->create_node();
-			insert_map_pair(k, v);
-			return v;
-		}
-		
-		template<typename Key>
-		inline bool node_data::remove(const Key& key, shared_memory_holder pMemory)
-		{
-			if(m_type != NodeType::Map)
-				return false;
-			
-			for(node_map::iterator it=m_map.begin();it!=m_map.end();++it) {
-				if(equals(*it->first, key, pMemory)) {
-					m_map.erase(it);
-					return true;
-				}
-			}
-			
-			return false;
-		}
-        
-        // map
-        template<typename Key, typename Value>
-        inline void node_data::force_insert(const Key& key, const Value& value, shared_memory_holder pMemory)
-        {
-			switch(m_type) {
-				case NodeType::Map:
-					break;
-				case NodeType::Undefined:
-				case NodeType::Null:
-				case NodeType::Sequence:
-					convert_to_map(pMemory);
-					break;
-				case NodeType::Scalar:
-                    throw BadInsert();
-			}
-			
-			node& k = convert_to_node(key, pMemory);
-			node& v = convert_to_node(value, pMemory);
-			insert_map_pair(k, v);
-        }
-
-		template<typename T>
-		inline bool node_data::equals(node& node, const T& rhs, shared_memory_holder pMemory)
-		{
-			T lhs;
-			if(convert<T>::decode(Node(node, pMemory), lhs))
-				return lhs == rhs;
-			return false;
-		}
-		
-		template<typename T>
-		inline node& node_data::convert_to_node(const T& rhs, shared_memory_holder pMemory)
-		{
-			Node value = convert<T>::encode(rhs);
-			value.EnsureNodeExists();
-			pMemory->merge(*value.m_pMemory);
-			return *value.m_pNode;
-		}
-	}
+template <typename T>
+inline bool node::equals(const T& rhs, shared_memory_holder pMemory) {
+  T lhs;
+  if (convert<T>::decode(Node(*this, pMemory), lhs)) {
+    return lhs == rhs;
+  }
+  return false;
 }

-#endif // NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+inline bool node::equals(const char* rhs, shared_memory_holder pMemory) {
+  return equals<std::string>(rhs, pMemory);
+}
+
+// indexing
+template <typename Key>
+inline node* node_data::get(const Key& key,
+                            shared_memory_holder pMemory) const {
+  switch (m_type) {
+    case NodeType::Map:
+      break;
+    case NodeType::Undefined:
+    case NodeType::Null:
+      return NULL;
+    case NodeType::Sequence:
+      if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory))
+        return pNode;
+      return NULL;
+    case NodeType::Scalar:
+      throw BadSubscript();
+  }
+
+  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
+    if (it->first->equals(key, pMemory)) {
+      return it->second;
+    }
+  }
+
+  return NULL;
+}
+
+template <typename Key>
+inline node& node_data::get(const Key& key, shared_memory_holder pMemory) {
+  switch (m_type) {
+    case NodeType::Map:
+      break;
+    case NodeType::Undefined:
+    case NodeType::Null:
+    case NodeType::Sequence:
+      if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory)) {
+        m_type = NodeType::Sequence;
+        return *pNode;
+      }
+
+      convert_to_map(pMemory);
+      break;
+    case NodeType::Scalar:
+      throw BadSubscript();
+  }
+
+  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
+    if (it->first->equals(key, pMemory)) {
+      return *it->second;
+    }
+  }
+
+  node& k = convert_to_node(key, pMemory);
+  node& v = pMemory->create_node();
+  insert_map_pair(k, v);
+  return v;
+}
+
+template <typename Key>
+inline bool node_data::remove(const Key& key, shared_memory_holder pMemory) {
+  if (m_type != NodeType::Map)
+    return false;
+
+  for (node_map::iterator it = m_map.begin(); it != m_map.end(); ++it) {
+    if (equals(*it->first, key, pMemory)) {
+      m_map.erase(it);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// map
+template <typename Key, typename Value>
+inline void node_data::force_insert(const Key& key, const Value& value,
+                                    shared_memory_holder pMemory) {
+  switch (m_type) {
+    case NodeType::Map:
+      break;
+    case NodeType::Undefined:
+    case NodeType::Null:
+    case NodeType::Sequence:
+      convert_to_map(pMemory);
+      break;
+    case NodeType::Scalar:
+      throw BadInsert();
+  }
+
+  node& k = convert_to_node(key, pMemory);
+  node& v = convert_to_node(value, pMemory);
+  insert_map_pair(k, v);
+}
+
+template <typename T>
+inline node& node_data::convert_to_node(const T& rhs,
+                                        shared_memory_holder pMemory) {
+  Node value = convert<T>::encode(rhs);
+  value.EnsureNodeExists();
+  pMemory->merge(*value.m_pMemory);
+  return *value.m_pNode;
+}
+}
+}
+
+#endif  // NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,64 +1,65 @@
 #ifndef VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define VALUE_DETAIL_ITERATOR_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
+#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/node/ptr.h"
 #include "yaml-cpp/node/detail/node_iterator.h"
 #include <boost/iterator/iterator_adaptor.hpp>
 #include <boost/utility.hpp>

-namespace YAML
-{
-	namespace detail
-	{
-		struct iterator_value;
+namespace YAML {
+namespace detail {
+struct iterator_value;

-		template<typename V>
-		class iterator_base: public boost::iterator_adaptor<
-		iterator_base<V>,
-		node_iterator,
-		V,
-		std::forward_iterator_tag,
-		V>
-		{
-		private:
-			template<typename> friend class iterator_base;
-			struct enabler {};
-			typedef typename iterator_base::base_type base_type;
-            
-        public:
-			typedef typename iterator_base::value_type value_type;
-			
-		public:
-			iterator_base() {}
-			explicit iterator_base(base_type rhs, shared_memory_holder pMemory): iterator_base::iterator_adaptor_(rhs), m_pMemory(pMemory) {}
-			
-			template<class W>
-			iterator_base(const iterator_base<W>& rhs, typename boost::enable_if<boost::is_convertible<W*, V*>, enabler>::type = enabler()): iterator_base::iterator_adaptor_(rhs.base()), m_pMemory(rhs.m_pMemory) {}
-		
-		private:
-			friend class boost::iterator_core_access;
+template <typename V>
+class iterator_base
+    : public boost::iterator_adaptor<iterator_base<V>, node_iterator, V,
+                                     std::forward_iterator_tag, V> {
+ private:
+  template <typename>
+  friend class iterator_base;
+  struct enabler {};
+  typedef typename iterator_base::base_type base_type;

-			void increment() { this->base_reference() = boost::next(this->base()); }
-			
-			value_type dereference() const {
-				const typename base_type::value_type& v = *this->base();
-				if(v.pNode)
-					return value_type(Node(*v, m_pMemory));
-				if(v.first && v.second)
-					return value_type(Node(*v.first, m_pMemory), Node(*v.second, m_pMemory));
-				return value_type();
-			}
-		
-		private:
-			shared_memory_holder m_pMemory;
-		};
-	}
+ public:
+  typedef typename iterator_base::value_type value_type;
+
+ public:
+  iterator_base() {}
+  explicit iterator_base(base_type rhs, shared_memory_holder pMemory)
+      : iterator_base::iterator_adaptor_(rhs), m_pMemory(pMemory) {}
+
+  template <class W>
+  iterator_base(const iterator_base<W>& rhs,
+                typename boost::enable_if<boost::is_convertible<W*, V*>,
+                                          enabler>::type = enabler())
+      : iterator_base::iterator_adaptor_(rhs.base()),
+        m_pMemory(rhs.m_pMemory) {}
+
+ private:
+  friend class boost::iterator_core_access;
+
+  void increment() { this->base_reference() = boost::next(this->base()); }
+
+  value_type dereference() const {
+    const typename base_type::value_type& v = *this->base();
+    if (v.pNode)
+      return value_type(Node(*v, m_pMemory));
+    if (v.first && v.second)
+      return value_type(Node(*v.first, m_pMemory), Node(*v.second, m_pMemory));
+    return value_type();
+  }
+
+ private:
+  shared_memory_holder m_pMemory;
+};
+}
 }

-#endif // VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#endif  // VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,27 +1,28 @@
 #ifndef VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define VALUE_DETAIL_ITERATOR_FWD_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
+#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 <list>
 #include <utility>
 #include <vector>

-namespace YAML
-{
-	class node;
-	
-	namespace detail {
-		struct iterator_value;
-		template<typename V> class iterator_base;
-	}
+namespace YAML {
+class node;

-	typedef detail::iterator_base<detail::iterator_value> iterator;
-	typedef detail::iterator_base<const detail::iterator_value> const_iterator;
+namespace detail {
+struct iterator_value;
+template <typename V>
+class iterator_base;
 }

-#endif // VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+typedef detail::iterator_base<detail::iterator_value> iterator;
+typedef detail::iterator_base<const detail::iterator_value> const_iterator;
+}
+
+#endif  // VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jesse Beder	998d7bf31e	Bump version to 0.5.2	2015-03-29 21:31:56 -05:00
Jesse Beder	25c466a152	Run clang-format	2015-03-29 21:27:20 -05:00
Jesse Beder	7092a0b099	Fixed linker error on Visual Studio with a shared lib by moving the static methods node_data::equals to an instance method on node.	2015-03-29 21:11:53 -05:00
Jesse Beder	25b2ed0787	Fix operator bool() exception on zombie node	2015-03-29 14:31:22 -05:00
Jesse Beder	67e37d000a	Merge from core	2015-02-21 12:34:19 -06:00
Jesse Beder	b1322770c2	Remove the extraneous gtest library from the test's link args, since gmock covers it	2015-02-21 12:33:36 -06:00
Jesse Beder	39e7b651dc	Fix test that depended on the order of map outputs	2015-02-21 12:14:53 -06:00
Jesse Beder	0970a108bd	Remove stray field	2015-01-24 17:58:58 -06:00
Jesse Beder	f9ff72dee7	Add test for an empty string not being null	2015-01-24 17:30:12 -06:00
Jesse Beder	1025f76df1	Fix memory leak when accessing a const Node with a key that doesn't exist.	2015-01-24 17:22:45 -06:00
Jesse Beder	a5e86cde59	Merge core	2015-01-24 16:30:27 -06:00
Jesse Beder	77c90a08e8	Refactor plain scalar validation in the emitter to precompute the invalid regexes	2015-01-24 16:29:57 -06:00
Jesse Beder	1006bee48a	Default-initialize all sub-iterators in node_iterator_base	2015-01-24 16:23:35 -06:00
Jesse Beder	899b6614c1	Merge from core	2015-01-24 16:07:36 -06:00
Jesse Beder	bc86fd4aec	Force null to be quoted if written as a string	2015-01-24 16:07:10 -06:00
Jesse Beder	7d932f0a10	Merge from core	2015-01-24 15:59:24 -06:00
Jesse Beder	087e0673f3	Renamed the None enumeration vaules to NoType to avoid a collision with X11's macro	2015-01-24 15:58:14 -06:00
Jesse Beder	c9729b26a4	Remove stray 'auto' that leaked in without C++11	2015-01-24 15:34:39 -06:00
Jesse Beder	f1a889a0b9	Fix initialize ordering warning	2015-01-24 15:32:04 -06:00
Jesse Beder	fcbec237c9	Add conversion for signed char	2015-01-24 15:19:49 -06:00
Jesse Beder	c324bf8a7d	Merge core	2015-01-24 14:47:29 -06:00
Jesse Beder	2b2e607118	Fix gcc warning	2015-01-24 14:47:00 -06:00
Jesse Beder	891c7338bf	Add test to CMake config	2015-01-24 14:45:40 -06:00
Jesse Beder	391111c055	Merge core	2015-01-24 14:40:55 -06:00
Jesse Beder	570ab9d3fb	Fix unused arg warnings for EmitterStyle	2015-01-24 14:39:17 -06:00
Jesse Beder	0c8a539361	Fix warnings on visual studio, including changing unsigned to std::size_t	2015-01-24 14:38:22 -06:00
Jesse Beder	9eae039c91	Merge	2015-01-24 13:24:08 -06:00
Jesse Beder	0c280724e9	Add flow/block style setting on Nodes	2015-01-24 13:11:43 -06:00
Jesse Beder	9880b608b9	Merge from core	2015-01-24 12:26:16 -06:00
Jesse Beder	ad712c4f2d	Add EmitterStyle, which will allow sequence or map style (i.e., flow or block) to be preserved between parsing and emitting	2015-01-24 12:19:20 -06:00
Jesse Beder	a397ad2925	Add yaml-cpp-config.cmake and yaml-cpp-config-version.cmake files for importing yaml-cpp into external projects (through find_package).	2015-01-24 11:21:26 -06:00
Jesse Beder	c7752ca336	Fix build warning from gcc about std::copy	2015-01-24 11:14:53 -06:00
Jesse Beder	2c340f0546	Fixed memory corruption when using a node as a key	2014-08-16 10:52:51 -05:00
Jesse Beder	1aa25e7679	Wrap the #pragma warning for msvc in an ifdef	2014-03-25 22:08:34 -05:00
Jesse Beder	541fef1545	Merge from core	2014-03-25 22:07:21 -05:00
Jesse Beder	a499d2edad	Add missing include to scanscalar.cpp	2014-03-25 22:04:53 -05:00
Jesse Beder	47af59f09c	Add dll tag to Binary	2014-03-25 22:03:27 -05:00
Jesse Beder	66e5c07b4f	Extend format build target to all build tools	2014-03-25 22:01:35 -05:00
Jesse Beder	13130ec20d	clang-format	2014-03-25 00:11:17 -05:00
Jesse Beder	dea3428ce0	Merge from core	2014-03-25 00:07:38 -05:00
Jesse Beder	edf8ebe246	Remove stray log message in cmake	2014-03-25 00:04:04 -05:00
Jesse Beder	e0b293e757	Add test and util sources to make format	2014-03-25 00:02:16 -05:00
Jesse Beder	a4a79835c9	Suppress gtest warnings on xcode	2014-03-24 23:47:46 -05:00
Jesse Beder	dc8d91ce45	Add make format target to run clang-format	2014-03-24 23:46:03 -05:00
Jesse Beder	d59586630e	Fix clang compiler settings, and properly set up warnings so they don't interfere with gtest and gmock	2014-03-24 23:34:26 -05:00
Jesse Beder	066359802b	Merge from core, and update several missing DLL exports. This does not resolve them all (in particular, node_data::equals seems to be still missing, even though it is inlined in a header, which seems strange).	2014-03-24 00:31:43 -05:00
Jesse Beder	fe8ca77a1b	Add missing DLL export, and set up gtest/gmock to properly import their symbols.	2014-03-23 23:56:17 -05:00
Jesse Beder	833f2996bc	Fix MSVC static/shared library mismatch with gtest.	2014-03-23 23:26:02 -05:00
Jesse Beder	7a68eaafd9	Disable warning: warning C4800: forcing value to bool 'true' or 'false' (performance warning) for the node test, since it really doesn't make any sense in this context. (It's exactly what we intended with the "unspecified bool type".)	2014-03-23 22:42:06 -05:00
Jesse Beder	98a181c7a7	Merge from core	2014-03-23 22:25:53 -05:00
Jesse Beder	fcfd6635b0	Removed unicode control sequence from test, since it's not guaranteed that the source code is UTF-8	2014-03-23 22:25:25 -05:00
Jesse Beder	bf6482c07e	Merge from core	2014-03-23 22:08:31 -05:00
Jesse Beder	a2a096f2f3	Add clang formatting file	2014-03-23 22:07:59 -05:00
Jesse Beder	3bd412ccc3	Merge from core	2014-03-23 20:25:13 -05:00
Jesse Beder	114db22335	Fix UTF16 parsing for multi-byte characters	2014-03-23 20:24:36 -05:00
Jesse Beder	253c80d09e	Merge from core	2014-03-23 20:17:34 -05:00
Jesse Beder	06bf012d81	clang-format	2014-03-23 20:08:54 -05:00
Jesse Beder	ad0a3311a7	Convert node tests to gtest	2014-03-23 19:21:13 -05:00
Jesse Beder	33424ecb65	Merge from core	2014-03-23 18:14:51 -05:00
Jesse Beder	d508a7cb0d	Import encoding test from old-api	2014-03-23 18:12:23 -05:00
Jesse Beder	2e8841c6fa	Merge from core	2014-03-23 16:39:33 -05:00
Jesse Beder	ad2953f660	Converted gen emitter tests to gtest, and removed the old testing framework from core	2014-03-23 16:35:26 -05:00
Jesse Beder	ebf14ec83a	Factored out HandlerTest as a base class	2014-03-23 16:26:44 -05:00
Jesse Beder	066b71a755	Factored out mock event handler	2014-03-23 16:17:16 -05:00
Jesse Beder	f946473437	Merge from core	2014-03-23 15:01:08 -05:00
Jesse Beder	90d7562be3	Fixed uninteresting mock	2014-03-23 14:50:58 -05:00
Jesse Beder	1327ce6d73	Convert core parser tests to gtest	2014-03-23 14:47:30 -05:00
Jesse Beder	05834520e5	Merge from core	2014-03-23 14:06:56 -05:00
Jesse Beder	dfa32c7f44	Renamed SpecTest to HandlerSpecTest	2014-03-23 14:06:37 -05:00
Jesse Beder	a4382b1370	Merge from core, plus convert the node spec tests to gtest	2014-03-23 14:02:51 -05:00
Jesse Beder	ace9c49e31	Convert spec tests to gtest with gmock	2014-03-23 12:49:30 -05:00
Jesse Beder	e3f120b99d	Add gmock as dependency	2014-03-23 12:04:03 -05:00
Jesse Beder	be85bb3212	Merge from core	2014-03-23 11:55:30 -05:00
Jesse Beder	f6a6f46ba4	Move EmitterTests to gtest	2014-03-23 11:49:32 -05:00
Jesse Beder	da118bbb0d	Add test for cloning a null node	2014-03-22 23:29:14 -05:00
Jesse Beder	5a24459ea1	Merge ostream_wrapper fix from core	2014-03-22 23:22:14 -05:00
Jesse Beder	80bdfa6dba	Add missing include to otream_wrapper	2014-03-22 23:21:36 -05:00
Jesse Beder	599d050eb2	Merge read fix from core	2014-03-22 23:19:07 -05:00
Jesse Beder	314baa6e13	Add missing include to read.cpp	2014-03-22 23:18:27 -05:00
Jesse Beder	4b40441cee	Run IWYU	2014-03-22 23:14:48 -05:00
Jesse Beder	8d7eb02c46	Merge IWYU from core	2014-03-22 23:08:09 -05:00
Jesse Beder	5fd25df859	Run IWYU	2014-03-22 22:46:04 -05:00
Jesse Beder	c7567b7b07	Add missing includes to node_data.h	2014-03-22 19:32:53 -05:00
Jesse Beder	d98ab9f342	Merge ostream_wrapper fix from core	2014-03-22 19:27:54 -05:00
Jesse Beder	0fbeac8f4f	Add more ostream_wrapper tests	2014-03-22 19:22:23 -05:00
Jesse Beder	396a97050d	Fix SEGV in ostream_wrapper	2014-03-22 19:15:49 -05:00
Jesse Beder	9583d1ab07	Merge gtest from core	2014-03-22 19:09:22 -05:00
Jesse Beder	db82302ed0	Add gtest, as separate set of tests (that just follow the ad-hoc tests that already exist)	2014-03-22 19:06:46 -05:00
Jesse Beder	32125697f2	Rename regex.h and regex.cpp to regex_yaml, so they don't interfere with the posix variant	2014-03-22 19:03:49 -05:00
Jesse Beder	d63ec48c8a	Run clang-format	2014-03-22 13:05:03 -05:00
Jesse Beder	3355bbb399	Merge clang-format from core	2014-03-22 13:03:18 -05:00
Jesse Beder	9b4db068bb	Run clang-format	2014-03-22 12:49:16 -05:00
Jesse Beder	5b88931143	Fixed bug while reading a single space char	2013-11-10 14:50:35 -06:00
Jesse Beder	25881c4f96	Add ifdef to check if BOOST_FOREACH is defined, and disable tests that use it if it is not available	2013-10-13 11:14:34 -05:00
Jesse Beder	0305ad13e4	Fixed crash when emitting empty node	2013-07-10 08:29:11 -05:00
Jesse Beder	dd0f2577ae	Merged make build fix from core	2013-06-18 08:20:51 -05:00
Jesse Beder	e40ed4f94e	Restrict make-specific targets to only be added with make	2013-06-18 08:12:23 -05:00
Jesse Beder	4f858a47d6	Added tag release-0.5.1 for changeset 98e9aefe6778	2013-04-13 18:45:50 -05:00
Jesse Beder	fa6a71e37f	Bumped version to 0.5.1	2013-04-13 18:37:33 -05:00
Jesse Beder	e5aa599b27	Merge null string bug fix from core, plus bug fix regarding use-after-delete for a token that seems to have been ignored.	2013-04-13 18:25:37 -05:00
Jesse Beder	2375f2c66b	Fix bug where the string "null" (without quotes) is deserialized as a string, instead of null.	2013-04-13 18:21:06 -05:00
Jesse Beder	895af26226	Fix floating point precision on input.	2013-04-13 13:10:36 -05:00
Jesse Beder	ae42def6cf	Merge to fix default precision for floats.	2013-04-13 00:09:40 -05:00
Jesse Beder	e0ae477b8f	Switch default precision to one more than the number of digits allows. See, e.g., http://stackoverflow.com/questions/4738768/printing-double-without-losing-precision.	2013-04-13 00:00:58 -05:00
Jesse Beder	434c6a5697	Add better exception reporting when incorrectly dereferencing an iterator.	2013-04-12 23:41:02 -05:00
Jesse Beder	097ac171c6	Add std::pair conversion specialization.	2013-04-02 21:04:17 -05:00
Jesse Beder	0482463569	Rename clear() to reset(), and it now takes an optional node parameter.	2013-04-02 20:39:54 -05:00
Jesse Beder	5dbcf7eeb1	Fix conversion for C-strings (both literals and normal C-strings) so it compiles on Visual Studio.	2013-04-01 22:25:53 -05:00
Jesse Beder	f5418306d6	Explicity disallow get_idx for boolean type, to avoid ambiguity with a map.	2013-04-01 22:06:09 -05:00
Jesse Beder	04937649b7	Add missing line from previous fix.	2013-04-01 21:52:32 -05:00
Jesse Beder	71f35b1104	Fix warning in Visual Studio: warning C4146: unary minus operator applied to unsigned type, result still unsigned	2013-04-01 21:43:09 -05:00
Jesse Beder	c335c8dd75	Added tag release-0.5.0 for changeset d042aa2fa32d	2012-12-28 18:59:29 -06:00